refactor Sharded and not fetch pre_compiled_cgus whtn single thread

Author: SparrowLii

compiler/rustc_codegen_ssa/src/base.rs

@@ -679,7 +679,7 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
     // This likely is a temporary measure. Once we don't have to support the
     // non-parallel compiler anymore, we can compile CGUs end-to-end in
     // parallel and get rid of the complicated scheduling logic.
-    let mut pre_compiled_cgus = if cfg!(parallel_compiler) {
+    let mut pre_compiled_cgus = if rustc_data_structures::sync::active() {
         tcx.sess.time("compile_first_CGU_batch", || {
             // Try to find one CGU to compile per thread.
             let cgus: Vec<_> = cgu_reuse

compiler/rustc_data_structures/src/sharded.rs

@@ -1,5 +1,5 @@
 use crate::fx::{FxHashMap, FxHasher};
-use crate::sync::{Lock, LockGuard};
+use crate::sync::{active, Lock, LockGuard};
 use std::borrow::Borrow;
 use std::collections::hash_map::RawEntryMut;
 use std::hash::{Hash, Hasher};
@@ -23,6 +23,7 @@ pub const SHARDS: usize = 1 << SHARD_BITS;
 /// An array of cache-line aligned inner locked structures with convenience methods.
 pub struct Sharded<T> {
     shards: [CacheAligned<Lock<T>>; SHARDS],
+    single_thread: bool,
 }
 
 impl<T: Default> Default for Sharded<T> {
@@ -35,31 +36,41 @@ impl<T: Default> Default for Sharded<T> {
 impl<T> Sharded<T> {
     #[inline]
     pub fn new(mut value: impl FnMut() -> T) -> Self {
-        Sharded { shards: [(); SHARDS].map(|()| CacheAligned(Lock::new(value()))) }
+        Sharded {
+            shards: [(); SHARDS].map(|()| CacheAligned(Lock::new(value()))),
+            single_thread: !active(),
+        }
     }
 
     /// The shard is selected by hashing `val` with `FxHasher`.
     #[inline]
     pub fn get_shard_by_value<K: Hash + ?Sized>(&self, val: &K) -> &Lock<T> {
-        if SHARDS == 1 { &self.shards[0].0 } else { self.get_shard_by_hash(make_hash(val)) }
+        if self.single_thread { &self.shards[0].0 } else { self.get_shard_by_hash(make_hash(val)) }
     }
 
     #[inline]
     pub fn get_shard_by_hash(&self, hash: u64) -> &Lock<T> {
-        &self.shards[get_shard_index_by_hash(hash)].0
-    }
-
-    #[inline]
-    pub fn get_shard_by_index(&self, i: usize) -> &Lock<T> {
-        &self.shards[i].0
+        if self.single_thread {
+            &self.shards[0].0
+        } else {
+            &self.shards[get_shard_index_by_hash(hash)].0
+        }
     }
 
     pub fn lock_shards(&self) -> Vec<LockGuard<'_, T>> {
-        (0..SHARDS).map(|i| self.shards[i].0.lock()).collect()
+        if self.single_thread {
+            vec![self.shards[0].0.lock()]
+        } else {
+            (0..SHARDS).map(|i| self.shards[i].0.lock()).collect()
+        }
     }
 
     pub fn try_lock_shards(&self) -> Option<Vec<LockGuard<'_, T>>> {
-        (0..SHARDS).map(|i| self.shards[i].0.try_lock()).collect()
+        if self.single_thread {
+            Some(vec![self.shards[0].0.try_lock()?])
+        } else {
+            (0..SHARDS).map(|i| self.shards[i].0.try_lock()).collect()
+        }
     }
 }
 
@@ -141,7 +152,7 @@ pub fn make_hash<K: Hash + ?Sized>(val: &K) -> u64 {
 /// consistently for each `Sharded` instance.
 #[inline]
 #[allow(clippy::modulo_one)]
-pub fn get_shard_index_by_hash(hash: u64) -> usize {
+fn get_shard_index_by_hash(hash: u64) -> usize {
     let hash_len = mem::size_of::<usize>();
     // Ignore the top 7 bits as hashbrown uses these and get the next SHARD_BITS highest bits.
     // hashbrown also uses the lowest bits, so we can't use those

compiler/rustc_query_system/src/dep_graph/graph.rs

@@ -1159,6 +1159,12 @@ impl<K: DepKind> CurrentDepGraph<K> {
             .get_or_alloc_cached_string("incr_comp_intern_dep_graph_node")
             .map(EventId::from_label);
 
+        let capacity = if rustc_data_structures::sync::active() {
+            new_node_count_estimate / sharded::SHARDS
+        } else {
+            new_node_count_estimate
+        };
+
         CurrentDepGraph {
             encoder: Steal::new(GraphEncoder::new(
                 encoder,
@@ -1167,10 +1173,7 @@ impl<K: DepKind> CurrentDepGraph<K> {
                 record_stats,
             )),
             new_node_to_index: Sharded::new(|| {
-                FxHashMap::with_capacity_and_hasher(
-                    new_node_count_estimate / sharded::SHARDS,
-                    Default::default(),
-                )
+                FxHashMap::with_capacity_and_hasher(capacity, Default::default())
             }),
             prev_index_to_index: Lock::new(IndexVec::from_elem_n(None, prev_graph_node_count)),
             anon_id_seed,