rebase and set default threads to 8

Author: SparrowLii

compiler/rustc_codegen_ssa/src/base.rs

@@ -686,7 +686,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 rustc_data_structures::sync::active() {
+    let mut pre_compiled_cgus = if rustc_data_structures::sync::is_dyn_thread_safe() {
         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::LockLike;
+use crate::sync::{DynSync, LockLike};
 use parking_lot::{Mutex, MutexGuard};
 use std::borrow::Borrow;
 use std::cell::{RefCell, RefMut};
@@ -131,13 +131,13 @@ pub struct DynSharded<T> {
     parallel_shard: ShardedImpl<T>,
 }
 
-// just for speed test
-unsafe impl<T> Sync for DynSharded<T> {}
+#[cfg(parallel_compiler)]
+unsafe impl<T> DynSync for DynSharded<T> {}
 
 impl<T: Default> Default for DynSharded<T> {
     #[inline]
     fn default() -> Self {
-        let single_thread = !crate::sync::active();
+        let single_thread = !crate::sync::is_dyn_thread_safe();
         DynSharded {
             single_thread,
             single_shard: RefCell::new(T::default()),
@@ -148,7 +148,7 @@ impl<T: Default> Default for DynSharded<T> {
 
 impl<T: Default> DynSharded<T> {
     pub fn new(mut value: impl FnMut() -> T) -> Self {
-        if !crate::sync::active() {
+        if !crate::sync::is_dyn_thread_safe() {
             DynSharded {
                 single_thread: true,
                 single_shard: RefCell::new(value()),

compiler/rustc_data_structures/src/sync.rs

@@ -65,11 +65,10 @@ mod mode {
     use super::Ordering;
     use std::sync::atomic::AtomicU8;
 
-    const UNINITIALIZED: u8 = 0;
     const DYN_NOT_THREAD_SAFE: u8 = 1;
     const DYN_THREAD_SAFE: u8 = 2;
 
-    static DYN_THREAD_SAFE_MODE: AtomicU8 = AtomicU8::new(UNINITIALIZED);
+    static DYN_THREAD_SAFE_MODE: AtomicU8 = AtomicU8::new(DYN_NOT_THREAD_SAFE);
 
     // Whether thread safety is enabled (due to running under multiple threads).
     #[inline]
@@ -84,15 +83,9 @@ mod mode {
     // Only set by the `-Z threads` compile option
     pub fn set_dyn_thread_safe_mode(mode: bool) {
         let set: u8 = if mode { DYN_THREAD_SAFE } else { DYN_NOT_THREAD_SAFE };
-        let previous = DYN_THREAD_SAFE_MODE.compare_exchange(
-            UNINITIALIZED,
-            set,
-            Ordering::Relaxed,
-            Ordering::Relaxed,
-        );
 
-        // Check that the mode was either uninitialized or was already set to the requested mode.
-        assert!(previous.is_ok() || previous == Err(set));
+        // just for speed test
+        DYN_THREAD_SAFE_MODE.store(set, Ordering::Relaxed);
     }
 }
 
@@ -337,24 +330,6 @@ cfg_if! {
             }
         }
 
-        #[inline]
-        pub fn join<A, B, RA: DynSend, RB: DynSend>(oper_a: A, oper_b: B) -> (RA, RB)
-        where
-            A: FnOnce() -> RA + DynSend,
-            B: FnOnce() -> RB + DynSend,
-        {
-            if mode::active() {
-                let oper_a = FromDyn::from(oper_a);
-                let oper_b = FromDyn::from(oper_b);
-                let (a, b) = rayon::join(move || FromDyn::from(oper_a.into_inner()()), move || FromDyn::from(oper_b.into_inner()()));
-                (a.into_inner(), b.into_inner())
-            } else {
-                (oper_a(), oper_b())
-            }
-        }
-
-        use std::thread;
-
         #[inline]
         pub fn join<A, B, RA: DynSend, RB: DynSend>(oper_a: A, oper_b: B) -> (RA, RB)
         where
@@ -385,19 +360,11 @@ cfg_if! {
         /// the current thread. Use that for the longest running block.
         #[macro_export]
         macro_rules! parallel {
-            (impl $fblock:tt [$($c:tt,)*] [$block:tt $(, $rest:tt)*]) => {
             (impl $fblock:block [$($c:expr,)*] [$block:expr $(, $rest:expr)*]) => {
                 parallel!(impl $fblock [$block, $($c,)*] [$($rest),*])
             };
-            (impl $fblock:tt [$($blocks:tt,)*] []) => {
             (impl $fblock:block [$($blocks:expr,)*] []) => {
                 ::rustc_data_structures::sync::scope(|s| {
-
-
-
-
-
-
                     $(let block = rustc_data_structures::sync::FromDyn::from(|| $blocks);
                     s.spawn(move |_| block.into_inner()());)*
                     (|| $fblock)();
@@ -421,7 +388,6 @@ cfg_if! {
                         }
                     }
                     $(
-                        s.spawn(|_| $blocks);
                         if let Err(p) = ::std::panic::catch_unwind(
                             ::std::panic::AssertUnwindSafe(|| $blocks)
                         ) {
@@ -430,19 +396,11 @@ cfg_if! {
                             }
                         }
                     )*
-                    $fblock;
-                })
                     if let Some(panic) = panic {
                         ::std::panic::resume_unwind(panic);
                     }
                 }
             };
-            ($fblock:tt, $($blocks:tt),*) => {
-                // Reverse the order of the later blocks since Rayon executes them in reverse order
-                // when using a single thread. This ensures the execution order matches that
-                // of a single threaded rustc
-                parallel!(impl $fblock [] [$($blocks),*]);
-            };
         }
 
         use rayon::iter::{FromParallelIterator, IntoParallelIterator, ParallelIterator};
@@ -453,7 +411,7 @@ cfg_if! {
         ) {
             if mode::is_dyn_thread_safe() {
                 let for_each = FromDyn::from(for_each);
-                let panic: Lock<Option<_>> = Lock::new(None);
+                let panic: Mutex<Option<_>> = Mutex::new(None);
                 t.into_par_iter().for_each(|i| if let Err(p) = catch_unwind(AssertUnwindSafe(|| for_each(i))) {
                     let mut l = panic.lock();
                     if l.is_none() {
@@ -491,7 +449,7 @@ cfg_if! {
             map: impl Fn(I) -> R + DynSync + DynSend
         ) -> C {
             if mode::is_dyn_thread_safe() {
-                let panic: Lock<Option<_>> = Lock::new(None);
+                let panic: Mutex<Option<_>> = Mutex::new(None);
                 let map = FromDyn::from(map);
                 // We catch panics here ensuring that all the loop iterations execute.
                 let r = t.into_par_iter().filter_map(|i| {
@@ -531,30 +489,6 @@ cfg_if! {
                 r
             }
         }
-
-pub unsafe trait DynSend {}
-pub unsafe trait DynSync {}
-
-unsafe impl<T> DynSend for T where T: Send {}
-unsafe impl<T> DynSync for T where T: Sync {}
-
-#[derive(Copy, Clone)]
-pub struct FromDyn<T>(T);
-
-impl<T> FromDyn<T> {
-    #[inline(always)]
-    pub fn from(val: T) -> Self {
-        // Check that `sync::active()` is true on creation so we can
-        // implement `Send` and `Sync` for this structure when `T`
-        // implements `DynSend` and `DynSync` respectively.
-        #[cfg(parallel_compiler)]
-        assert!(mode::active());
-        FromDyn(val)
-    }
-
-    #[inline(always)]
-    pub fn into_inner(self) -> T {
-        self.0
     }
 }
 
@@ -607,7 +541,7 @@ impl<T> Lock<T> {
     #[inline]
     pub fn new(val: T) -> Self {
         Lock {
-            single_thread: !active(),
+            single_thread: !is_dyn_thread_safe(),
             data: UnsafeCell::new(val),
             borrow: Cell::new(false),
             mutex: RawMutex::INIT,
@@ -725,10 +659,6 @@ impl<T: Default> Default for Lock<T> {
     }
 }
 
-// Just for speed test
-unsafe impl<T: Send> std::marker::Send for Lock<T> {}
-unsafe impl<T: Send> std::marker::Sync for Lock<T> {}
-
 pub struct LockGuard<'a, T> {
     lock: &'a Lock<T>,
     marker: PhantomData<&'a mut T>,
@@ -1037,6 +967,10 @@ pub struct RwLock<T> {
     data: UnsafeCell<T>,
 }
 
+// just for speed test
+unsafe impl<T> std::marker::Send for RwLock<T> {}
+unsafe impl<T> std::marker::Sync for RwLock<T> {}
+
 impl<T: Debug> Debug for RwLock<T> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Lock").field("data", self.read().deref()).finish()
@@ -1046,7 +980,11 @@ impl<T: Debug> Debug for RwLock<T> {
 impl<T: Default> Default for RwLock<T> {
     fn default() -> Self {
         RwLock {
-            raw: RwLockRaw { single_thread: !active(), borrow: Cell::new(0), raw: RawRwLock::INIT },
+            raw: RwLockRaw {
+                single_thread: !is_dyn_thread_safe(),
+                borrow: Cell::new(0),
+                raw: RawRwLock::INIT,
+            },
 
             data: UnsafeCell::new(T::default()),
         }
@@ -1057,7 +995,11 @@ impl<T> RwLock<T> {
     #[inline(always)]
     pub fn new(inner: T) -> Self {
         RwLock {
-            raw: RwLockRaw { single_thread: !active(), borrow: Cell::new(0), raw: RawRwLock::INIT },
+            raw: RwLockRaw {
+                single_thread: !is_dyn_thread_safe(),
+                borrow: Cell::new(0),
+                raw: RawRwLock::INIT,
+            },
 
             data: UnsafeCell::new(inner),
         }
@@ -1197,10 +1139,6 @@ impl<T> RwLock<T> {
     }
 }
 
-// just for speed test
-unsafe impl<T: Send> std::marker::Send for RwLock<T> {}
-unsafe impl<T: Send + Sync> std::marker::Sync for RwLock<T> {}
-
 // FIXME: Probably a bad idea
 impl<T: Clone> Clone for RwLock<T> {
     #[inline]
@@ -1221,7 +1159,7 @@ impl<T> WorkerLocal<T> {
     /// value this worker local should take for each thread in the thread pool.
     #[inline]
     pub fn new<F: FnMut(usize) -> T>(mut f: F) -> WorkerLocal<T> {
-        if !active() {
+        if !is_dyn_thread_safe() {
             WorkerLocal { single_thread: true, inner: Some(f(0)), mt_inner: None }
         } else {
             WorkerLocal {
@@ -1246,9 +1184,6 @@ impl<T> Deref for WorkerLocal<T> {
     }
 }
 
-// Just for speed test
-unsafe impl<T: Send> std::marker::Sync for WorkerLocal<T> {}
-
 use std::thread;
 pub use worker_local::Registry;
 
@@ -1261,10 +1196,6 @@ pub struct OneThread<T> {
     inner: T,
 }
 
-// just for speed test now
-unsafe impl<T> std::marker::Sync for OneThread<T> {}
-unsafe impl<T> std::marker::Send for OneThread<T> {}
-
 impl<T> OneThread<T> {
     #[inline(always)]
     fn check(&self) {
@@ -1273,7 +1204,7 @@ impl<T> OneThread<T> {
 
     #[inline(always)]
     pub fn new(inner: T) -> Self {
-        OneThread { single_thread: !active(), thread: thread::current().id(), inner }
+        OneThread { single_thread: !is_dyn_thread_safe(), thread: thread::current().id(), inner }
     }
 
     #[inline(always)]

compiler/rustc_data_structures/src/sync/worker_local.rs

@@ -1,4 +1,4 @@
-use crate::sync::Lock;
+use parking_lot::Mutex;
 use std::cell::Cell;
 use std::cell::OnceCell;
 use std::ops::Deref;
@@ -34,7 +34,7 @@ impl RegistryId {
 #[derive(Debug)]
 struct RegistryData {
     thread_limit: usize,
-    threads: Lock<usize>,
+    threads: Mutex<usize>,
 }
 
 /// Represents a list of threads which can access worker locals.
@@ -64,7 +64,7 @@ thread_local! {
 impl Registry {
     /// Creates a registry which can hold up to `thread_limit` threads.
     pub fn new(thread_limit: usize) -> Self {
-        Registry(Arc::new(RegistryData { thread_limit, threads: Lock::new(0) }))
+        Registry(Arc::new(RegistryData { thread_limit, threads: Mutex::new(0) }))
     }
 
     /// Gets the registry associated with the current thread. Panics if there's no such registry.

compiler/rustc_interface/src/interface.rs

@@ -72,7 +72,7 @@ pub fn set_parallel_mode(sopts1: &config::UnstableOptions, sopts2: &config::Code
         }
     };
 
-    rustc_data_structures::sync::set(parallel);
+    rustc_data_structures::sync::set_dyn_thread_safe_mode(parallel);
 }
 
 /// Converts strings provided as `--cfg [cfgspec]` into a `crate_cfg`.

compiler/rustc_interface/src/util.rs

@@ -6,6 +6,7 @@ use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 #[cfg(parallel_compiler)]
 use rustc_data_structures::sync;
+use rustc_data_structures::sync::FromDyn;
 use rustc_errors::registry::Registry;
 use rustc_parse::validate_attr;
 use rustc_session as session;
@@ -134,7 +135,7 @@ pub(crate) fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
     f: F,
 ) -> R {
     #[cfg(parallel_compiler)]
-    if rustc_data_structures::sync::active() {
+    if rustc_data_structures::sync::is_dyn_thread_safe() {
         return run_in_threads_pool_with_globals(edition, _threads, f);
     }
     // The "thread pool" is a single spawned thread in the non-parallel
@@ -203,14 +204,17 @@ pub(crate) fn run_in_threads_pool_with_globals<F: FnOnce() -> R + Send, R: Send>
     // `Send` in the parallel compiler.
     rustc_span::create_session_globals_then(edition, || {
         rustc_span::with_session_globals(|session_globals| {
+            let session_globals = FromDyn::from(session_globals);
             builder
                 .build_scoped(
                     // Initialize each new worker thread when created.
                     move |thread: rayon::ThreadBuilder| {
                         // Register the thread for use with the `WorkerLocal` type.
                         registry.register();
 
-                        rustc_span::set_session_globals_then(session_globals, || thread.run())
+                        rustc_span::set_session_globals_then(session_globals.into_inner(), || {
+                            thread.run()
+                        })
                     },
                     // Run `f` on the first thread in the thread pool.
                     move |pool: &rayon::ThreadPool| pool.install(f),

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -2233,7 +2233,7 @@ pub fn encode_metadata(tcx: TyCtxt<'_>, path: &Path) {
     join(
         || encode_metadata_impl(tcx, path),
         || {
-            if !rustc_data_structures::sync::active() {
+            if !rustc_data_structures::sync::is_dyn_thread_safe() {
                 return;
             }
             // Prefetch some queries used by metadata encoding.

compiler/rustc_middle/src/query/mod.rs

@@ -54,6 +54,7 @@ use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_attr as attr;
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap, FxIndexSet};
+use rustc_data_structures::sharded::{Shard, Sharded, SingleShard};
 use rustc_data_structures::steal::Steal;
 use rustc_data_structures::svh::Svh;
 use rustc_data_structures::sync::Lrc;
@@ -80,6 +81,7 @@ use rustc_span::symbol::Symbol;
 use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi;
 use rustc_target::spec::PanicStrategy;
+use std::intrinsics::likely;
 use std::mem;
 use std::ops::Deref;
 use std::path::PathBuf;