Auto merge of #56765 - Zoxc:pq-test, r=<try>

[do not merge] Test parallel queries

Let's see if I have more luck

r? @michaelwoerister

Author: bors

src/bootstrap/config.rs

@@ -553,7 +553,7 @@ impl Config {
             set(&mut config.lld_enabled, rust.lld);
             set(&mut config.lldb_enabled, rust.lldb);
             set(&mut config.llvm_tools_enabled, rust.llvm_tools);
-            config.rustc_parallel_queries = rust.experimental_parallel_queries.unwrap_or(false);
+            config.rustc_parallel_queries = rust.experimental_parallel_queries.unwrap_or(true);
             config.rustc_default_linker = rust.default_linker.clone();
             config.musl_root = rust.musl_root.clone().map(PathBuf::from);
             config.save_toolstates = rust.save_toolstates.clone().map(PathBuf::from);

src/librustc/dep_graph/dep_node.rs

@@ -434,17 +434,6 @@ impl DefId {
     }
 }
 
-impl DepKind {
-    #[inline]
-    pub fn fingerprint_needed_for_crate_hash(self) -> bool {
-        match self {
-            DepKind::HirBody |
-            DepKind::Krate => true,
-            _ => false,
-        }
-    }
-}
-
 define_dep_nodes!( <'tcx>
     // We use this for most things when incr. comp. is turned off.
     [] Null,

src/librustc/dep_graph/graph.rs

@@ -29,14 +29,11 @@ impl PreviousDepGraph {
     }
 
     #[inline]
-    pub fn edges_from(&self,
-                      dep_node: &DepNode)
-                      -> Option<(&[SerializedDepNodeIndex], SerializedDepNodeIndex)> {
-        self.index
-            .get(dep_node)
-            .map(|&node_index| {
-                (self.data.edge_targets_from(node_index), node_index)
-            })
+    pub fn edge_targets_from(
+        &self,
+        dep_node_index: SerializedDepNodeIndex
+    ) -> &[SerializedDepNodeIndex] {
+        self.data.edge_targets_from(dep_node_index)
     }
 
     #[inline]

src/librustc/dep_graph/prev.rs

@@ -51,21 +51,69 @@ pub(super) struct NodeCollector<'a, 'hir> {
 
     // We are collecting DepNode::HirBody hashes here so we can compute the
     // crate hash from then later on.
-    hir_body_nodes: Vec<(DefPathHash, DepNodeIndex)>,
+    hir_body_nodes: Vec<(DefPathHash, Fingerprint)>,
+}
+
+fn input_dep_node_and_hash<'a, I>(
+    dep_graph: &DepGraph,
+    hcx: &mut StableHashingContext<'a>,
+    def_node: DepNode,
+    input: I,
+) -> (DepNodeIndex, Fingerprint)
+where
+    I: HashStable<StableHashingContext<'a>>,
+{
+    let dep_node_index = dep_graph.input_task(def_node, &mut *hcx, &input).1;
+
+    let hash = if dep_graph.is_fully_enabled() {
+        dep_graph.fingerprint_of(dep_node_index)
+    } else {
+        let mut stable_hasher = StableHasher::new();
+        input.hash_stable(hcx, &mut stable_hasher);
+        stable_hasher.finish()
+    };
+
+    (dep_node_index, hash)
+}
+
+fn hir_dep_nodes<'a, I>(
+    dep_graph: &DepGraph,
+    hcx: &mut StableHashingContext<'a>,
+    def_path_hash: DefPathHash,
+    item_like: I,
+    hir_body_nodes: &mut Vec<(DefPathHash, Fingerprint)>,
+) -> (DepNodeIndex, DepNodeIndex)
+where
+    I: HashStable<StableHashingContext<'a>>,
+{
+    let sig = dep_graph.input_task(
+        def_path_hash.to_dep_node(DepKind::Hir),
+        &mut *hcx,
+        HirItemLike { item_like: &item_like, hash_bodies: false },
+    ).1;
+    let (full, hash) = input_dep_node_and_hash(
+        dep_graph,
+        hcx,
+        def_path_hash.to_dep_node(DepKind::HirBody),
+        HirItemLike { item_like: &item_like, hash_bodies: true },
+    );
+    hir_body_nodes.push((def_path_hash, hash));
+    (sig, full)
 }
 
 impl<'a, 'hir> NodeCollector<'a, 'hir> {
     pub(super) fn root(krate: &'hir Crate,
                        dep_graph: &'a DepGraph,
                        definitions: &'a definitions::Definitions,
-                       hcx: StableHashingContext<'a>,
+                       mut hcx: StableHashingContext<'a>,
                        source_map: &'a SourceMap)
                 -> NodeCollector<'a, 'hir> {
         let root_mod_def_path_hash = definitions.def_path_hash(CRATE_DEF_INDEX);
 
+        let mut hir_body_nodes = Vec::new();
+
         // Allocate DepNodes for the root module
-        let (root_mod_sig_dep_index, root_mod_full_dep_index);
-        {
+        let (root_mod_sig_dep_index, root_mod_full_dep_index) = {
             let Crate {
                 ref module,
                 // Crate attributes are not copied over to the root `Mod`, so hash
@@ -83,28 +131,23 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
                 body_ids: _,
             } = *krate;
 
-            root_mod_sig_dep_index = dep_graph.input_task(
-                root_mod_def_path_hash.to_dep_node(DepKind::Hir),
-                &hcx,
-                HirItemLike { item_like: (module, attrs, span), hash_bodies: false },
-            ).1;
-            root_mod_full_dep_index = dep_graph.input_task(
-                root_mod_def_path_hash.to_dep_node(DepKind::HirBody),
-                &hcx,
-                HirItemLike { item_like: (module, attrs, span), hash_bodies: true },
-            ).1;
-        }
+            hir_dep_nodes(
+                dep_graph,
+                &mut hcx,
+                root_mod_def_path_hash,
+                (module, attrs, span),
+                &mut hir_body_nodes,
+            )
+        };
 
         {
             dep_graph.input_task(
                 DepNode::new_no_params(DepKind::AllLocalTraitImpls),
-                &hcx,
+                &mut hcx,
                 &krate.trait_impls,
             );
         }
 
-        let hir_body_nodes = vec![(root_mod_def_path_hash, root_mod_full_dep_index)];
-
         let mut collector = NodeCollector {
             krate,
             source_map,
@@ -139,9 +182,9 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
         let node_hashes = self
             .hir_body_nodes
             .iter()
-            .fold(Fingerprint::ZERO, |fingerprint, &(def_path_hash, dep_node_index)| {
+            .fold(Fingerprint::ZERO, |fingerprint, &(def_path_hash, hash)| {
                 fingerprint.combine(
-                    def_path_hash.0.combine(self.dep_graph.fingerprint_of(dep_node_index))
+                    def_path_hash.0.combine(hash)
                 )
             });
 
@@ -169,17 +212,19 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
 
         source_file_names.sort_unstable();
 
-        let (_, crate_dep_node_index) = self
-            .dep_graph
-            .input_task(DepNode::new_no_params(DepKind::Krate),
-                       &self.hcx,
-                       (((node_hashes, upstream_crates), source_file_names),
-                        (commandline_args_hash,
-                         crate_disambiguator.to_fingerprint())));
-
-        let svh = Svh::new(self.dep_graph
-                               .fingerprint_of(crate_dep_node_index)
-                               .to_smaller_hash());
+        let crate_hash_input = (
+            ((node_hashes, upstream_crates), source_file_names),
+            (commandline_args_hash, crate_disambiguator.to_fingerprint())
+        );
+
+        let (_, crate_hash) = input_dep_node_and_hash(
+            self.dep_graph,
+            &mut self.hcx,
+            DepNode::new_no_params(DepKind::Krate),
+            crate_hash_input,
+        );
+
+        let svh = Svh::new(crate_hash.to_smaller_hash());
         (self.map, svh)
     }
 
@@ -261,19 +306,15 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
 
         let def_path_hash = self.definitions.def_path_hash(dep_node_owner);
 
-        self.current_signature_dep_index = self.dep_graph.input_task(
-            def_path_hash.to_dep_node(DepKind::Hir),
-            &self.hcx,
-            HirItemLike { item_like, hash_bodies: false },
-        ).1;
-
-        self.current_full_dep_index = self.dep_graph.input_task(
-            def_path_hash.to_dep_node(DepKind::HirBody),
-            &self.hcx,
-            HirItemLike { item_like, hash_bodies: true },
-        ).1;
-
-        self.hir_body_nodes.push((def_path_hash, self.current_full_dep_index));
+        let (signature_dep_index, full_dep_index) = hir_dep_nodes(
+            self.dep_graph,
+            &mut self.hcx,
+            def_path_hash,
+            item_like,
+            &mut self.hir_body_nodes,
+        );
+        self.current_signature_dep_index = signature_dep_index;
+        self.current_full_dep_index = full_dep_index;
 
         self.current_dep_node_owner = dep_node_owner;
         self.currently_in_body = false;

src/librustc/hir/map/collector.rs

@@ -26,7 +26,10 @@ use util::common::{duration_to_secs_str, ErrorReported};
 use util::common::ProfileQueriesMsg;
 
 use rustc_data_structures::base_n;
-use rustc_data_structures::sync::{self, Lrc, Lock, LockCell, OneThread, Once, RwLock};
+use rustc_data_structures::sync::{
+    self, Lrc, Lock, OneThread, Once, RwLock, AtomicU64, AtomicUsize, AtomicBool, Ordering,
+    Ordering::SeqCst,
+};
 
 use errors::{self, DiagnosticBuilder, DiagnosticId, Applicability};
 use errors::emitter::{Emitter, EmitterWriter};
@@ -51,7 +54,6 @@ use std::io::Write;
 use std::path::PathBuf;
 use std::time::Duration;
 use std::sync::mpsc;
-use std::sync::atomic::{AtomicUsize, Ordering};
 
 mod code_stats;
 pub mod config;
@@ -148,15 +150,15 @@ pub struct Session {
     /// If -zfuel=crate=n is specified, Some(crate).
     optimization_fuel_crate: Option<String>,
     /// If -zfuel=crate=n is specified, initially set to n. Otherwise 0.
-    optimization_fuel_limit: LockCell<u64>,
+    optimization_fuel_limit: AtomicU64,
     /// We're rejecting all further optimizations.
-    out_of_fuel: LockCell<bool>,
+    out_of_fuel: AtomicBool,
 
     // The next two are public because the driver needs to read them.
     /// If -zprint-fuel=crate, Some(crate).
     pub print_fuel_crate: Option<String>,
     /// Always set to zero and incremented so that we can print fuel expended by a crate.
-    pub print_fuel: LockCell<u64>,
+    pub print_fuel: AtomicU64,
 
     /// Loaded up early on in the initialization of this `Session` to avoid
     /// false positives about a job server in our environment.
@@ -835,7 +837,7 @@ impl Session {
 
     #[inline(always)]
     pub fn profiler<F: FnOnce(&mut SelfProfiler) -> ()>(&self, f: F) {
-        if unlikely!(self.self_profiling_active) {
+        if unlikely!(false) {
             self.profiler_active(f)
         }
     }
@@ -867,36 +869,47 @@ impl Session {
                  self.perf_stats.normalize_projection_ty.load(Ordering::Relaxed));
     }
 
-    /// We want to know if we're allowed to do an optimization for crate foo from -z fuel=foo=n.
-    /// This expends fuel if applicable, and records fuel if applicable.
-    pub fn consider_optimizing<T: Fn() -> String>(&self, crate_name: &str, msg: T) -> bool {
+    #[inline(never)]
+    #[cold]
+    pub fn consider_optimizing_cold<T: Fn() -> String>(&self, crate_name: &str, msg: T) -> bool {
         let mut ret = true;
         if let Some(ref c) = self.optimization_fuel_crate {
             if c == crate_name {
                 assert_eq!(self.query_threads(), 1);
-                let fuel = self.optimization_fuel_limit.get();
+                let fuel = self.optimization_fuel_limit.load(SeqCst);
                 ret = fuel != 0;
-                if fuel == 0 && !self.out_of_fuel.get() {
+                if fuel == 0 && !self.out_of_fuel.load(SeqCst) {
                     eprintln!("optimization-fuel-exhausted: {}", msg());
-                    self.out_of_fuel.set(true);
+                    self.out_of_fuel.store(true, SeqCst);
                 } else if fuel > 0 {
-                    self.optimization_fuel_limit.set(fuel - 1);
+                    self.optimization_fuel_limit.store(fuel - 1, SeqCst);
                 }
             }
         }
         if let Some(ref c) = self.print_fuel_crate {
             if c == crate_name {
                 assert_eq!(self.query_threads(), 1);
-                self.print_fuel.set(self.print_fuel.get() + 1);
+                self.print_fuel.store(self.print_fuel.load(SeqCst) + 1, SeqCst);
             }
         }
         ret
     }
 
+    /// We want to know if we're allowed to do an optimization for crate foo from -z fuel=foo=n.
+    /// This expends fuel if applicable, and records fuel if applicable.
+    #[inline(always)]
+    pub fn consider_optimizing<T: Fn() -> String>(&self, crate_name: &str, msg: T) -> bool {
+        if likely!(self.optimization_fuel_crate.is_none() && self.print_fuel_crate.is_none()) {
+            true
+        } else {
+            self.consider_optimizing_cold(crate_name, msg)
+        }
+    }
+
     /// Returns the number of query threads that should be used for this
     /// compilation
     pub fn query_threads_from_opts(opts: &config::Options) -> usize {
-        opts.debugging_opts.query_threads.unwrap_or(1)
+        opts.debugging_opts.query_threads.unwrap_or(4)
     }
 
     /// Returns the number of query threads that should be used for this
@@ -1138,9 +1151,9 @@ pub fn build_session_(
 
     let optimization_fuel_crate = sopts.debugging_opts.fuel.as_ref().map(|i| i.0.clone());
     let optimization_fuel_limit =
-        LockCell::new(sopts.debugging_opts.fuel.as_ref().map(|i| i.1).unwrap_or(0));
+        AtomicU64::new(sopts.debugging_opts.fuel.as_ref().map(|i| i.1).unwrap_or(0));
     let print_fuel_crate = sopts.debugging_opts.print_fuel.clone();
-    let print_fuel = LockCell::new(0);
+    let print_fuel = AtomicU64::new(0);
 
     let working_dir = env::current_dir().unwrap_or_else(|e|
         p_s.span_diagnostic
@@ -1205,7 +1218,7 @@ pub fn build_session_(
         optimization_fuel_limit,
         print_fuel_crate,
         print_fuel,
-        out_of_fuel: LockCell::new(false),
+        out_of_fuel: AtomicBool::new(false),
         // Note that this is unsafe because it may misinterpret file descriptors
         // on Unix as jobserver file descriptors. We hopefully execute this near
         // the beginning of the process though to ensure we don't get false