let SHARD = 1

Author: SparrowLii

compiler/rustc_data_structures/Cargo.toml

@@ -14,7 +14,7 @@ indexmap = { version = "1.9.3" }
 jobserver_crate = { version = "0.1.13", package = "jobserver" }
 libc = "0.2"
 measureme = "10.0.0"
-rustc-rayon-core = { version = "0.5.0", optional = true }
+rustc-rayon-core = { version = "0.5.0" }
 rustc-rayon = { version = "0.5.0", optional = true }
 rustc_arena = { path = "../rustc_arena" }
 rustc_graphviz = { path = "../rustc_graphviz" }
@@ -51,4 +51,4 @@ features = [
 memmap2 = "0.2.1"
 
 [features]
-rustc_use_parallel_compiler = ["indexmap/rustc-rayon", "rustc-rayon", "rustc-rayon-core"]
+rustc_use_parallel_compiler = ["indexmap/rustc-rayon", "rustc-rayon"]

compiler/rustc_data_structures/src/lib.rs

@@ -33,6 +33,7 @@
 #![feature(strict_provenance)]
 #![feature(ptr_alignment_type)]
 #![feature(macro_metavar_expr)]
+#![feature(mutex_unpoison)]
 #![allow(rustc::default_hash_types)]
 #![allow(rustc::potential_query_instability)]
 #![deny(rustc::untranslatable_diagnostic)]

compiler/rustc_data_structures/src/sharded.rs

@@ -3,22 +3,14 @@ use crate::sync::{CacheAligned, Lock, LockGuard};
 use std::borrow::Borrow;
 use std::collections::hash_map::RawEntryMut;
 use std::hash::{Hash, Hasher};
-use std::mem;
 
-#[cfg(parallel_compiler)]
-// 32 shards is sufficient to reduce contention on an 8-core Ryzen 7 1700,
-// but this should be tested on higher core count CPUs. How the `Sharded` type gets used
-// may also affect the ideal number of shards.
-const SHARD_BITS: usize = 5;
-
-#[cfg(not(parallel_compiler))]
 const SHARD_BITS: usize = 0;
 
 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],
+    shard: Lock<T>,
 }
 
 impl<T: Default> Default for Sharded<T> {
@@ -28,34 +20,43 @@ impl<T: Default> Default for Sharded<T> {
     }
 }
 
-impl<T> Sharded<T> {
+impl<T: Default> Sharded<T> {
     #[inline]
     pub fn new(mut value: impl FnMut() -> T) -> Self {
-        Sharded { shards: [(); SHARDS].map(|()| CacheAligned(Lock::new(value()))) }
+        Sharded { shard: Lock::new(value()) }
     }
 
     /// 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)) }
+    pub fn with_get_shard_by_value<K: Hash + ?Sized, F: FnOnce(&mut T) -> R, R>(
+        &self,
+        _val: &K,
+        f: F,
+    ) -> R {
+        self.shard.with_lock(f)
     }
 
     #[inline]
-    pub fn get_shard_by_hash(&self, hash: u64) -> &Lock<T> {
-        &self.shards[get_shard_index_by_hash(hash)].0
+    pub fn with_get_shard_by_hash<F: FnOnce(&mut T) -> R, R>(&self, _hash: u64, f: F) -> R {
+        self.shard.with_lock(f)
     }
 
     #[inline]
-    pub fn get_shard_by_index(&self, i: usize) -> &Lock<T> {
-        &self.shards[i].0
+    pub fn get_shard_by_value<K: Hash + ?Sized>(&self, _val: &K) -> &Lock<T> {
+        &self.shard
+    }
+
+    #[inline]
+    pub fn get_shard_by_hash(&self, _hash: u64) -> &Lock<T> {
+        &self.shard
     }
 
     pub fn lock_shards(&self) -> Vec<LockGuard<'_, T>> {
-        (0..SHARDS).map(|i| self.shards[i].0.lock()).collect()
+        vec![self.shard.lock()]
     }
 
     pub fn try_lock_shards(&self) -> Option<Vec<LockGuard<'_, T>>> {
-        (0..SHARDS).map(|i| self.shards[i].0.try_lock()).collect()
+        Some(vec![self.shard.try_lock()?])
     }
 }
 
@@ -75,17 +76,18 @@ impl<K: Eq + Hash + Copy> ShardedHashMap<K, ()> {
         Q: Hash + Eq,
     {
         let hash = make_hash(value);
-        let mut shard = self.get_shard_by_hash(hash).lock();
-        let entry = shard.raw_entry_mut().from_key_hashed_nocheck(hash, value);
-
-        match entry {
-            RawEntryMut::Occupied(e) => *e.key(),
-            RawEntryMut::Vacant(e) => {
-                let v = make();
-                e.insert_hashed_nocheck(hash, v, ());
-                v
+        self.with_get_shard_by_hash(hash, |shard| {
+            let entry = shard.raw_entry_mut().from_key_hashed_nocheck(hash, value);
+
+            match entry {
+                RawEntryMut::Occupied(e) => *e.key(),
+                RawEntryMut::Vacant(e) => {
+                    let v = make();
+                    e.insert_hashed_nocheck(hash, v, ());
+                    v
+                }
             }
-        }
+        })
     }
 
     #[inline]
@@ -95,17 +97,18 @@ impl<K: Eq + Hash + Copy> ShardedHashMap<K, ()> {
         Q: Hash + Eq,
     {
         let hash = make_hash(&value);
-        let mut shard = self.get_shard_by_hash(hash).lock();
-        let entry = shard.raw_entry_mut().from_key_hashed_nocheck(hash, &value);
-
-        match entry {
-            RawEntryMut::Occupied(e) => *e.key(),
-            RawEntryMut::Vacant(e) => {
-                let v = make(value);
-                e.insert_hashed_nocheck(hash, v, ());
-                v
+        self.with_get_shard_by_hash(hash, |shard| {
+            let entry = shard.raw_entry_mut().from_key_hashed_nocheck(hash, &value);
+
+            match entry {
+                RawEntryMut::Occupied(e) => *e.key(),
+                RawEntryMut::Vacant(e) => {
+                    let v = make(value);
+                    e.insert_hashed_nocheck(hash, v, ());
+                    v
+                }
             }
-        }
+        })
     }
 }
 
@@ -117,9 +120,11 @@ pub trait IntoPointer {
 impl<K: Eq + Hash + Copy + IntoPointer> ShardedHashMap<K, ()> {
     pub fn contains_pointer_to<T: Hash + IntoPointer>(&self, value: &T) -> bool {
         let hash = make_hash(&value);
-        let shard = self.get_shard_by_hash(hash).lock();
-        let value = value.into_pointer();
-        shard.raw_entry().from_hash(hash, |entry| entry.into_pointer() == value).is_some()
+
+        self.with_get_shard_by_hash(hash, |shard| {
+            let value = value.into_pointer();
+            shard.raw_entry().from_hash(hash, |entry| entry.into_pointer() == value).is_some()
+        })
     }
 }
 
@@ -130,17 +135,19 @@ pub fn make_hash<K: Hash + ?Sized>(val: &K) -> u64 {
     state.finish()
 }
 
+/*
 /// Get a shard with a pre-computed hash value. If `get_shard_by_value` is
 /// ever used in combination with `get_shard_by_hash` on a single `Sharded`
 /// instance, then `hash` must be computed with `FxHasher`. Otherwise,
 /// `hash` can be computed with any hasher, so long as that hasher is used
 /// 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
     let bits = (hash >> (hash_len * 8 - 7 - SHARD_BITS)) as usize;
     bits % SHARDS
 }
+*/