Experiment: Only track fingerprints for reconstructible dep-nodes.

Author: michaelwoerister

compiler/rustc_middle/src/query/mod.rs

@@ -1066,7 +1066,7 @@ rustc_queries! {
             "const-evaluating + checking `{}`",
             key.value.display(tcx)
         }
-        cache_on_disk_if { true }
+        // cache_on_disk_if { true }  Cannot cache this anymore
     }
 
     /// Evaluates const items or anonymous constants
@@ -1081,7 +1081,7 @@ rustc_queries! {
             "simplifying constant for the type system `{}`",
             key.value.display(tcx)
         }
-        cache_on_disk_if { true }
+        // cache_on_disk_if { true }  Cannot cache this anymore
     }
 
     /// Evaluate a constant and convert it to a type level constant or
@@ -1148,7 +1148,7 @@ rustc_queries! {
     /// look up the correct symbol name of instances from upstream crates.
     query symbol_name(key: ty::Instance<'tcx>) -> ty::SymbolName<'tcx> {
         desc { "computing the symbol for `{}`", key }
-        cache_on_disk_if { true }
+        // cache_on_disk_if { true }  Cannot cache this anymore
     }
 
     query def_kind(def_id: DefId) -> DefKind {
@@ -1284,7 +1284,7 @@ rustc_queries! {
     query codegen_select_candidate(
         key: (ty::ParamEnv<'tcx>, ty::TraitRef<'tcx>)
     ) -> Result<&'tcx ImplSource<'tcx, ()>, CodegenObligationError> {
-        cache_on_disk_if { true }
+        // cache_on_disk_if { true }  Cannot cache this anymore
         desc { |tcx| "computing candidate for `{}`", key.1 }
     }
 
@@ -1894,7 +1894,7 @@ rustc_queries! {
     }
 
     query unused_generic_params(key: ty::InstanceDef<'tcx>) -> UnusedGenericParams {
-        cache_on_disk_if { key.def_id().is_local() }
+        // cache_on_disk_if { key.def_id().is_local() }  Cannot cache this anymore
         desc {
             |tcx| "determining which generic parameters are unused by `{}`",
                 tcx.def_path_str(key.def_id())

compiler/rustc_query_system/src/dep_graph/graph.rs

@@ -133,7 +133,7 @@ impl<D: Deps> DepGraph<D> {
         let colors = DepNodeColorMap::new(prev_graph_node_count);
 
         // Instantiate a dependy-less node only once for anonymous queries.
-        let _green_node_index = current.intern_new_node(
+        let _green_node_index = current.alloc_new_node(
             profiler,
             DepNode { kind: D::DEP_KIND_NULL, hash: current.anon_id_seed.into() },
             EdgesVec::new(),
@@ -272,6 +272,7 @@ impl<D: Deps> DepGraph<D> {
         D::with_deps(TaskDepsRef::Forbid, op)
     }
 
+    // FIXME(sparse_fps): Document
     #[inline(always)]
     pub fn with_task<Ctxt: HasDepContext<Deps = D>, A: Debug, R>(
         &self,
@@ -287,6 +288,7 @@ impl<D: Deps> DepGraph<D> {
         }
     }
 
+    // FIXME(sparse_fps): Document
     pub fn with_anon_task<Tcx: DepContext<Deps = D>, OP, R>(
         &self,
         cx: Tcx,
@@ -297,7 +299,7 @@ impl<D: Deps> DepGraph<D> {
         OP: FnOnce() -> R,
     {
         match self.data() {
-            Some(data) => data.with_anon_task(cx, dep_kind, op),
+            Some(data) => data.with_anon_task(cx, dep_kind, true, op),
             None => (op(), self.next_virtual_depnode_index()),
         }
     }
@@ -395,61 +397,71 @@ impl<D: Deps> DepGraphData<D> {
         (result, dep_node_index)
     }
 
+    // FIXME(sparse_fps): Document
     /// Executes something within an "anonymous" task, that is, a task the
     /// `DepNode` of which is determined by the list of inputs it read from.
     pub(crate) fn with_anon_task<Tcx: DepContext<Deps = D>, OP, R>(
         &self,
         cx: Tcx,
         dep_kind: DepKind,
+        intern: bool,
         op: OP,
     ) -> (R, DepNodeIndex)
     where
         OP: FnOnce() -> R,
     {
-        debug_assert!(!cx.is_eval_always(dep_kind));
-
         let task_deps = Lock::new(TaskDeps::default());
         let result = D::with_deps(TaskDepsRef::Allow(&task_deps), op);
         let task_deps = task_deps.into_inner();
         let task_deps = task_deps.reads;
 
-        let dep_node_index = match task_deps.len() {
-            0 => {
-                // Because the dep-node id of anon nodes is computed from the sets of its
-                // dependencies we already know what the ID of this dependency-less node is
-                // going to be (i.e. equal to the precomputed
-                // `SINGLETON_DEPENDENCYLESS_ANON_NODE`). As a consequence we can skip creating
-                // a `StableHasher` and sending the node through interning.
-                DepNodeIndex::SINGLETON_DEPENDENCYLESS_ANON_NODE
-            }
-            1 => {
-                // When there is only one dependency, don't bother creating a node.
-                task_deps[0]
-            }
-            _ => {
-                // The dep node indices are hashed here instead of hashing the dep nodes of the
-                // dependencies. These indices may refer to different nodes per session, but this isn't
-                // a problem here because we that ensure the final dep node hash is per session only by
-                // combining it with the per session random number `anon_id_seed`. This hash only need
-                // to map the dependencies to a single value on a per session basis.
-                let mut hasher = StableHasher::new();
-                task_deps.hash(&mut hasher);
-
-                let target_dep_node = DepNode {
-                    kind: dep_kind,
-                    // Fingerprint::combine() is faster than sending Fingerprint
-                    // through the StableHasher (at least as long as StableHasher
-                    // is so slow).
-                    hash: self.current.anon_id_seed.combine(hasher.finish()).into(),
-                };
-
-                self.current.intern_new_node(
-                    cx.profiler(),
-                    target_dep_node,
-                    task_deps,
-                    Fingerprint::ZERO,
-                )
+        let dep_node_index = if intern {
+            // FIXME(sparse_fp): what is this assertion about?
+            debug_assert!(!cx.is_eval_always(dep_kind));
+
+            match task_deps.len() {
+                0 => {
+                    // Because the dep-node id of anon nodes is computed from the sets of its
+                    // dependencies we already know what the ID of this dependency-less node is
+                    // going to be (i.e. equal to the precomputed
+                    // `SINGLETON_DEPENDENCYLESS_ANON_NODE`). As a consequence we can skip creating
+                    // a `StableHasher` and sending the node through interning.
+                    DepNodeIndex::SINGLETON_DEPENDENCYLESS_ANON_NODE
+                }
+                1 => {
+                    // When there is only one dependency, don't bother creating a node.
+                    task_deps[0]
+                }
+                _ => {
+                    // The dep node indices are hashed here instead of hashing the dep nodes of the
+                    // dependencies. These indices may refer to different nodes per session, but this isn't
+                    // a problem here because we that ensure the final dep node hash is per session only by
+                    // combining it with the per session random number `anon_id_seed`. This hash only need
+                    // to map the dependencies to a single value on a per session basis.
+                    let mut hasher = StableHasher::new();
+                    task_deps.hash(&mut hasher);
+                    dep_kind.hash(&mut hasher);
+
+                    let dedup_fingerprint: Fingerprint = hasher.finish();
+
+                    match self
+                        .current
+                        .interned_node_to_index
+                        .lock_shard_by_value(&dedup_fingerprint)
+                        .entry(dedup_fingerprint)
+                    {
+                        Entry::Occupied(entry) => *entry.get(),
+                        Entry::Vacant(entry) => {
+                            let dep_node_index =
+                                self.current.alloc_anon_node(cx.profiler(), dep_kind, task_deps);
+                            entry.insert(dep_node_index);
+                            dep_node_index
+                        }
+                    }
+                }
             }
+        } else {
+            self.current.alloc_anon_node(cx.profiler(), dep_kind, task_deps)
         };
 
         (result, dep_node_index)
@@ -616,18 +628,20 @@ impl<D: Deps> DepGraph<D> {
 }
 
 impl<D: Deps> DepGraphData<D> {
-    #[inline]
-    fn dep_node_index_of_opt(&self, dep_node: &DepNode) -> Option<DepNodeIndex> {
-        if let Some(prev_index) = self.previous.node_to_index_opt(dep_node) {
-            self.current.prev_index_to_index.lock()[prev_index]
-        } else {
-            self.current.new_node_to_index.lock_shard_by_value(dep_node).get(dep_node).copied()
-        }
-    }
+    // #[inline]
+    // fn dep_node_index_of_opt(&self, dep_node: &DepNode) -> Option<DepNodeIndex> {
+    //     if let Some(prev_index) = self.previous.node_to_index_opt(dep_node) {
+    //         self.current.prev_index_to_index.lock()[prev_index]
+    //     } else {
+    //         self.current.interned_node_to_index.lock_shard_by_value(dep_node).get(dep_node).copied()
+    //     }
+    // }
 
     #[inline]
-    fn dep_node_exists(&self, dep_node: &DepNode) -> bool {
-        self.dep_node_index_of_opt(dep_node).is_some()
+    fn dep_node_exists(&self, _dep_node: &DepNode) -> bool {
+        // FIXME(sparse_fps): bring back assertions
+        //self.dep_node_index_of_opt(dep_node).is_some()
+        false
     }
 
     fn node_color(&self, dep_node: &DepNode) -> Option<DepNodeColor> {
@@ -1071,7 +1085,7 @@ rustc_index::newtype_index! {
 /// first, and `data` second.
 pub(super) struct CurrentDepGraph<D: Deps> {
     encoder: Steal<GraphEncoder<D>>,
-    new_node_to_index: Sharded<FxHashMap<DepNode, DepNodeIndex>>,
+    interned_node_to_index: Sharded<FxHashMap<Fingerprint, DepNodeIndex>>,
     prev_index_to_index: Lock<IndexVec<SerializedDepNodeIndex, Option<DepNodeIndex>>>,
 
     /// This is used to verify that fingerprints do not change between the creation of a node
@@ -1152,7 +1166,7 @@ impl<D: Deps> CurrentDepGraph<D> {
                 record_graph,
                 record_stats,
             )),
-            new_node_to_index: Sharded::new(|| {
+            interned_node_to_index: Sharded::new(|| {
                 FxHashMap::with_capacity_and_hasher(
                     new_node_count_estimate / sharded::shards(),
                     Default::default(),
@@ -1182,29 +1196,30 @@ impl<D: Deps> CurrentDepGraph<D> {
     /// Writes the node to the current dep-graph and allocates a `DepNodeIndex` for it.
     /// Assumes that this is a node that has no equivalent in the previous dep-graph.
     #[inline(always)]
-    fn intern_new_node(
+    fn alloc_new_node(
         &self,
         profiler: &SelfProfilerRef,
         key: DepNode,
         edges: EdgesVec,
         current_fingerprint: Fingerprint,
     ) -> DepNodeIndex {
-        let dep_node_index = match self.new_node_to_index.lock_shard_by_value(&key).entry(key) {
-            Entry::Occupied(entry) => *entry.get(),
-            Entry::Vacant(entry) => {
-                let dep_node_index =
-                    self.encoder.borrow().send(profiler, key, current_fingerprint, edges);
-                entry.insert(dep_node_index);
-                dep_node_index
-            }
-        };
-
+        let dep_node_index = self.encoder.borrow().send(profiler, key, current_fingerprint, edges);
         #[cfg(debug_assertions)]
         self.record_edge(dep_node_index, key, current_fingerprint);
 
         dep_node_index
     }
 
+    #[inline(always)]
+    fn alloc_anon_node(
+        &self,
+        profiler: &SelfProfilerRef,
+        dep_kind: DepKind,
+        edges: EdgesVec,
+    ) -> DepNodeIndex {
+        self.encoder.borrow().send_anon_node(profiler, dep_kind, edges)
+    }
+
     fn intern_node(
         &self,
         profiler: &SelfProfilerRef,
@@ -1262,7 +1277,7 @@ impl<D: Deps> CurrentDepGraph<D> {
             let fingerprint = fingerprint.unwrap_or(Fingerprint::ZERO);
 
             // This is a new node: it didn't exist in the previous compilation session.
-            let dep_node_index = self.intern_new_node(profiler, key, edges, fingerprint);
+            let dep_node_index = self.alloc_new_node(profiler, key, edges, fingerprint);
 
             (dep_node_index, None)
         }
@@ -1274,7 +1289,8 @@ impl<D: Deps> CurrentDepGraph<D> {
         prev_graph: &SerializedDepGraph,
         prev_index: SerializedDepNodeIndex,
     ) -> DepNodeIndex {
-        self.debug_assert_not_in_new_nodes(prev_graph, prev_index);
+        // FIXME(sparse_fp): restore assertions
+        // self.debug_assert_not_in_new_nodes(prev_graph, prev_index);
 
         let mut prev_index_to_index = self.prev_index_to_index.lock();
 
@@ -1296,18 +1312,19 @@ impl<D: Deps> CurrentDepGraph<D> {
         }
     }
 
-    #[inline]
-    fn debug_assert_not_in_new_nodes(
-        &self,
-        prev_graph: &SerializedDepGraph,
-        prev_index: SerializedDepNodeIndex,
-    ) {
-        let node = &prev_graph.index_to_node(prev_index);
-        debug_assert!(
-            !self.new_node_to_index.lock_shard_by_value(node).contains_key(node),
-            "node from previous graph present in new node collection"
-        );
-    }
+    // FIXME(sparse_fp): restore assertions
+    // #[inline]
+    // fn debug_assert_not_in_new_nodes(
+    //     &self,
+    //     prev_graph: &SerializedDepGraph,
+    //     prev_index: SerializedDepNodeIndex,
+    // ) {
+    //     let node = &prev_graph.index_to_node(prev_index);
+    //     debug_assert!(
+    //         !self.interned_node_to_index.lock_shard_by_value(node).contains_key(node),
+    //         "node from previous graph present in new node collection"
+    //     );
+    // }
 }
 
 #[derive(Debug, Clone, Copy)]