close parallel compilation for Incremental

Author: SparrowLii

compiler/rustc_data_structures/src/sync.rs

@@ -53,14 +53,13 @@ mod worker_local;
 
 pub use std::sync::atomic::Ordering;
 pub use std::sync::atomic::Ordering::SeqCst;
-use std::sync::{Mutex, MutexGuard};
 
 pub use vec::{AppendOnlyIndexVec, AppendOnlyVec};
 
 mod vec;
 use parking_lot::lock_api::RawMutex as _;
 use parking_lot::lock_api::RawRwLock as _;
-use parking_lot::{RawMutex, RawRwLock};
+use parking_lot::{Mutex, MutexGuard, RawMutex, RawRwLock};
 
 mod mode {
     use super::Ordering;
@@ -644,7 +643,7 @@ impl<T> Lock<T> {
         }
     }
 
-    #[inline(never)]
+    #[inline]
     fn lock_raw(&self) {
         if likely(self.single_thread) {
             assert!(!self.borrow.replace(true));
@@ -660,7 +659,7 @@ impl<T> Lock<T> {
         LockGuard { lock: &self, marker: PhantomData }
     }
 
-    #[inline(never)]
+    #[inline]
     pub(crate) fn with_mt_lock<F: FnOnce(&mut T) -> R, R>(&self, f: F) -> R {
         unsafe {
             self.mutex.lock();
@@ -683,7 +682,7 @@ impl<T> Lock<T> {
         }
     }
 
-    #[inline(never)]
+    #[inline]
     fn with_mt_borrow<F: FnOnce(&T) -> R, R>(&self, f: F) -> R {
         unsafe {
             self.mutex.lock();
@@ -751,7 +750,7 @@ impl<T> DerefMut for LockGuard<'_, T> {
     }
 }
 
-#[inline(never)]
+#[inline]
 fn unlock_mt<T>(guard: &mut LockGuard<'_, T>) {
     unsafe { guard.lock.mutex.unlock() }
 }
@@ -842,26 +841,23 @@ impl<T> LockLike<T> for Mutex<T> {
 
     #[inline]
     fn into_inner(self) -> T {
-        self.into_inner().unwrap()
+        self.into_inner()
     }
 
     #[inline]
     fn get_mut(&mut self) -> &mut T {
-        self.get_mut().unwrap()
+        self.get_mut()
     }
 
     #[inline]
     fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
-        self.try_lock().ok()
+        self.try_lock()
     }
 
     #[inline(always)]
     #[track_caller]
     fn lock(&self) -> MutexGuard<'_, T> {
-        self.lock().unwrap_or_else(|e| {
-            self.clear_poison();
-            e.into_inner()
-        })
+        self.lock()
     }
 }
 
@@ -1095,7 +1091,7 @@ impl<T> RwLock<T> {
         self.data.get_mut()
     }
 
-    #[inline(never)]
+    #[inline]
     fn mt_read(&self) -> ReadGuard<'_, T> {
         self.raw.raw.lock_shared();
         ReadGuard { rwlock: self, marker: PhantomData }
@@ -1113,7 +1109,7 @@ impl<T> RwLock<T> {
         }
     }
 
-    #[inline(never)]
+    #[inline]
     fn with_mt_read_lock<F: FnOnce(&T) -> R, R>(&self, f: F) -> R {
         self.raw.raw.lock_shared();
         let r = unsafe { f(&*self.data.get()) };
@@ -1157,7 +1153,7 @@ impl<T> RwLock<T> {
         }
     }
 
-    #[inline(never)]
+    #[inline]
     fn mt_write(&self) -> WriteGuard<'_, T> {
         self.raw.raw.lock_exclusive();
         WriteGuard { rwlock: self, marker: PhantomData }
@@ -1173,7 +1169,7 @@ impl<T> RwLock<T> {
         }
     }
 
