with lock

Author: SparrowLii

compiler/rustc_data_structures/src/sharded.rs

@@ -34,6 +34,14 @@ impl<T: Default> Default for Sharded<T> {
 impl<T: Default> Sharded<T> {
     #[inline]
     pub fn new(mut value: impl FnMut() -> T) -> Self {
+        Sharded {
+            single_thread: !active(),
+            shard: Lock::new(value()),
+            shards: [(); SHARDS].map(|()| CacheAligned(Lock::new(value()))),
+        }
+    }
+
+    pub fn with_new(mut value: impl FnMut() -> T) -> Self {
         if likely(!active()) {
             Sharded {
                 single_thread: !active(),
@@ -114,7 +122,7 @@ pub type ShardedHashMap<K, V> = Sharded<FxHashMap<K, V>>;
 
 impl<K: Eq, V> ShardedHashMap<K, V> {
     pub fn len(&self) -> usize {
-        self.lock_shards().iter().map(|shard| shard.len()).sum()
+        self.lock_shards().iter().map(|shard| shard.deref().len()).sum()
     }
 }
 

compiler/rustc_data_structures/src/sync.rs

@@ -437,6 +437,7 @@ cfg_if! {
                 let panic: Lock<Option<_>> = Lock::new(None);
                 t.into_par_iter().for_each(|i| if let Err(p) = catch_unwind(AssertUnwindSafe(|| for_each(i))) {
                     let mut l = panic.lock();
+                    let l = l .deref_mut();
                     if l.is_none() {
                         *l = Some(p)
                     }
@@ -480,6 +481,7 @@ cfg_if! {
                         Ok(r) => Some(r),
                         Err(p) => {
                             let mut l = panic.lock();
+                            let l = l.deref_mut();
                             if l.is_none() {
                                 *l = Some(p);
                             }
@@ -599,7 +601,7 @@ pub struct Lock<T> {
 impl<T: Debug> Debug for Lock<T> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self.try_lock() {
-            Some(guard) => f.debug_struct("Lock").field("data", &&*guard).finish(),
+            Some(guard) => f.debug_struct("Lock").field("data", guard.deref()).finish(),
             None => {
                 struct LockedPlaceholder;
                 impl Debug for LockedPlaceholder {
@@ -740,7 +742,7 @@ impl<T: Default> Default for Lock<T> {
 impl<T: Clone> Clone for Lock<T> {
     #[inline]
     fn clone(&self) -> Self {
-        Lock::new(self.borrow().clone())
+        Lock::new(self.borrow().deref().clone())
     }
 }
 
@@ -753,16 +755,12 @@ pub struct LockGuard<'a, T> {
     marker: PhantomData<&'a mut T>,
 }
 
-impl<T> const Deref for LockGuard<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
+impl<T> LockGuard<'_, T> {
+    pub const fn deref(&self) -> &T {
         unsafe { &*self.lock.data.get() }
     }
-}
 
-impl<T> const DerefMut for LockGuard<'_, T> {
-    fn deref_mut(&mut self) -> &mut T {
+    pub const fn deref_mut(&mut self) -> &mut T {
         unsafe { &mut *self.lock.data.get() }
     }
 }

compiler/rustc_query_system/src/dep_graph/graph.rs

@@ -1143,7 +1143,7 @@ impl<K: DepKind> CurrentDepGraph<K> {
                 record_graph,
                 record_stats,
             )),
-            new_node_to_index: Sharded::new(|| {
+            new_node_to_index: Sharded::with_new(|| {
                 FxHashMap::with_capacity_and_hasher(capacity, Default::default())
             }),
             prev_index_to_index: Lock::new(IndexVec::from_elem_n(None, prev_graph_node_count)),

compiler/rustc_span/src/lib.rs

@@ -1354,7 +1354,7 @@ impl<S: Encoder> Encodable<S> for SourceFile {
         self.end_pos.encode(s);
 
         // We are always in `Lines` form by the time we reach here.
-        assert!(self.lines.borrow().is_lines());
+        assert!(self.lines.with_borrow(|lines| lines.is_lines()));
         self.lines(|lines| {
             // Store the length.
             s.emit_u32(lines.len() as u32);
@@ -1521,8 +1521,7 @@ impl SourceFile {
     where
         F: FnOnce(&[BytePos]) -> R,
     {
-        let mut guard = self.lines.borrow_mut();
-        match &*guard {
+        let f = |guard: &mut SourceFileLines| match guard {
             SourceFileLines::Lines(lines) => f(lines),
             SourceFileLines::Diffs(SourceFileDiffs {
                 mut line_start,
@@ -1531,21 +1530,21 @@ impl SourceFile {
                 raw_diffs,
             }) => {
                 // Convert from "diffs" form to "lines" form.
-                let num_lines = num_diffs + 1;
+                let num_lines = *num_diffs + 1;
                 let mut lines = Vec::with_capacity(num_lines);
                 lines.push(line_start);
 
-                assert_eq!(*num_diffs, raw_diffs.len() / bytes_per_diff);
-                match bytes_per_diff {
+                assert_eq!(*num_diffs, raw_diffs.len() / *bytes_per_diff);
+                match *bytes_per_diff {
                     1 => {
-                        lines.extend(raw_diffs.into_iter().map(|&diff| {
+                        lines.extend(*raw_diffs.into_iter().map(|diff| {
                             line_start = line_start + BytePos(diff as u32);
                             line_start
                         }));
                     }
                     2 => {
                         lines.extend((0..*num_diffs).map(|i| {
-                            let pos = bytes_per_diff * i;
+                            let pos = *bytes_per_diff * i;
                             let bytes = [raw_diffs[pos], raw_diffs[pos + 1]];
                             let diff = u16::from_le_bytes(bytes);
                             line_start = line_start + BytePos(diff as u32);
@@ -1554,7 +1553,7 @@ impl SourceFile {
                     }
                     4 => {
                         lines.extend((0..*num_diffs).map(|i| {
-                            let pos = bytes_per_diff * i;
+                            let pos = *bytes_per_diff * i;
                             let bytes = [
                                 raw_diffs[pos],
                                 raw_diffs[pos + 1],
@@ -1572,7 +1571,8 @@ impl SourceFile {
                 *guard = SourceFileLines::Lines(lines);
                 res
             }
-        }
+        };
+        self.lines.with_lock(f)
     }
 
     /// Returns the `BytePos` of the beginning of the current line.
@@ -1590,15 +1590,15 @@ impl SourceFile {
         F: FnOnce() -> Option<String>,
     {
         if matches!(
-            *self.external_src.borrow(),
+            *self.external_src.borrow().deref(),
             ExternalSource::Foreign { kind: ExternalSourceKind::AbsentOk, .. }
         ) {
             let src = get_src();
             let mut external_src = self.external_src.borrow_mut();
             // Check that no-one else have provided the source while we were getting it
             if let ExternalSource::Foreign {
                 kind: src_kind @ ExternalSourceKind::AbsentOk, ..
-            } = &mut *external_src
+            } = external_src.deref_mut()
             {
                 if let Some(mut src) = src {
                     // The src_hash needs to be computed on the pre-normalized src.
@@ -1613,10 +1613,10 @@ impl SourceFile {
 
                 false
             } else {
-                self.src.is_some() || external_src.get_source().is_some()
+                self.src.is_some() || external_src.deref().get_source().is_some()
             }
         } else {
-            self.src.is_some() || self.external_src.borrow().get_source().is_some()
+            self.src.is_some() || self.external_src.with_borrow(|src| src.get_source().is_some())
         }
     }
 
@@ -1642,7 +1642,7 @@ impl SourceFile {
 
         if let Some(ref src) = self.src {
             Some(Cow::from(get_until_newline(src, begin)))
-        } else if let Some(src) = self.external_src.borrow().get_source() {
+        } else if let Some(src) = self.external_src.with_borrow(|src| src.get_source()) {
             Some(Cow::Owned(String::from(get_until_newline(src, begin))))
         } else {
             None