Make copy_cgu_workproducts_to_incr_comp_cache_dir parallel

Author: Zoxc

src/librustc_codegen_ssa/back/write.rs

@@ -21,7 +21,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::profiling::VerboseTimingGuard;
 use rustc_data_structures::svh::Svh;
-use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::sync::{par_partition, Lrc};
 use rustc_errors::emitter::Emitter;
 use rustc_errors::{DiagnosticId, FatalError, Handler, Level};
 use rustc_fs_util::link_or_copy;
@@ -239,7 +239,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
     pub worker: usize,
     // The incremental compilation session directory, or None if we are not
     // compiling incrementally
-    pub incr_comp_session_dir: Option<PathBuf>,
+    pub incr_comp_session_dir: Option<Arc<PathBuf>>,
     // Used to update CGU re-use information during the thinlto phase.
     pub cgu_reuse_tracker: CguReuseTracker,
     // Channel back to the main control thread to send messages to
@@ -473,32 +473,47 @@ fn copy_all_cgu_workproducts_to_incr_comp_cache_dir(
     sess: &Session,
     compiled_modules: &CompiledModules,
 ) -> FxHashMap<WorkProductId, WorkProduct> {
-    let mut work_products = FxHashMap::default();
-
     if sess.opts.incremental.is_none() {
-        return work_products;
+        return FxHashMap::default();
     }
 
-    let _timer = sess.timer("incr_comp_copy_cgu_workproducts");
+    let _timer = sess.timer("incr_comp_copy_all_cgu_workproducts");
 
-    for module in compiled_modules.modules.iter().filter(|m| m.kind == ModuleKind::Regular) {
-        let mut files = vec![];
+    let session_dir = sess.incr_comp_session_dir();
 
-        if let Some(ref path) = module.object {
-            files.push((WorkProductFileKind::Object, path.clone()));
-        }
-        if let Some(ref path) = module.bytecode {
-            files.push((WorkProductFileKind::Bytecode, path.clone()));
-        }
-        if let Some(ref path) = module.bytecode_compressed {
-            files.push((WorkProductFileKind::BytecodeCompressed, path.clone()));
-        }
+    // Split the modules into 3 parts, which limits usage to 3 threads.
+    // That seems to be all Windows' file system can handle.
+    let work_product_chunks = par_partition(&compiled_modules.modules, 3, |chunk| {
+        chunk
+            .iter()
+            .filter(|m| m.kind == ModuleKind::Regular)
+            .filter_map(|module| {
+                let mut files = vec![];
 
-        if let Some((id, product)) =
-            copy_cgu_workproducts_to_incr_comp_cache_dir(sess, &module.name, &files)
-        {
-            work_products.insert(id, product);
-        }
+                if let Some(ref path) = module.object {
+                    files.push((WorkProductFileKind::Object, path.clone()));
+                }
+                if let Some(ref path) = module.bytecode {
+                    files.push((WorkProductFileKind::Bytecode, path.clone()));
+                }
+                if let Some(ref path) = module.bytecode_compressed {
+                    files.push((WorkProductFileKind::BytecodeCompressed, path.clone()));
+                }
+
+                copy_cgu_workproducts_to_incr_comp_cache_dir(
+                    sess,
+                    &session_dir,
+                    &module.name,
+                    &files,
+                )
+            })
+            .collect::<Vec<_>>()
+    });
+
+    let mut work_products = FxHashMap::default();
+
+    for (id, product) in work_product_chunks.into_iter().flat_map(|chunk| chunk.into_iter()) {
+        work_products.insert(id, product);
     }
 
     work_products
@@ -1029,7 +1044,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
         exported_symbols,
         remark: sess.opts.cg.remark.clone(),
         worker: 0,
-        incr_comp_session_dir: sess.incr_comp_session_dir_opt().map(|r| r.clone()),
+        incr_comp_session_dir: sess.incr_comp_session_dir_opt(),
         cgu_reuse_tracker: sess.cgu_reuse_tracker.clone(),
         coordinator_send,
         diag_emitter: shared_emitter.clone(),

src/librustc_incremental/persist/fs.rs

@@ -310,7 +310,7 @@ pub fn finalize_session_directory(sess: &Session, svh: Svh) {
 
     let _timer = sess.timer("incr_comp_finalize_session_directory");
 
-    let incr_comp_session_dir: PathBuf = sess.incr_comp_session_dir().clone();
+    let incr_comp_session_dir = sess.incr_comp_session_dir();
 
     if sess.has_errors_or_delayed_span_bugs() {
         // If there have been any errors during compilation, we don't want to

src/librustc_incremental/persist/work_product.rs

@@ -5,10 +5,11 @@ use rustc::dep_graph::{WorkProduct, WorkProductFileKind, WorkProductId};
 use rustc::session::Session;
 use rustc_fs_util::link_or_copy;
 use std::fs as std_fs;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 pub fn copy_cgu_workproducts_to_incr_comp_cache_dir(
     sess: &Session,
+    session_dir: &Path,
     cgu_name: &str,
     files: &[(WorkProductFileKind, PathBuf)],
 ) -> Option<(WorkProductId, WorkProduct)> {
@@ -17,6 +18,8 @@ pub fn copy_cgu_workproducts_to_incr_comp_cache_dir(
         return None;
     }
 
+    let _timer = sess.prof.generic_activity("incr_comp_copy_cgu_workproducts");
+
     let saved_files = files
         .iter()
         .map(|&(kind, ref path)| {
@@ -26,7 +29,7 @@ pub fn copy_cgu_workproducts_to_incr_comp_cache_dir(
                 WorkProductFileKind::BytecodeCompressed => "bc.z",
             };
             let file_name = format!("{}.{}", cgu_name, extension);
-            let path_in_incr_dir = in_incr_comp_dir_sess(sess, &file_name);
+            let path_in_incr_dir = session_dir.join(&file_name);
             match link_or_copy(path, &path_in_incr_dir) {
                 Ok(_) => Some((kind, file_name)),
                 Err(err) => {

src/librustc_session/session.rs

@@ -34,7 +34,7 @@ use rustc_data_structures::profiling::{SelfProfiler, SelfProfilerRef};
 use rustc_target::spec::{PanicStrategy, RelroLevel, Target, TargetTriple};
 
 use std;
-use std::cell::{self, RefCell};
+use std::cell::RefCell;
 use std::env;
 use std::fmt;
 use std::io::Write;
@@ -94,7 +94,7 @@ pub struct Session {
     /// macro name and definition span in the source crate.
     pub imported_macro_spans: OneThread<RefCell<FxHashMap<Span, (String, Span)>>>,
 
-    incr_comp_session: OneThread<RefCell<IncrCompSession>>,
+    incr_comp_session: Lock<IncrCompSession>,
     /// Used for incremental compilation tests. Will only be populated if
     /// `-Zquery-dep-graph` is specified.
     pub cgu_reuse_tracker: CguReuseTracker,
@@ -599,53 +599,41 @@ impl Session {
         )
     }
 
-    pub fn set_incr_session_load_dep_graph(&self, load: bool) {
-        let mut incr_comp_session = self.incr_comp_session.borrow_mut();
-
-        if let IncrCompSession::Active { ref mut load_dep_graph, .. } = *incr_comp_session {
-            *load_dep_graph = load;
-        }
-    }
-
-    pub fn incr_session_load_dep_graph(&self) -> bool {
-        let incr_comp_session = self.incr_comp_session.borrow();
-        match *incr_comp_session {
-            IncrCompSession::Active { load_dep_graph, .. } => load_dep_graph,
-            _ => false,
-        }
-    }
-
     pub fn init_incr_comp_session(
         &self,
         session_dir: PathBuf,
         lock_file: flock::Lock,
         load_dep_graph: bool,
     ) {
-        let mut incr_comp_session = self.incr_comp_session.borrow_mut();
+        let mut incr_comp_session = self.incr_comp_session.lock();
 
         if let IncrCompSession::NotInitialized = *incr_comp_session {
         } else {
             panic!("Trying to initialize IncrCompSession `{:?}`", *incr_comp_session)
         }
 
-        *incr_comp_session =
-            IncrCompSession::Active { session_directory: session_dir, lock_file, load_dep_graph };
+        *incr_comp_session = IncrCompSession::Active {
+            session_directory: Arc::new(session_dir),
+            lock_file,
+            load_dep_graph,
+        };
     }
 
     pub fn finalize_incr_comp_session(&self, new_directory_path: PathBuf) {
-        let mut incr_comp_session = self.incr_comp_session.borrow_mut();
+        let mut incr_comp_session = self.incr_comp_session.lock();
 
         if let IncrCompSession::Active { .. } = *incr_comp_session {
         } else {
             panic!("trying to finalize `IncrCompSession` `{:?}`", *incr_comp_session);
         }
 
         // Note: this will also drop the lock file, thus unlocking the directory.
-        *incr_comp_session = IncrCompSession::Finalized { session_directory: new_directory_path };
+        *incr_comp_session =
+            IncrCompSession::Finalized { session_directory: Arc::new(new_directory_path) };
     }
 
     pub fn mark_incr_comp_session_as_invalid(&self) {
-        let mut incr_comp_session = self.incr_comp_session.borrow_mut();
+        let mut incr_comp_session = self.incr_comp_session.lock();
 
         let session_directory = match *incr_comp_session {
             IncrCompSession::Active { ref session_directory, .. } => session_directory.clone(),
@@ -657,22 +645,21 @@ impl Session {
         *incr_comp_session = IncrCompSession::InvalidBecauseOfErrors { session_directory };
     }
 
-    pub fn incr_comp_session_dir(&self) -> cell::Ref<'_, PathBuf> {
-        let incr_comp_session = self.incr_comp_session.borrow();
-        cell::Ref::map(incr_comp_session, |incr_comp_session| match *incr_comp_session {
-            IncrCompSession::NotInitialized => panic!(
-                "trying to get session directory from `IncrCompSession`: {:?}",
-                *incr_comp_session,
-            ),
+    pub fn incr_comp_session_dir(&self) -> Arc<PathBuf> {
+        let session = self.incr_comp_session.lock();
+        match *session {
+            IncrCompSession::NotInitialized => {
+                panic!("trying to get session directory from `IncrCompSession`: {:?}", *session)
+            }
             IncrCompSession::Active { ref session_directory, .. }
             | IncrCompSession::Finalized { ref session_directory }
             | IncrCompSession::InvalidBecauseOfErrors { ref session_directory } => {
-                session_directory
+                session_directory.clone()
             }
-        })
+        }
     }
 
-    pub fn incr_comp_session_dir_opt(&self) -> Option<cell::Ref<'_, PathBuf>> {
+    pub fn incr_comp_session_dir_opt(&self) -> Option<Arc<PathBuf>> {
         self.opts.incremental.as_ref().map(|_| self.incr_comp_session_dir())
     }
 
@@ -1050,7 +1037,7 @@ fn build_session_(
         recursion_limit: Once::new(),
         type_length_limit: Once::new(),
         imported_macro_spans: OneThread::new(RefCell::new(FxHashMap::default())),
-        incr_comp_session: OneThread::new(RefCell::new(IncrCompSession::NotInitialized)),
+        incr_comp_session: Lock::new(IncrCompSession::NotInitialized),
         cgu_reuse_tracker,
         prof,
         perf_stats: PerfStats {
@@ -1188,14 +1175,14 @@ pub enum IncrCompSession {
     NotInitialized,
     /// This is the state during which the session directory is private and can
     /// be modified.
-    Active { session_directory: PathBuf, lock_file: flock::Lock, load_dep_graph: bool },
+    Active { session_directory: Arc<PathBuf>, lock_file: flock::Lock, load_dep_graph: bool },
     /// This is the state after the session directory has been finalized. In this
     /// state, the contents of the directory must not be modified any more.
-    Finalized { session_directory: PathBuf },
+    Finalized { session_directory: Arc<PathBuf> },
     /// This is an error state that is reached when some compilation error has
     /// occurred. It indicates that the contents of the session directory must
     /// not be used, since they might be invalid.
-    InvalidBecauseOfErrors { session_directory: PathBuf },
+    InvalidBecauseOfErrors { session_directory: Arc<PathBuf> },
 }
 
 pub fn early_error(output: config::ErrorOutputType, msg: &str) -> ! {