Auto merge of #62038 - Zoxc:pre-gc-dep-graph, r=<try>

[WIP] Make dep node indices persistent between sessions

This makes marking dep nodes green faster (and lock free in the case with no diagnostics). This change is split out from #60035.

Unlike #60035 this makes loading the dep graph slower because it loads 2 copies of the dep graph, one immutable and one mutable.

Based on #61845, #61779 and #61923.

Author: bors

Cargo.lock

@@ -2893,6 +2893,7 @@ name = "rustc_data_structures"
 version = "0.0.0"
 dependencies = [
  "cfg-if 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crossbeam-utils 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "ena 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "graphviz 0.0.0",
  "indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",

src/librustc/dep_graph/graph.rs

@@ -11,9 +11,9 @@ pub mod cgu_reuse_tracker;
 pub use self::dep_tracking_map::{DepTrackingMap, DepTrackingMapConfig};
 pub use self::dep_node::{DepNode, DepKind, DepConstructor, WorkProductId, RecoverKey, label_strs};
 pub use self::graph::{DepGraph, WorkProduct, DepNodeIndex, DepNodeColor, TaskDeps, hash_result};
-pub use self::graph::WorkProductFileKind;
+pub use self::graph::{DepGraphArgs, WorkProductFileKind, CurrentDepGraph};
 pub use self::prev::PreviousDepGraph;
 pub use self::query::DepGraphQuery;
 pub use self::safe::AssertDepGraphSafe;
 pub use self::safe::DepGraphSafe;
-pub use self::serialized::{SerializedDepGraph, SerializedDepNodeIndex};
+pub use self::serialized::SerializedDepGraph;

src/librustc/dep_graph/mod.rs

@@ -1,43 +1,70 @@
 use crate::ich::Fingerprint;
 use rustc_data_structures::fx::FxHashMap;
-use super::dep_node::DepNode;
-use super::serialized::{SerializedDepGraph, SerializedDepNodeIndex};
+use rustc_data_structures::indexed_vec::IndexVec;
+use rustc_data_structures::sync::AtomicCell;
+use super::dep_node::{DepNode, DepKind};
+use super::graph::{DepNodeIndex, DepNodeState};
+use super::serialized::SerializedDepGraph;
 
-#[derive(Debug, RustcEncodable, RustcDecodable, Default)]
+#[derive(Debug, Default)]
 pub struct PreviousDepGraph {
     data: SerializedDepGraph,
-    index: FxHashMap<DepNode, SerializedDepNodeIndex>,
+    pub(super) index: FxHashMap<DepNode, DepNodeIndex>,
+    pub(super) unused: Vec<DepNodeIndex>,
 }
 
 impl PreviousDepGraph {
-    pub fn new(data: SerializedDepGraph) -> PreviousDepGraph {
+    pub fn new_and_state(
+        data: SerializedDepGraph
+    ) -> (PreviousDepGraph, IndexVec<DepNodeIndex, AtomicCell<DepNodeState>>) {
+        let mut unused = Vec::new();
+
+        let state: IndexVec<_, _> = data.nodes.iter_enumerated().map(|(index, node)| {
+            if node.kind == DepKind::Null {
+                // There might be `DepKind::Null` nodes due to thread-local dep node indices
+                // that didn't get assigned anything.
+                // We also changed outdated nodes to `DepKind::Null`.
+                unused.push(index);
+                AtomicCell::new(DepNodeState::Invalid)
+            } else {
+                AtomicCell::new(DepNodeState::Unknown)
+            }
+        }).collect();
+
         let index: FxHashMap<_, _> = data.nodes
             .iter_enumerated()
-            .map(|(idx, &dep_node)| (dep_node, idx))
+            .filter_map(|(idx, &dep_node)| {
+                if dep_node.kind == DepKind::Null {
+                    None
+                } else {
+                    Some((dep_node, idx))
+                }
+            })
             .collect();
-        PreviousDepGraph { data, index }
+
+        (PreviousDepGraph { data, index, unused }, state)
     }
 
     #[inline]
     pub fn edge_targets_from(
         &self,
-        dep_node_index: SerializedDepNodeIndex
-    ) -> &[SerializedDepNodeIndex] {
+        dep_node_index: DepNodeIndex
+    ) -> &[DepNodeIndex] {
         self.data.edge_targets_from(dep_node_index)
     }
 
     #[inline]
-    pub fn index_to_node(&self, dep_node_index: SerializedDepNodeIndex) -> DepNode {
+    pub fn index_to_node(&self, dep_node_index: DepNodeIndex) -> DepNode {
         self.data.nodes[dep_node_index]
     }
 
     #[inline]
-    pub fn node_to_index(&self, dep_node: &DepNode) -> SerializedDepNodeIndex {
+    pub fn node_to_index(&self, dep_node: &DepNode) -> DepNodeIndex {
         self.index[dep_node]
     }
 
     #[inline]
-    pub fn node_to_index_opt(&self, dep_node: &DepNode) -> Option<SerializedDepNodeIndex> {
+    pub fn node_to_index_opt(&self, dep_node: &DepNode) -> Option<DepNodeIndex> {
         self.index.get(dep_node).cloned()
     }
 
@@ -50,12 +77,12 @@ impl PreviousDepGraph {
 
     #[inline]
     pub fn fingerprint_by_index(&self,
-                                dep_node_index: SerializedDepNodeIndex)
+                                dep_node_index: DepNodeIndex)
                                 -> Fingerprint {
         self.data.fingerprints[dep_node_index]
     }
 
     pub fn node_count(&self) -> usize {
-        self.index.len()
+        self.data.nodes.len()
     }
 }

src/librustc/dep_graph/prev.rs

@@ -2,34 +2,31 @@
 
 use crate::dep_graph::DepNode;
 use crate::ich::Fingerprint;
-use rustc_data_structures::indexed_vec::{IndexVec, Idx};
-
-newtype_index! {
-    pub struct SerializedDepNodeIndex { .. }
-}
+use rustc_data_structures::indexed_vec::IndexVec;
+use super::graph::DepNodeIndex;
 
 /// Data for use when recompiling the **current crate**.
 #[derive(Debug, RustcEncodable, RustcDecodable, Default)]
 pub struct SerializedDepGraph {
     /// The set of all DepNodes in the graph
-    pub nodes: IndexVec<SerializedDepNodeIndex, DepNode>,
+    pub nodes: IndexVec<DepNodeIndex, DepNode>,
     /// The set of all Fingerprints in the graph. Each Fingerprint corresponds to
     /// the DepNode at the same index in the nodes vector.
-    pub fingerprints: IndexVec<SerializedDepNodeIndex, Fingerprint>,
+    pub fingerprints: IndexVec<DepNodeIndex, Fingerprint>,
     /// For each DepNode, stores the list of edges originating from that
     /// DepNode. Encoded as a [start, end) pair indexing into edge_list_data,
     /// which holds the actual DepNodeIndices of the target nodes.
-    pub edge_list_indices: IndexVec<SerializedDepNodeIndex, (u32, u32)>,
+    pub edge_list_indices: IndexVec<DepNodeIndex, (u32, u32)>,
     /// A flattened list of all edge targets in the graph. Edge sources are
     /// implicit in edge_list_indices.
-    pub edge_list_data: Vec<SerializedDepNodeIndex>,
+    pub edge_list_data: Vec<DepNodeIndex>,
 }
 
 impl SerializedDepGraph {
     #[inline]
     pub fn edge_targets_from(&self,
-                             source: SerializedDepNodeIndex)
-                             -> &[SerializedDepNodeIndex] {
+                             source: DepNodeIndex)
+                             -> &[DepNodeIndex] {
         let targets = self.edge_list_indices[source];
         &self.edge_list_data[targets.0 as usize..targets.1 as usize]
     }

src/librustc/dep_graph/serialized.rs

@@ -2,10 +2,10 @@ use crate::ty::query::QueryDescription;
 use crate::ty::query::queries;
 use crate::ty::{self, ParamEnvAnd, Ty, TyCtxt};
 use crate::ty::subst::SubstsRef;
-use crate::dep_graph::SerializedDepNodeIndex;
 use crate::hir::def_id::{CrateNum, DefId, DefIndex};
 use crate::mir;
 use crate::mir::interpret::GlobalId;
+use crate::dep_graph::DepNodeIndex;
 use crate::traits;
 use crate::traits::query::{
     CanonicalPredicateGoal, CanonicalProjectionGoal,

src/librustc/query/mod.rs

@@ -48,14 +48,14 @@ use crate::util::common::ErrorReported;
 use crate::util::nodemap::{DefIdMap, DefIdSet, ItemLocalMap, ItemLocalSet};
 use crate::util::nodemap::{FxHashMap, FxHashSet};
 use errors::DiagnosticBuilder;
-use rustc_data_structures::interner::HashInterner;
 use smallvec::SmallVec;
 use rustc_data_structures::stable_hasher::{HashStable, hash_stable_hashmap,
                                            StableHasher, StableHasherResult,
                                            StableVec};
 use arena::SyncDroplessArena;
 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use rustc_data_structures::sync::{Lrc, Lock, WorkerLocal};
+use rustc_data_structures::sharded::ShardedHashMap;
 use std::any::Any;
 use std::borrow::Borrow;
 use std::cmp::Ordering;
@@ -93,7 +93,7 @@ impl AllArenas {
     }
 }
 
-type InternedSet<'tcx, T> = Lock<FxHashMap<Interned<'tcx, T>, ()>>;
+type InternedSet<'tcx, T> = ShardedHashMap<Interned<'tcx, T>, ()>;
 
 pub struct CtxtInterners<'tcx> {
     /// The arena that types, regions, etc are allocated from
@@ -147,7 +147,7 @@ impl<'tcx> CtxtInterners<'tcx> {
         // determine that all contents are in the global tcx.
         // See comments on Lift for why we can't use that.
         if flags.flags.intersects(ty::TypeFlags::KEEP_IN_LOCAL_TCX) {
-            local.type_.borrow_mut().intern(st, |st| {
+            local.type_.intern(st, |st| {
                 let ty_struct = TyS {
                     sty: st,
                     flags: flags.flags,
@@ -171,7 +171,7 @@ impl<'tcx> CtxtInterners<'tcx> {
                 Interned(local.arena.alloc(ty_struct))
             }).0
         } else {
-            global.type_.borrow_mut().intern(st, |st| {
+            global.type_.intern(st, |st| {
                 let ty_struct = TyS {
                     sty: st,
                     flags: flags.flags,
@@ -964,7 +964,7 @@ impl<'tcx> CommonTypes<'tcx> {
 impl<'tcx> CommonLifetimes<'tcx> {
     fn new(interners: &CtxtInterners<'tcx>) -> CommonLifetimes<'tcx> {
         let mk = |r| {
-            interners.region.borrow_mut().intern(r, |r| {
+            interners.region.intern(r, |r| {
                 Interned(interners.arena.alloc(r))
             }).0
         };
@@ -980,7 +980,7 @@ impl<'tcx> CommonLifetimes<'tcx> {
 impl<'tcx> CommonConsts<'tcx> {
     fn new(interners: &CtxtInterners<'tcx>, types: &CommonTypes<'tcx>) -> CommonConsts<'tcx> {
         let mk_const = |c| {
-            interners.const_.borrow_mut().intern(c, |c| {
+            interners.const_.intern(c, |c| {
                 Interned(interners.arena.alloc(c))
             }).0
         };
@@ -1096,14 +1096,14 @@ pub struct GlobalCtxt<'tcx> {
     /// Data layout specification for the current target.
     pub data_layout: TargetDataLayout,
 
-    stability_interner: Lock<FxHashMap<&'tcx attr::Stability, ()>>,
+    stability_interner: ShardedHashMap<&'tcx attr::Stability, ()>,
 
     /// Stores the value of constants (and deduplicates the actual memory)
-    allocation_interner: Lock<FxHashMap<&'tcx Allocation, ()>>,
+    allocation_interner: ShardedHashMap<&'tcx Allocation, ()>,
 
     pub alloc_map: Lock<interpret::AllocMap<'tcx>>,
 
-    layout_interner: Lock<FxHashMap<&'tcx LayoutDetails, ()>>,
+    layout_interner: ShardedHashMap<&'tcx LayoutDetails, ()>,
 
     /// A general purpose channel to throw data out the back towards LLVM worker
     /// threads.
@@ -1148,7 +1148,7 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     pub fn intern_const_alloc(self, alloc: Allocation) -> &'tcx Allocation {
-        self.allocation_interner.borrow_mut().intern(alloc, |alloc| {
+        self.allocation_interner.intern(alloc, |alloc| {
             self.arena.alloc(alloc)
         })
     }
@@ -1162,13 +1162,13 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     pub fn intern_stability(self, stab: attr::Stability) -> &'tcx attr::Stability {
-        self.stability_interner.borrow_mut().intern(stab, |stab| {
+        self.stability_interner.intern(stab, |stab| {
             self.arena.alloc(stab)
         })
     }
 
     pub fn intern_layout(self, layout: LayoutDetails) -> &'tcx LayoutDetails {
-        self.layout_interner.borrow_mut().intern(layout, |layout| {
+        self.layout_interner.intern(layout, |layout| {
             self.arena.alloc(layout)
         })
     }
@@ -2110,7 +2110,9 @@ macro_rules! sty_debug_print {
                 };
                 $(let mut $variant = total;)*
 
-                for &Interned(t) in tcx.interners.type_.borrow().keys() {
+                let shards = tcx.interners.type_.lock_shards();
+                let types = shards.iter().flat_map(|shard| shard.keys());
+                for &Interned(t) in types {
                     let variant = match t.sty {
                         ty::Bool | ty::Char | ty::Int(..) | ty::Uint(..) |
                             ty::Float(..) | ty::Str | ty::Never => continue,
@@ -2161,11 +2163,11 @@ impl<'tcx> TyCtxt<'tcx> {
             Generator, GeneratorWitness, Dynamic, Closure, Tuple, Bound,
             Param, Infer, UnnormalizedProjection, Projection, Opaque, Foreign);
 
-        println!("InternalSubsts interner: #{}", self.interners.substs.borrow().len());
-        println!("Region interner: #{}", self.interners.region.borrow().len());
-        println!("Stability interner: #{}", self.stability_interner.borrow().len());
-        println!("Allocation interner: #{}", self.allocation_interner.borrow().len());
-        println!("Layout interner: #{}", self.layout_interner.borrow().len());
+        println!("InternalSubsts interner: #{}", self.interners.substs.len());
+        println!("Region interner: #{}", self.interners.region.len());
+        println!("Stability interner: #{}", self.stability_interner.len());
+        println!("Allocation interner: #{}", self.allocation_interner.len());
+        println!("Layout interner: #{}", self.layout_interner.len());
     }
 }
 
@@ -2298,7 +2300,7 @@ macro_rules! intern_method {
                 // determine that all contents are in the global tcx.
                 // See comments on Lift for why we can't use that.
                 if ($keep_in_local_tcx)(&v) {
-                    self.interners.$name.borrow_mut().intern_ref(key, || {
+                    self.interners.$name.intern_ref(key, || {
                         // Make sure we don't end up with inference
                         // types/regions in the global tcx.
                         if self.is_global() {
@@ -2310,7 +2312,7 @@ macro_rules! intern_method {
                         Interned($alloc_method(&self.interners.arena, v))
                     }).0
                 } else {
-                    self.global_interners.$name.borrow_mut().intern_ref(key, || {
+                    self.global_interners.$name.intern_ref(key, || {
                         Interned($alloc_method(&self.global_interners.arena, v))
                     }).0
                 }

src/librustc/ty/context.rs

@@ -1,5 +1,4 @@
-use crate::dep_graph::SerializedDepNodeIndex;
-use crate::dep_graph::DepNode;
+use crate::dep_graph::{DepNode, DepNodeIndex};
 use crate::hir::def_id::{CrateNum, DefId};
 use crate::ty::TyCtxt;
 use crate::ty::query::queries;
@@ -11,7 +10,7 @@ use crate::util::profiling::ProfileCategory;
 use std::borrow::Cow;
 use std::hash::Hash;
 use std::fmt::Debug;
-use rustc_data_structures::sync::Lock;
+use rustc_data_structures::sharded::Sharded;
 use rustc_data_structures::fingerprint::Fingerprint;
 use crate::ich::StableHashingContext;
 
@@ -31,7 +30,7 @@ pub(crate) trait QueryAccessors<'tcx>: QueryConfig<'tcx> {
     fn query(key: Self::Key) -> Query<'tcx>;
 
     // Don't use this method to access query results, instead use the methods on TyCtxt
-    fn query_cache<'a>(tcx: TyCtxt<'tcx>) -> &'a Lock<QueryCache<'tcx, Self>>;
+    fn query_cache<'a>(tcx: TyCtxt<'tcx>) -> &'a Sharded<QueryCache<'tcx, Self>>;
 
     fn to_dep_node(tcx: TyCtxt<'tcx>, key: &Self::Key) -> DepNode;
 
@@ -54,7 +53,7 @@ pub(crate) trait QueryDescription<'tcx>: QueryAccessors<'tcx> {
         false
     }
 
-    fn try_load_from_disk(_: TyCtxt<'tcx>, _: SerializedDepNodeIndex) -> Option<Self::Value> {
+    fn try_load_from_disk(_: TyCtxt<'tcx>, _: DepNodeIndex) -> Option<Self::Value> {
         bug!("QueryDescription::load_from_disk() called for an unsupported query.")
     }
 }
@@ -86,7 +85,7 @@ macro_rules! impl_disk_cacheable_query(
 
             #[inline]
             fn try_load_from_disk(tcx: TyCtxt<'tcx>,
-                                      id: SerializedDepNodeIndex)
+                                      id: DepNodeIndex)
                                       -> Option<Self::Value> {
                 tcx.queries.on_disk_cache.try_load_query_result(tcx, id)
             }

src/librustc/ty/query/config.rs

@@ -1,4 +1,4 @@
-use crate::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
+use crate::dep_graph::DepNodeIndex;
 use crate::hir;
 use crate::hir::def_id::{CrateNum, DefIndex, DefId, LocalDefId, LOCAL_CRATE};
 use crate::hir::map::definitions::DefPathHash;
@@ -62,11 +62,11 @@ pub struct OnDiskCache<'sess> {
 
     // A map from dep-node to the position of the cached query result in
     // `serialized_data`.
-    query_result_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
+    query_result_index: FxHashMap<DepNodeIndex, AbsoluteBytePos>,
 
     // A map from dep-node to the position of any associated diagnostics in
     // `serialized_data`.
-    prev_diagnostics_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
+    prev_diagnostics_index: FxHashMap<DepNodeIndex, AbsoluteBytePos>,
 
     alloc_decoding_state: AllocDecodingState,
 }
@@ -82,8 +82,8 @@ struct Footer {
     interpret_alloc_index: Vec<u32>,
 }
 
-type EncodedQueryResultIndex = Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>;
-type EncodedDiagnosticsIndex = Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>;
+type EncodedQueryResultIndex = Vec<(DepNodeIndex, AbsoluteBytePos)>;
+type EncodedDiagnosticsIndex = Vec<(DepNodeIndex, AbsoluteBytePos)>;
 type EncodedDiagnostics = Vec<Diagnostic>;
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)]
@@ -224,18 +224,18 @@ impl<'sess> OnDiskCache<'sess> {
 
                 // const eval is special, it only encodes successfully evaluated constants
                 use crate::ty::query::QueryAccessors;
-                let cache = const_eval::query_cache(tcx).borrow();
-                assert!(cache.active.is_empty());
-                for (key, entry) in cache.results.iter() {
+                let shards = const_eval::query_cache(tcx).lock_shards();
+                assert!(shards.iter().all(|shard| shard.active.is_empty()));
+                for (key, entry) in shards.iter().flat_map(|shard| shard.results.iter()) {
                     use crate::ty::query::config::QueryDescription;
                     if const_eval::cache_on_disk(tcx, key.clone()) {
                         if let Ok(ref value) = entry.value {
-                            let dep_node = SerializedDepNodeIndex::new(entry.index.index());
+                            let dep_node = DepNodeIndex::new(entry.index.index());
 
                             // Record position of the cache entry
                             qri.push((dep_node, AbsoluteBytePos::new(enc.position())));
 
-                            // Encode the type check tables with the SerializedDepNodeIndex
+                            // Encode the type check tables with the DepNodeIndex
                             // as tag.
                             enc.encode_tagged(dep_node, value)?;
                         }
@@ -253,7 +253,7 @@ impl<'sess> OnDiskCache<'sess> {
                 let pos = AbsoluteBytePos::new(encoder.position());
                 // Let's make sure we get the expected type here:
                 let diagnostics: &EncodedDiagnostics = diagnostics;
-                let dep_node_index = SerializedDepNodeIndex::new(dep_node_index.index());
+                let dep_node_index = DepNodeIndex::new(dep_node_index.index());
                 encoder.encode_tagged(dep_node_index, diagnostics)?;
 
                 Ok((dep_node_index, pos))
@@ -327,7 +327,7 @@ impl<'sess> OnDiskCache<'sess> {
     pub fn load_diagnostics<'tcx>(
         &self,
         tcx: TyCtxt<'tcx>,
-        dep_node_index: SerializedDepNodeIndex,
+        dep_node_index: DepNodeIndex,
     ) -> Vec<Diagnostic> {
         let diagnostics: Option<EncodedDiagnostics> = self.load_indexed(
             tcx,
@@ -352,11 +352,11 @@ impl<'sess> OnDiskCache<'sess> {
     }
 
     /// Returns the cached query result if there is something in the cache for
-    /// the given `SerializedDepNodeIndex`; otherwise returns `None`.
+    /// the given `DepNodeIndex`; otherwise returns `None`.
     pub fn try_load_query_result<'tcx, T>(
         &self,
         tcx: TyCtxt<'tcx>,
-        dep_node_index: SerializedDepNodeIndex,
+        dep_node_index: DepNodeIndex,
     ) -> Option<T>
     where
         T: Decodable,
@@ -386,8 +386,8 @@ impl<'sess> OnDiskCache<'sess> {
     fn load_indexed<'tcx, T>(
         &self,
         tcx: TyCtxt<'tcx>,
-        dep_node_index: SerializedDepNodeIndex,
-        index: &FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
+        dep_node_index: DepNodeIndex,
+        index: &FxHashMap<DepNodeIndex, AbsoluteBytePos>,
         debug_tag: &'static str,
     ) -> Option<T>
     where
@@ -1087,16 +1087,16 @@ where
         unsafe { ::std::intrinsics::type_name::<Q>() });
 
     time_ext(tcx.sess.time_extended(), Some(tcx.sess), desc, || {
-        let map = Q::query_cache(tcx).borrow();
-        assert!(map.active.is_empty());
-        for (key, entry) in map.results.iter() {
+        let shards = Q::query_cache(tcx).lock_shards();
+        assert!(shards.iter().all(|shard| shard.active.is_empty()));
+        for (key, entry) in shards.iter().flat_map(|shard| shard.results.iter()) {
             if Q::cache_on_disk(tcx, key.clone()) {
-                let dep_node = SerializedDepNodeIndex::new(entry.index.index());
+                let dep_node = DepNodeIndex::new(entry.index.index());
 
                 // Record position of the cache entry
                 query_result_index.push((dep_node, AbsoluteBytePos::new(encoder.position())));
 
-                // Encode the type check tables with the SerializedDepNodeIndex
+                // Encode the type check tables with the DepNodeIndex
                 // as tag.
                 encoder.encode_tagged(dep_node, &entry.value)?;
             }

src/librustc/ty/query/on_disk_cache.rs

@@ -2,7 +2,7 @@
 //! generate the actual methods on tcx which find and execute the provider,
 //! manage the caches, and so forth.
 
-use crate::dep_graph::{DepNodeIndex, DepNode, DepKind, SerializedDepNodeIndex};
+use crate::dep_graph::{DepNodeIndex, DepNode, DepKind};
 use crate::ty::tls;
 use crate::ty::{self, TyCtxt};
 use crate::ty::query::Query;
@@ -17,6 +17,7 @@ use errors::Diagnostic;
 use errors::FatalError;
 use rustc_data_structures::fx::{FxHashMap};
 use rustc_data_structures::sync::{Lrc, Lock};
+use rustc_data_structures::sharded::Sharded;
 use rustc_data_structures::thin_vec::ThinVec;
 #[cfg(not(parallel_compiler))]
 use rustc_data_structures::cold_path;
@@ -90,7 +91,7 @@ macro_rules! profq_query_msg {
 /// A type representing the responsibility to execute the job in the `job` field.
 /// This will poison the relevant query if dropped.
 pub(super) struct JobOwner<'a, 'tcx, Q: QueryDescription<'tcx> + 'a> {
-    cache: &'a Lock<QueryCache<'tcx, Q>>,
+    cache: &'a Sharded<QueryCache<'tcx, Q>>,
     key: Q::Key,
     job: Lrc<QueryJob<'tcx>>,
 }
@@ -107,7 +108,7 @@ impl<'a, 'tcx, Q: QueryDescription<'tcx>> JobOwner<'a, 'tcx, Q> {
     pub(super) fn try_get(tcx: TyCtxt<'tcx>, span: Span, key: &Q::Key) -> TryGetJob<'a, 'tcx, Q> {
         let cache = Q::query_cache(tcx);
         loop {
-            let mut lock = cache.borrow_mut();
+            let mut lock = cache.get_shard_by_value(key).lock();
             if let Some(value) = lock.results.get(key) {
                 profq_msg!(tcx, ProfileQueriesMsg::CacheHit);
                 tcx.sess.profiler(|p| p.record_query_hit(Q::NAME));
@@ -191,7 +192,7 @@ impl<'a, 'tcx, Q: QueryDescription<'tcx>> JobOwner<'a, 'tcx, Q> {
 
         let value = QueryValue::new(result.clone(), dep_node_index);
         {
-            let mut lock = cache.borrow_mut();
+            let mut lock = cache.get_shard_by_value(&key).lock();
             lock.active.remove(&key);
             lock.results.insert(key, value);
         }
@@ -215,7 +216,8 @@ impl<'a, 'tcx, Q: QueryDescription<'tcx>> Drop for JobOwner<'a, 'tcx, Q> {
     #[cold]
     fn drop(&mut self) {
         // Poison the query so jobs waiting on it panic
-        self.cache.borrow_mut().active.insert(self.key.clone(), QueryResult::Poisoned);
+        let shard = self.cache.get_shard_by_value(&self.key);
+        shard.lock().active.insert(self.key.clone(), QueryResult::Poisoned);
         // Also signal the completion of the job, so waiters
         // will continue execution
         self.job.signal_complete();
@@ -411,10 +413,9 @@ impl<'tcx> TyCtxt<'tcx> {
             // try_mark_green(), so we can ignore them here.
             let loaded = self.start_query(job.job.clone(), None, |tcx| {
                 let marked = tcx.dep_graph.try_mark_green_and_read(tcx, &dep_node);
-                marked.map(|(prev_dep_node_index, dep_node_index)| {
+                marked.map(|dep_node_index| {
                     (tcx.load_from_disk_and_cache_in_memory::<Q>(
                         key.clone(),
-                        prev_dep_node_index,
                         dep_node_index,
                         &dep_node
                     ), dep_node_index)
@@ -434,7 +435,6 @@ impl<'tcx> TyCtxt<'tcx> {
     fn load_from_disk_and_cache_in_memory<Q: QueryDescription<'tcx>>(
         self,
         key: Q::Key,
-        prev_dep_node_index: SerializedDepNodeIndex,
         dep_node_index: DepNodeIndex,
         dep_node: &DepNode,
     ) -> Q::Value {
@@ -447,7 +447,7 @@ impl<'tcx> TyCtxt<'tcx> {
         let result = if Q::cache_on_disk(self.global_tcx(), key.clone()) &&
                         self.sess.opts.debugging_opts.incremental_queries {
             self.sess.profiler(|p| p.incremental_load_result_start(Q::NAME));
-            let result = Q::try_load_from_disk(self.global_tcx(), prev_dep_node_index);
+            let result = Q::try_load_from_disk(self.global_tcx(), dep_node_index);
             self.sess.profiler(|p| p.incremental_load_result_end(Q::NAME));
 
             // We always expect to find a cached result for things that
@@ -486,11 +486,11 @@ impl<'tcx> TyCtxt<'tcx> {
         // If -Zincremental-verify-ich is specified, re-hash results from
         // the cache and make sure that they have the expected fingerprint.
         if unlikely!(self.sess.opts.debugging_opts.incremental_verify_ich) {
-            self.incremental_verify_ich::<Q>(&result, dep_node, dep_node_index);
+            self.incremental_verify_ich::<Q>(&result, dep_node);
         }
 
         if unlikely!(self.sess.opts.debugging_opts.query_dep_graph) {
-            self.dep_graph.mark_loaded_from_cache(dep_node_index, true);
+            self.dep_graph.mark_loaded_from_cache(*dep_node, true);
         }
 
         result
@@ -502,24 +502,18 @@ impl<'tcx> TyCtxt<'tcx> {
         self,
         result: &Q::Value,
         dep_node: &DepNode,
-        dep_node_index: DepNodeIndex,
     ) {
         use crate::ich::Fingerprint;
 
-        assert!(Some(self.dep_graph.fingerprint_of(dep_node_index)) ==
-                self.dep_graph.prev_fingerprint_of(dep_node),
-                "Fingerprint for green query instance not loaded \
-                    from cache: {:?}", dep_node);
-
         debug!("BEGIN verify_ich({:?})", dep_node);
         let mut hcx = self.create_stable_hashing_context();
 
         let new_hash = Q::hash_result(&mut hcx, result).unwrap_or(Fingerprint::ZERO);
         debug!("END verify_ich({:?})", dep_node);
 
-        let old_hash = self.dep_graph.fingerprint_of(dep_node_index);
+        let old_hash = self.dep_graph.prev_fingerprint_of(dep_node);
 
-        assert!(new_hash == old_hash, "Found unstable fingerprints \
+        assert!(Some(new_hash) == old_hash, "Found unstable fingerprints \
             for {:?}", dep_node);
     }
 
@@ -566,7 +560,7 @@ impl<'tcx> TyCtxt<'tcx> {
         profq_msg!(self, ProfileQueriesMsg::ProviderEnd);
 
         if unlikely!(self.sess.opts.debugging_opts.query_dep_graph) {
-            self.dep_graph.mark_loaded_from_cache(dep_node_index, false);
+            self.dep_graph.mark_loaded_from_cache(dep_node, false);
         }
 
         if dep_node.kind != crate::dep_graph::DepKind::Null {
@@ -683,7 +677,7 @@ macro_rules! define_queries_inner {
         use std::mem;
         #[cfg(parallel_compiler)]
         use ty::query::job::QueryResult;
-        use rustc_data_structures::sync::Lock;
+        use rustc_data_structures::sharded::Sharded;
         use crate::{
             rustc_data_structures::stable_hasher::HashStable,
             rustc_data_structures::stable_hasher::StableHasherResult,
@@ -715,18 +709,17 @@ macro_rules! define_queries_inner {
             pub fn collect_active_jobs(&self) -> Vec<Lrc<QueryJob<$tcx>>> {
                 let mut jobs = Vec::new();
 
-                // We use try_lock here since we are only called from the
+                // We use try_lock_shards here since we are only called from the
                 // deadlock handler, and this shouldn't be locked.
                 $(
-                    jobs.extend(
-                        self.$name.try_lock().unwrap().active.values().filter_map(|v|
-                            if let QueryResult::Started(ref job) = *v {
-                                Some(job.clone())
-                            } else {
-                                None
-                            }
-                        )
-                    );
+                    let shards = self.$name.try_lock_shards().unwrap();
+                    jobs.extend(shards.iter().flat_map(|shard| shard.active.values().filter_map(|v|
+                        if let QueryResult::Started(ref job) = *v {
+                            Some(job.clone())
+                        } else {
+                            None
+                        }
+                    )));
                 )*
 
                 jobs
@@ -748,26 +741,27 @@ macro_rules! define_queries_inner {
 
                 fn stats<'tcx, Q: QueryConfig<'tcx>>(
                     name: &'static str,
-                    map: &QueryCache<'tcx, Q>
+                    map: &Sharded<QueryCache<'tcx, Q>>,
                 ) -> QueryStats {
+                    let map = map.lock_shards();
                     QueryStats {
                         name,
                         #[cfg(debug_assertions)]
-                        cache_hits: map.cache_hits,
+                        cache_hits: map.iter().map(|shard| shard.cache_hits).sum(),
                         #[cfg(not(debug_assertions))]
                         cache_hits: 0,
                         key_size: mem::size_of::<Q::Key>(),
                         key_type: unsafe { type_name::<Q::Key>() },
                         value_size: mem::size_of::<Q::Value>(),
                         value_type: unsafe { type_name::<Q::Value>() },
-                        entry_count: map.results.len(),
+                        entry_count: map.iter().map(|shard| shard.results.len()).sum(),
                     }
                 }
 
                 $(
                     queries.push(stats::<queries::$name<'_>>(
                         stringify!($name),
-                        &*self.$name.lock()
+                        &self.$name,
                     ));
                 )*
 
@@ -939,7 +933,7 @@ macro_rules! define_queries_inner {
             }
 
             #[inline(always)]
-            fn query_cache<'a>(tcx: TyCtxt<$tcx>) -> &'a Lock<QueryCache<$tcx, Self>> {
+            fn query_cache<'a>(tcx: TyCtxt<$tcx>) -> &'a Sharded<QueryCache<$tcx, Self>> {
                 &tcx.queries.$name
             }
 
@@ -1066,7 +1060,7 @@ macro_rules! define_queries_struct {
             providers: IndexVec<CrateNum, Providers<$tcx>>,
             fallback_extern_providers: Box<Providers<$tcx>>,
 
-            $($(#[$attr])*  $name: Lock<QueryCache<$tcx, queries::$name<$tcx>>>,)*
+            $($(#[$attr])*  $name: Sharded<QueryCache<$tcx, queries::$name<$tcx>>>,)*
         }
     };
 }

src/librustc/ty/query/plumbing.rs

@@ -19,6 +19,7 @@ rustc_cratesio_shim = { path = "../librustc_cratesio_shim" }
 serialize = { path = "../libserialize" }
 graphviz = { path = "../libgraphviz" }
 cfg-if = "0.1.2"
+crossbeam-utils = { version = "0.6.5", features = ["nightly"] }
 stable_deref_trait = "1.0.0"
 rayon = { version = "0.2.0", package = "rustc-rayon" }
 rayon-core = { version = "0.2.0", package = "rustc-rayon-core" }

src/librustc_data_structures/Cargo.toml

@@ -79,7 +79,6 @@ pub mod flock;
 pub mod fx;
 pub mod graph;
 pub mod indexed_vec;
-pub mod interner;
 pub mod jobserver;
 pub mod obligation_forest;
 pub mod owning_ref;
@@ -91,6 +90,7 @@ pub use ena::snapshot_vec;
 pub mod sorted_map;
 #[macro_use] pub mod stable_hasher;
 pub mod sync;
+pub mod sharded;
 pub mod tiny_list;
 pub mod thin_vec;
 pub mod transitive_relation;

src/librustc_data_structures/interner.rs

@@ -0,0 +1,163 @@
+use std::hash::{Hasher, Hash};
+use std::mem;
+use std::borrow::Borrow;
+use std::collections::hash_map::RawEntryMut;
+use smallvec::SmallVec;
+use crate::fx::{FxHasher, FxHashMap};
+use crate::sync::{Lock, LockGuard};
+
+#[derive(Clone, Default)]
+#[cfg_attr(parallel_compiler, repr(align(64)))]
+struct CacheAligned<T>(T);
+
+#[cfg(parallel_compiler)]
+const SHARD_BITS: usize = 5;
+
+#[cfg(not(parallel_compiler))]
+const SHARD_BITS: usize = 0;
+
+pub const SHARDS: usize = 1 << SHARD_BITS;
+
+/// An array of cache-line aligned inner locked structures with convenience methods.
+#[derive(Clone)]
+pub struct Sharded<T> {
+    shards: [CacheAligned<Lock<T>>; SHARDS],
+}
+
+impl<T: Default> Default for Sharded<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new(|_| T::default())
+    }
+}
+
+impl<T> Sharded<T> {
+    #[inline]
+    pub fn new(mut value: impl FnMut(usize) -> T) -> Self {
+        // Create a vector of the values we want
+        let mut values: SmallVec<[_; SHARDS]> = (0..SHARDS).map(|i| {
+            CacheAligned(Lock::new(value(i)))
+        }).collect();
+
+        // Create an unintialized array
+        let mut shards: mem::MaybeUninit<[CacheAligned<Lock<T>>; SHARDS]> =
+            mem::MaybeUninit::uninit();
+
+        unsafe {
+            // Copy the values into our array
+            let first = shards.as_mut_ptr() as *mut CacheAligned<Lock<T>>;
+            values.as_ptr().copy_to_nonoverlapping(first, SHARDS);
+
+            // Ignore the content of the vector
+            values.set_len(0);
+
+            Sharded {
+                shards: shards.assume_init(),
+            }
+        }
+    }
+
+    #[inline]
+    pub fn get_shard_by_index(&self, index: usize) -> &Lock<T> {
+        &self.shards[index % SHARDS].0
+    }
+
+    #[inline]
+    pub fn get_shard_by_value<K: Hash + ?Sized>(&self, val: &K) -> &Lock<T> {
+        if SHARDS == 1 {
+            &self.shards[0].0
+        } else {
+            self.get_shard_by_hash(make_hash(val))
+        }
+    }
+
+    #[inline]
+    pub fn get_shard_by_value_mut<K: Hash + ?Sized>(&mut self, val: &K) -> &mut T {
+        if SHARDS == 1 {
+            self.shards[0].0.get_mut()
+        } else {
+            self.shards[Self::get_shard_index_by_hash(make_hash(val))].0.get_mut()
+        }
+    }
+
+    #[inline]
+    fn get_shard_index_by_hash(hash: u64) -> usize {
+        let hash_len = mem::size_of::<usize>();
+        // Ignore the top 7 bits as hashbrown uses these and get the next SHARD_BITS highest bits.
+        // hashbrown also uses the lowest bits, so we can't use those
+        let bits = (hash >> (hash_len * 8 - 7 - SHARD_BITS)) as usize;
+        bits % SHARDS
+    }
+
+    #[inline]
+    pub fn get_shard_by_hash(&self, hash: u64) -> &Lock<T> {
+        &self.shards[Self::get_shard_index_by_hash(hash)].0
+    }
+
+    pub fn lock_shards(&self) -> Vec<LockGuard<'_, T>> {
+        (0..SHARDS).map(|i| self.shards[i].0.lock()).collect()
+    }
+
+    pub fn try_lock_shards(&self) -> Option<Vec<LockGuard<'_, T>>> {
+        let mut result = Vec::with_capacity(SHARDS);
+        for i in 0..SHARDS {
+            result.push(self.shards[i].0.try_lock()?);
+        }
+        Some(result)
+    }
+}
+
+pub type ShardedHashMap<K, V> = Sharded<FxHashMap<K, V>>;
+
+impl<K: Eq + Hash, V> ShardedHashMap<K, V> {
+    pub fn len(&self) -> usize{
+        self.lock_shards().iter().map(|shard| shard.len()).sum()
+    }
+}
+
+impl<K: Eq + Hash + Copy> ShardedHashMap<K, ()> {
+    #[inline]
+    pub fn intern_ref<Q: ?Sized>(&self, value: &Q, make: impl FnOnce() -> K) -> K
+        where K: Borrow<Q>,
+              Q: Hash + Eq
+    {
+        let hash = make_hash(value);
+        let mut shard = self.get_shard_by_hash(hash).lock();
+        let entry = shard.raw_entry_mut().from_key_hashed_nocheck(hash, value);
+
+        match entry {
+            RawEntryMut::Occupied(e) => *e.key(),
+            RawEntryMut::Vacant(e) => {
+                let v = make();
+                e.insert_hashed_nocheck(hash, v, ());
+                v
+            }
+        }
+    }
+
+    #[inline]
+    pub fn intern<Q>(&self, value: Q, make: impl FnOnce(Q) -> K) -> K
+        where K: Borrow<Q>,
+              Q: Hash + Eq
+    {
+        let hash = make_hash(&value);
+        let mut shard = self.get_shard_by_hash(hash).lock();
+        let entry = shard.raw_entry_mut().from_key_hashed_nocheck(hash, &value);
+
+        match entry {
+            RawEntryMut::Occupied(e) => *e.key(),
+            RawEntryMut::Vacant(e) => {
+                let v = make(value);
+                e.insert_hashed_nocheck(hash, v, ());
+                v
+            }
+        }
+    }
+}
+
+#[inline]
+fn make_hash<K: Hash + ?Sized>(val: &K) -> u64 {
+    let mut state = FxHasher::default();
+    val.hash(&mut state);
+    state.finish()
+}

src/librustc_data_structures/lib.rs

@@ -67,6 +67,71 @@ cfg_if! {
         use std::ops::Add;
         use std::panic::{resume_unwind, catch_unwind, AssertUnwindSafe};
 
+        #[derive(Debug)]
+        pub struct AtomicCell<T: Copy>(Cell<T>);
+
+        impl<T: Copy> AtomicCell<T> {
+            #[inline]
+            pub fn new(v: T) -> Self {
+                AtomicCell(Cell::new(v))
+            }
+
+            #[inline]
+            pub fn get_mut(&mut self) -> &mut T {
+                self.0.get_mut()
+            }
+        }
+
+        impl<T: Copy> AtomicCell<T> {
+            pub fn into_inner(self) -> T {
+                self.0.into_inner()
+            }
+
+            #[inline]
+            pub fn load(&self) -> T {
+                self.0.get()
+            }
+
+            #[inline]
+            pub fn store(&self, val: T) {
+                self.0.set(val)
+            }
+
+            pub fn swap(&self, val: T) -> T {
+                self.0.replace(val)
+            }
+        }
+
+        impl<T: Copy + PartialEq> AtomicCell<T> {
+            pub fn compare_and_swap(&self, current: T, new: T) -> T {
+                match self.compare_exchange(current, new) {
+                    Ok(v) => v,
+                    Err(v) => v,
+                }
+            }
+
+            pub fn compare_exchange(&self,
+                                    current: T,
+                                    new: T)
+                                    -> Result<T, T> {
+                let read = self.0.get();
+                if read == current {
+                    self.0.set(new);
+                    Ok(read)
+                } else {
+                    Err(read)
+                }
+            }
+        }
+
+        impl<T: Add<Output=T> + Copy> AtomicCell<T> {
+            pub fn fetch_add(&self, val: T) -> T {
+                let old = self.0.get();
+                self.0.set(old + val);
+                old
+            }
+        }
+
         #[derive(Debug)]
         pub struct Atomic<T: Copy>(Cell<T>);
 
@@ -77,7 +142,7 @@ cfg_if! {
             }
         }
 
-        impl<T: Copy + PartialEq> Atomic<T> {
+        impl<T: Copy> Atomic<T> {
             pub fn into_inner(self) -> T {
                 self.0.into_inner()
             }
@@ -95,7 +160,9 @@ cfg_if! {
             pub fn swap(&self, val: T, _: Ordering) -> T {
                 self.0.replace(val)
             }
+        }
 
+        impl<T: Copy + PartialEq> Atomic<T> {
             pub fn compare_exchange(&self,
                                     current: T,
                                     new: T,
@@ -271,6 +338,8 @@ cfg_if! {
 
         pub use std::sync::atomic::{AtomicBool, AtomicUsize, AtomicU32, AtomicU64};
 
+        pub use crossbeam_utils::atomic::AtomicCell;
+
         pub use std::sync::Arc as Lrc;
         pub use std::sync::Weak as Weak;
 

src/librustc_data_structures/sharded.rs

@@ -1,7 +1,7 @@
 //! Code to save/load the dep-graph from files.
 
 use rustc_data_structures::fx::FxHashMap;
-use rustc::dep_graph::{PreviousDepGraph, SerializedDepGraph, WorkProduct, WorkProductId};
+use rustc::dep_graph::{PreviousDepGraph, DepGraphArgs, SerializedDepGraph, CurrentDepGraph};
 use rustc::session::Session;
 use rustc::ty::TyCtxt;
 use rustc::ty::query::OnDiskCache;
@@ -23,16 +23,14 @@ pub fn dep_graph_tcx_init<'tcx>(tcx: TyCtxt<'tcx>) {
     tcx.allocate_metadata_dep_nodes();
 }
 
-type WorkProductMap = FxHashMap<WorkProductId, WorkProduct>;
-
 pub enum LoadResult<T> {
     Ok { data: T },
     DataOutOfDate,
     Error { message: String },
 }
 
-impl LoadResult<(PreviousDepGraph, WorkProductMap)> {
-    pub fn open(self, sess: &Session) -> (PreviousDepGraph, WorkProductMap) {
+impl LoadResult<DepGraphArgs> {
+    pub fn open(self, sess: &Session) -> DepGraphArgs {
         match self {
             LoadResult::Error { message } => {
                 sess.warn(&message);
@@ -93,7 +91,7 @@ impl<T> MaybeAsync<T> {
     }
 }
 
-pub type DepGraphFuture = MaybeAsync<LoadResult<(PreviousDepGraph, WorkProductMap)>>;
+pub type DepGraphFuture = MaybeAsync<LoadResult<DepGraphArgs>>;
 
 /// Launch a thread and load the dependency graph in the background.
 pub fn load_dep_graph(sess: &Session) -> DepGraphFuture {
@@ -185,7 +183,21 @@ pub fn load_dep_graph(sess: &Session) -> DepGraphFuture {
                     let dep_graph = SerializedDepGraph::decode(&mut decoder)
                         .expect("Error reading cached dep-graph");
 
-                    LoadResult::Ok { data: (PreviousDepGraph::new(dep_graph), prev_work_products) }
+                    let (prev_graph, state) = PreviousDepGraph::new_and_state(dep_graph);
+                    let current = time_ext(
+                        time_passes,
+                        None,
+                        "background setup current dep-graph",
+                        || CurrentDepGraph::new(&prev_graph),
+                    );
+                    LoadResult::Ok {
+                        data: DepGraphArgs {
+                            state,
+                            prev_graph,
+                            prev_work_products,
+                            current,
+                        }
+                    }
                 }
             }
         })

src/librustc_data_structures/sync.rs

@@ -173,13 +173,13 @@ impl Compiler {
             Ok(match self.dep_graph_future()?.take() {
                 None => DepGraph::new_disabled(),
                 Some(future) => {
-                    let (prev_graph, prev_work_products) =
+                    let args =
                         time(self.session(), "blocked while dep-graph loading finishes", || {
                             future.open().unwrap_or_else(|e| rustc_incremental::LoadResult::Error {
                                 message: format!("could not decode incremental cache: {:?}", e),
                             }).open(self.session())
                         });
-                    DepGraph::new(prev_graph, prev_work_products)
+                    DepGraph::new(args)
                 }
             })
         })

src/librustc_incremental/persist/load.rs

@@ -328,7 +328,7 @@ fn add_query_description_impl(
                 #[inline]
                 fn try_load_from_disk(
                     #tcx: TyCtxt<'tcx>,
-                    #id: SerializedDepNodeIndex
+                    #id: DepNodeIndex
                 ) -> Option<Self::Value> {
                     #block
                 }
@@ -339,7 +339,7 @@ fn add_query_description_impl(
                 #[inline]
                 fn try_load_from_disk(
                     tcx: TyCtxt<'tcx>,
-                    id: SerializedDepNodeIndex
+                    id: DepNodeIndex
                 ) -> Option<Self::Value> {
                     tcx.queries.on_disk_cache.try_load_query_result(tcx, id)
                 }

src/librustc_interface/queries.rs

@@ -7,7 +7,6 @@
 //! `tcx.inherent_impls(def_id)`). That value, however,
 //! is computed by selecting an idea from this table.
 
-use rustc::dep_graph::DepKind;
 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use rustc::hir;
 use rustc::hir::itemlikevisit::ItemLikeVisitor;
@@ -36,35 +35,11 @@ pub fn crate_inherent_impls<'tcx>(
 pub fn inherent_impls<'tcx>(tcx: TyCtxt<'tcx>, ty_def_id: DefId) -> &'tcx [DefId] {
     assert!(ty_def_id.is_local());
 
-    // NB. Until we adopt the red-green dep-tracking algorithm (see
-    // [the plan] for details on that), we do some hackery here to get
-    // the dependencies correct.  Basically, we use a `with_ignore` to
-    // read the result we want. If we didn't have the `with_ignore`,
-    // we would wind up with a dependency on the entire crate, which
-    // we don't want. Then we go and add dependencies on all the impls
-    // in the result (which is what we wanted).
-    //
-    // The result is a graph with an edge from `Hir(I)` for every impl
-    // `I` defined on some type `T` to `CoherentInherentImpls(T)`,
-    // thus ensuring that if any of those impls change, the set of
-    // inherent impls is considered dirty.
-    //
-    // [the plan]: https://github.com/rust-lang/rust-roadmap/issues/4
-
-    let result = tcx.dep_graph.with_ignore(|| {
-        let crate_map = tcx.crate_inherent_impls(ty_def_id.krate);
-        match crate_map.inherent_impls.get(&ty_def_id) {
-            Some(v) => &v[..],
-            None => &[],
-        }
-    });
-
-    for &impl_def_id in &result[..] {
-        let def_path_hash = tcx.def_path_hash(impl_def_id);
-        tcx.dep_graph.read(def_path_hash.to_dep_node(DepKind::Hir));
+    let crate_map = tcx.crate_inherent_impls(ty_def_id.krate);
+    match crate_map.inherent_impls.get(&ty_def_id) {
+        Some(v) => &v[..],
+        None => &[],
     }
-
-    result
 }
 
 struct InherentCollect<'tcx> {