incr.comp.: Cache DepNodes with corresponding query results.

michaelwoerister · michaelwoerister · commit 6d049fb5bb36 · 2017-07-10T12:21:39.000+02:00
diff --git a/src/librustc/dep_graph/edges.rs b/src/librustc/dep_graph/edges.rs
@@ -19,21 +19,24 @@ use super::debug::EdgeFilter;
 
 pub struct DepGraphEdges {
     nodes: Vec<DepNode>,
-    indices: FxHashMap<DepNode, IdIndex>,
-    edges: FxHashSet<(IdIndex, IdIndex)>,
+    indices: FxHashMap<DepNode, DepNodeIndex>,
+    edges: FxHashSet<(DepNodeIndex, DepNodeIndex)>,
     task_stack: Vec<OpenTask>,
     forbidden_edge: Option<EdgeFilter>,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-struct IdIndex {
+pub struct DepNodeIndex {
     index: u32
 }
 
-impl IdIndex {
-    fn new(v: usize) -> IdIndex {
+impl DepNodeIndex {
+
+    pub const INVALID: DepNodeIndex = DepNodeIndex { index: ::std::u32::MAX };
+
+    fn new(v: usize) -> DepNodeIndex {
         assert!((v & 0xFFFF_FFFF) == v);
-        IdIndex { index: v as u32 }
+        DepNodeIndex { index: v as u32 }
     }
 
     fn index(self) -> usize {
@@ -80,7 +83,7 @@ impl DepGraphEdges {
         }
     }
 
-    fn id(&self, index: IdIndex) -> DepNode {
+    fn id(&self, index: DepNodeIndex) -> DepNode {
         self.nodes[index.index()]
     }
 
@@ -101,7 +104,7 @@ impl DepGraphEdges {
         });
     }
 
-    pub fn pop_task(&mut self, key: DepNode) {
+    pub fn pop_task(&mut self, key: DepNode) -> DepNodeIndex {
         let popped_node = self.task_stack.pop().unwrap();
 
         if let OpenTask::Regular {
@@ -117,6 +120,8 @@ impl DepGraphEdges {
                 let source_id = self.get_or_create_node(read);
                 self.edges.insert((source_id, target_id));
             }
+
+            target_id
         } else {
             bug!("pop_task() - Expected regular task to be popped")
         }
@@ -129,7 +134,7 @@ impl DepGraphEdges {
         });
     }
 
-    pub fn pop_anon_task(&mut self, kind: DepKind) -> DepNode {
+    pub fn pop_anon_task(&mut self, kind: DepKind) -> DepNodeIndex {
         let popped_node = self.task_stack.pop().unwrap();
 
         if let OpenTask::Anon {
@@ -155,8 +160,8 @@ impl DepGraphEdges {
                 hash: fingerprint,
             };
 
-            if self.indices.contains_key(&target_dep_node) {
-                return target_dep_node;
+            if let Some(&index) = self.indices.get(&target_dep_node) {
+                return index;
             }
 
             let target_id = self.get_or_create_node(target_dep_node);
@@ -166,7 +171,7 @@ impl DepGraphEdges {
                 self.edges.insert((source_id, target_id));
             }
 
-            target_dep_node
+            target_id
         } else {
             bug!("pop_anon_task() - Expected anonymous task to be popped")
         }
@@ -210,6 +215,11 @@ impl DepGraphEdges {
         }
     }
 
+    pub fn read_index(&mut self, source: DepNodeIndex) {
+        let dep_node = self.nodes[source.index()];
+        self.read(dep_node);
+    }
+
     pub fn query(&self) -> DepGraphQuery {
         let edges: Vec<_> = self.edges.iter()
                                       .map(|&(i, j)| (self.id(i), self.id(j)))
@@ -229,7 +239,7 @@ impl DepGraphEdges {
     }
 
     #[inline]
-    fn get_or_create_node(&mut self, dep_node: DepNode) -> IdIndex {
+    fn get_or_create_node(&mut self, dep_node: DepNode) -> DepNodeIndex {
         let DepGraphEdges {
             ref mut indices,
             ref mut nodes,
@@ -239,7 +249,7 @@ impl DepGraphEdges {
         *indices.entry(dep_node).or_insert_with(|| {
             let next_id = nodes.len();
             nodes.push(dep_node);
-            IdIndex::new(next_id)
+            DepNodeIndex::new(next_id)
         })
      }
 }
diff --git a/src/librustc/dep_graph/graph.rs b/src/librustc/dep_graph/graph.rs
@@ -17,7 +17,7 @@ use super::dep_node::{DepNode, DepKind, WorkProductId};
 use super::query::DepGraphQuery;
 use super::raii;
 use super::safe::DepGraphSafe;
-use super::edges::DepGraphEdges;
+use super::edges::{DepGraphEdges, DepNodeIndex};
 
 #[derive(Clone)]
 pub struct DepGraph {
@@ -108,16 +108,27 @@ impl DepGraph {
     ///   `arg` parameter.
     ///
     /// [README]: README.md
-    pub fn with_task<C, A, R>(&self, key: DepNode, cx: C, arg: A, task: fn(C, A) -> R) -> R
-        where C: DepGraphSafe, A: DepGraphSafe
+    pub fn with_task<C, A, R>(&self,
+                              key: DepNode,
+                              cx: C,
+                              arg: A,
+                              task: fn(C, A) -> R)
+                              -> (R, DepNodeIndex)
+        where C: DepGraphSafe
     {
-        let _task = self.in_task(key);
-        task(cx, arg)
+        if let Some(ref data) = self.data {
+            data.edges.borrow_mut().push_task(key);
+            let result = task(cx, arg);
+            let dep_node_index = data.edges.borrow_mut().pop_task(key);
+            (result, dep_node_index)
+        } else {
+            (task(cx, arg), DepNodeIndex::INVALID)
+        }
     }
 
     /// Execute something within an "anonymous" task, that is, a task the
     /// DepNode of which is determined by the list of inputs it read from.
-    pub fn with_anon_task<OP,R>(&self, dep_kind: DepKind, op: OP) -> (R, DepNode)
+    pub fn with_anon_task<OP,R>(&self, dep_kind: DepKind, op: OP) -> (R, DepNodeIndex)
         where OP: FnOnce() -> R
     {
         if let Some(ref data) = self.data {
@@ -126,7 +137,7 @@ impl DepGraph {
             let dep_node = data.edges.borrow_mut().pop_anon_task(dep_kind);
             (result, dep_node)
         } else {
-            (op(), DepNode::new_no_params(DepKind::Krate))
+            (op(), DepNodeIndex::INVALID)
         }
     }
 
@@ -137,6 +148,13 @@ impl DepGraph {
         }
     }
 
+    #[inline]
+    pub fn read_index(&self, v: DepNodeIndex) {
+        if let Some(ref data) = self.data {
+            data.edges.borrow_mut().read_index(v);
+        }
+    }
+
     /// Only to be used during graph loading
     #[inline]
     pub fn add_edge_directly(&self, source: DepNode, target: DepNode) {
diff --git a/src/librustc/dep_graph/mod.rs b/src/librustc/dep_graph/mod.rs
@@ -22,6 +22,7 @@ pub use self::dep_node::DepNode;
 pub use self::dep_node::WorkProductId;
 pub use self::graph::DepGraph;
 pub use self::graph::WorkProduct;
+pub use self::edges::DepNodeIndex;
 pub use self::query::DepGraphQuery;
 pub use self::safe::AssertDepGraphSafe;
 pub use self::safe::DepGraphSafe;
diff --git a/src/librustc/ty/maps.rs b/src/librustc/ty/maps.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use dep_graph::{DepConstructor, DepNode};
+use dep_graph::{DepConstructor, DepNode, DepNodeIndex};
 use hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId, LOCAL_CRATE};
 use hir::def::Def;
 use hir;
@@ -186,7 +186,7 @@ impl<'tcx> Value<'tcx> for ty::SymbolName {
 
 struct QueryMap<D: QueryDescription> {
     phantom: PhantomData<D>,
-    map: FxHashMap<D::Key, D::Value>,
+    map: FxHashMap<D::Key, (D::Value, DepNodeIndex)>,
 }
 
 impl<M: QueryDescription> QueryMap<M> {
@@ -580,7 +580,8 @@ macro_rules! define_maps {
                        key,
                        span);
 
-                if let Some(result) = tcx.maps.$name.borrow().map.get(&key) {
+                if let Some(&(ref result, dep_node_index)) = tcx.maps.$name.borrow().map.get(&key) {
+                    tcx.dep_graph.read_index(dep_node_index);
                     return Ok(f(result));
                 }
 
@@ -591,26 +592,46 @@ macro_rules! define_maps {
                     span = key.default_span(tcx)
                 }
 
-                let _task = tcx.dep_graph.in_task(Self::to_dep_node(tcx, &key));
-
-                let result = tcx.cycle_check(span, Query::$name(key), || {
-                    let provider = tcx.maps.providers[key.map_crate()].$name;
-                    provider(tcx.global_tcx(), key)
+                let (result, dep_node_index) = tcx.cycle_check(span, Query::$name(key), || {
+                    let dep_node = Self::to_dep_node(tcx, &key);
+
+                    if dep_node.kind.is_anon() {
+                        tcx.dep_graph.with_anon_task(dep_node.kind, || {
+                            let provider = tcx.maps.providers[key.map_crate()].$name;
+                            provider(tcx.global_tcx(), key)
+                        })
+                    } else {
+                        fn run_provider<'a, 'tcx, 'lcx>(tcx: TyCtxt<'a, 'tcx, 'lcx>,
+                                                        key: $K)
+                                                        -> $V {
+                            let provider = tcx.maps.providers[key.map_crate()].$name;
+                            provider(tcx.global_tcx(), key)
+                        }
+
+                        tcx.dep_graph.with_task(dep_node, tcx, key, run_provider)
+                    }
                 })?;
 
-                Ok(f(tcx.maps.$name.borrow_mut().map.entry(key).or_insert(result)))
+                tcx.dep_graph.read_index(dep_node_index);
+
+                Ok(f(&tcx.maps
+                         .$name
+                         .borrow_mut()
+                         .map
+                         .entry(key)
+                         .or_insert((result, dep_node_index))
+                         .0))
             }
 
             pub fn try_get(tcx: TyCtxt<'a, $tcx, 'lcx>, span: Span, key: $K)
                            -> Result<$V, CycleError<'a, $tcx>> {
-                // We register the `read` here, but not in `force`, since
-                // `force` does not give access to the value produced (and thus
-                // we actually don't read it).
-                tcx.dep_graph.read(Self::to_dep_node(tcx, &key));
                 Self::try_get_with(tcx, span, key, Clone::clone)
             }
 
             pub fn force(tcx: TyCtxt<'a, $tcx, 'lcx>, span: Span, key: $K) {
+                // Ignore dependencies, since we not reading the computed value
+                let _task = tcx.dep_graph.in_ignore();
+
                 match Self::try_get_with(tcx, span, key, |_| ()) {
                     Ok(()) => {}
                     Err(e) => tcx.report_cycle(e)
diff --git a/src/librustc_trans/base.rs b/src/librustc_trans/base.rs
@@ -1120,7 +1120,7 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         .into_iter()
         .map(|cgu| {
             let dep_node = cgu.work_product_dep_node();
-            let (stats, module) =
+            let ((stats, module), _) =
                 tcx.dep_graph.with_task(dep_node,
                                         AssertDepGraphSafe(&shared_ccx),
                                         AssertDepGraphSafe(cgu),

Original file line number	Diff line number	Diff line change
`@@ -19,21 +19,24 @@ use super::debug::EdgeFilter;`
`19`	`19`
`20`	`20`	`pub struct DepGraphEdges {`
`21`	`21`	`nodes: Vec<DepNode>,`
`22`		`- indices: FxHashMap<DepNode, IdIndex>,`
`23`		`- edges: FxHashSet<(IdIndex, IdIndex)>,`
	`22`	`+ indices: FxHashMap<DepNode, DepNodeIndex>,`
	`23`	`+ edges: FxHashSet<(DepNodeIndex, DepNodeIndex)>,`
`24`	`24`	`task_stack: Vec<OpenTask>,`
`25`	`25`	`forbidden_edge: Option<EdgeFilter>,`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]`
`29`		`-struct IdIndex {`
	`29`	`+pub struct DepNodeIndex {`
`30`	`30`	`index: u32`
`31`	`31`	`}`
`32`	`32`
`33`		`-impl IdIndex {`
`34`		`- fn new(v: usize) -> IdIndex {`
	`33`	`+impl DepNodeIndex {`
	`34`	`+`
	`35`	`+ pub const INVALID: DepNodeIndex = DepNodeIndex { index: ::std::u32::MAX };`
	`36`	`+`
	`37`	`+ fn new(v: usize) -> DepNodeIndex {`
`35`	`38`	`assert!((v & 0xFFFF_FFFF) == v);`
`36`		`- IdIndex { index: v as u32 }`
	`39`	`+ DepNodeIndex { index: v as u32 }`
`37`	`40`	`}`
`38`	`41`
`39`	`42`	`fn index(self) -> usize {`
`@@ -80,7 +83,7 @@ impl DepGraphEdges {`
`80`	`83`	`}`
`81`	`84`	`}`
`82`	`85`
`83`		`- fn id(&self, index: IdIndex) -> DepNode {`
	`86`	`+ fn id(&self, index: DepNodeIndex) -> DepNode {`
`84`	`87`	`self.nodes[index.index()]`
`85`	`88`	`}`
`86`	`89`
`@@ -101,7 +104,7 @@ impl DepGraphEdges {`
`101`	`104`	`});`
`102`	`105`	`}`
`103`	`106`
`104`		`- pub fn pop_task(&mut self, key: DepNode) {`
	`107`	`+ pub fn pop_task(&mut self, key: DepNode) -> DepNodeIndex {`
`105`	`108`	`let popped_node = self.task_stack.pop().unwrap();`
`106`	`109`
`107`	`110`	`if let OpenTask::Regular {`
`@@ -117,6 +120,8 @@ impl DepGraphEdges {`
`117`	`120`	`let source_id = self.get_or_create_node(read);`
`118`	`121`	`self.edges.insert((source_id, target_id));`
`119`	`122`	`}`
	`123`	`+`
	`124`	`+ target_id`
`120`	`125`	`} else {`
`121`	`126`	`bug!("pop_task() - Expected regular task to be popped")`
`122`	`127`	`}`
`@@ -129,7 +134,7 @@ impl DepGraphEdges {`
`129`	`134`	`});`
`130`	`135`	`}`
`131`	`136`
`132`		`- pub fn pop_anon_task(&mut self, kind: DepKind) -> DepNode {`
	`137`	`+ pub fn pop_anon_task(&mut self, kind: DepKind) -> DepNodeIndex {`
`133`	`138`	`let popped_node = self.task_stack.pop().unwrap();`
`134`	`139`
`135`	`140`	`if let OpenTask::Anon {`
`@@ -155,8 +160,8 @@ impl DepGraphEdges {`
`155`	`160`	`hash: fingerprint,`
`156`	`161`	`};`
`157`	`162`
`158`		`- if self.indices.contains_key(&target_dep_node) {`
`159`		`- return target_dep_node;`
	`163`	`+ if let Some(&index) = self.indices.get(&target_dep_node) {`
	`164`	`+ return index;`
`160`	`165`	`}`
`161`	`166`
`162`	`167`	`let target_id = self.get_or_create_node(target_dep_node);`
`@@ -166,7 +171,7 @@ impl DepGraphEdges {`
`166`	`171`	`self.edges.insert((source_id, target_id));`
`167`	`172`	`}`
`168`	`173`
`169`		`- target_dep_node`
	`174`	`+ target_id`
`170`	`175`	`} else {`
`171`	`176`	`bug!("pop_anon_task() - Expected anonymous task to be popped")`
`172`	`177`	`}`
`@@ -210,6 +215,11 @@ impl DepGraphEdges {`
`210`	`215`	`}`
`211`	`216`	`}`
`212`	`217`
	`218`	`+ pub fn read_index(&mut self, source: DepNodeIndex) {`
	`219`	`+ let dep_node = self.nodes[source.index()];`
	`220`	`+ self.read(dep_node);`
	`221`	`+ }`
	`222`	`+`
`213`	`223`	`pub fn query(&self) -> DepGraphQuery {`
`214`	`224`	`let edges: Vec<_> = self.edges.iter()`
`215`	`225`	`.map(\|&(i, j)\| (self.id(i), self.id(j)))`
`@@ -229,7 +239,7 @@ impl DepGraphEdges {`
`229`	`239`	`}`
`230`	`240`
`231`	`241`	`#[inline]`
`232`		`- fn get_or_create_node(&mut self, dep_node: DepNode) -> IdIndex {`
	`242`	`+ fn get_or_create_node(&mut self, dep_node: DepNode) -> DepNodeIndex {`
`233`	`243`	`let DepGraphEdges {`
`234`	`244`	`ref mut indices,`
`235`	`245`	`ref mut nodes,`
`@@ -239,7 +249,7 @@ impl DepGraphEdges {`
`239`	`249`	`*indices.entry(dep_node).or_insert_with(\|\| {`
`240`	`250`	`let next_id = nodes.len();`
`241`	`251`	`nodes.push(dep_node);`
`242`		`- IdIndex::new(next_id)`
	`252`	`+ DepNodeIndex::new(next_id)`
`243`	`253`	`})`
`244`	`254`	`}`
`245`	`255`	`}`