-    #[inline(never)]
+    #[inline]
     pub fn with_mt_write_lock<F: FnOnce(&mut T) -> R, R>(&self, f: F) -> R {
         self.raw.raw.lock_exclusive();
         unsafe {

compiler/rustc_driver_impl/src/lib.rs

@@ -257,7 +257,7 @@ fn run_compiler(
     let sopts = config::build_session_options(&matches);
 
     // Set parallel mode before thread pool creation, which will create `Lock`s.
-    interface::set_parallel_mode(&sopts.unstable_opts);
+    interface::set_parallel_mode(&sopts.unstable_opts, &sopts.cg);
 
     if let Some(ref code) = matches.opt_str("explain") {
         handle_explain(diagnostics_registry(), code, sopts.error_format);

compiler/rustc_interface/src/interface.rs

@@ -61,8 +61,18 @@ impl Compiler {
 }
 
 #[allow(rustc::bad_opt_access)]
-pub fn set_parallel_mode(sopts: &config::UnstableOptions) {
-    rustc_data_structures::sync::set(sopts.threads > 1);
+pub fn set_parallel_mode(sopts1: &config::UnstableOptions, sopts2: &config::CodegenOptions) {
+    let parallel = if sopts1.threads <= 1 {
+        false
+    } else {
+        if let Some(path) = &sopts2.incremental {
+            if matches!(std::fs::try_exists(PathBuf::from(path)), Ok(false)) { true } else { false }
+        } else {
+            true
+        }
+    };
+
+    rustc_data_structures::sync::set(parallel);
 }
 
 /// Converts strings provided as `--cfg [cfgspec]` into a `crate_cfg`.

compiler/rustc_interface/src/lib.rs

@@ -4,6 +4,7 @@
 #![feature(thread_spawn_unchecked)]
 #![feature(lazy_cell)]
 #![feature(try_blocks)]
+#![feature(fs_try_exists)]
 #![recursion_limit = "256"]
 #![allow(rustc::potential_query_instability)]
 #![deny(rustc::untranslatable_diagnostic)]

compiler/rustc_interface/src/util.rs

@@ -134,7 +134,7 @@ pub(crate) fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
     f: F,
 ) -> R {
     #[cfg(parallel_compiler)]
-    if _threads > 1 {
+    if rustc_data_structures::sync::active() {
         return run_in_threads_pool_with_globals(edition, _threads, f);
     }
     // The "thread pool" is a single spawned thread in the non-parallel

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 tcx.sess.threads() == 1 {
+            if !rustc_data_structures::sync::active() {
                 return;
             }
             // Prefetch some queries used by metadata encoding.

compiler/rustc_query_system/src/query/job.rs

@@ -612,7 +612,7 @@ pub(crate) fn report_cycle<'a, D: DepKind>(
 }
 
 pub fn print_query_stack<Qcx: QueryContext>(
-    qcx: Qcx,
+    _qcx: Qcx,
     mut current_query: Option<QueryJobId>,
     handler: &Handler,
     num_frames: Option<usize>,
@@ -621,7 +621,12 @@ pub fn print_query_stack<Qcx: QueryContext>(
     // a panic hook, which means that the global `Handler` may be in a weird
     // state if it was responsible for triggering the panic.
     let mut i = 0;
-    let query_map = qcx.try_collect_active_jobs();
+
+    #[cfg(not(parallel_compiler))]
+    let query_map = _qcx.try_collect_active_jobs();
+
+    #[cfg(parallel_compiler)]
+    let query_map: Option<QueryMap<Qcx::DepKind>> = None;
 
     while let Some(query) = current_query {
         if Some(i) == num_frames {

compiler/rustc_query_system/src/query/plumbing.rs

@@ -304,7 +304,7 @@ where
     // re-executing the query since `try_start` only checks that the query is not currently
     // executing, but another thread may have already completed the query and stores it result
     // in the query cache.
-    if cfg!(parallel_compiler) && qcx.dep_context().sess().threads() > 1 {
+    if cfg!(parallel_compiler) && rustc_data_structures::sync::active() {
         if let Some((value, index)) = query.look_up(qcx, &key) {
             qcx.dep_context().profiler().query_cache_hit(index.into());
             return (value, Some(index));

compiler/rustc_session/src/options.rs

@@ -1748,7 +1748,7 @@ options! {
     /// in the future. Note that -Zthreads=0 is the way to get
     /// the num_cpus behavior.
     #[rustc_lint_opt_deny_field_access("use `Session::threads` instead of this field")]
-    threads: usize = (1, parse_threads, [UNTRACKED],
+    threads: usize = (2, parse_threads, [UNTRACKED],
         "use a thread pool with N threads"),
     time_llvm_passes: bool = (false, parse_bool, [UNTRACKED],
         "measure time of each LLVM pass (default: no)"),

src/librustdoc/lib.rs

@@ -738,7 +738,7 @@ fn main_args(at_args: &[String]) -> MainResult {
     };
 
     // Set parallel mode before error handler creation, which will create `Lock`s.
-    interface::set_parallel_mode(&options.unstable_opts);
+    interface::set_parallel_mode(&options.unstable_opts, &options.codegen_options);
 
     let diag = core::new_handler(
         options.error_format,