Store dep node result fingerprints in a separate file

Author: Zoxc

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};
 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

@@ -2,41 +2,35 @@ use crate::ich::Fingerprint;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::indexed_vec::IndexVec;
 use super::dep_node::DepNode;
-use super::graph::DepNodeState;
-use super::serialized::{SerializedDepGraph, SerializedDepNodeIndex};
+use super::graph::DepNodeIndex;
+use super::serialized::SerializedDepGraph;
 
-#[derive(Debug, /*RustcEncodable, RustcDecodable,*/ Default)]
+#[derive(Debug, Default)]
 pub struct PreviousDepGraph {
     /// Maps from dep nodes to their previous index, if any.
-    index: FxHashMap<DepNode, SerializedDepNodeIndex>,
+    index: FxHashMap<DepNode, DepNodeIndex>,
     /// The set of all DepNodes in the graph
-    nodes: IndexVec<SerializedDepNodeIndex, DepNode>,
+    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.
-    fingerprints: IndexVec<SerializedDepNodeIndex, Fingerprint>,
+    pub(super) 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.
-    edge_list_indices: IndexVec<SerializedDepNodeIndex, (u32, u32)>,
+    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.
-    edge_list_data: Vec<SerializedDepNodeIndex>,
-    /// A set of nodes which are no longer valid.
-    pub(super) state: IndexVec<SerializedDepNodeIndex, DepNodeState>,
+    edge_list_data: Vec<DepNodeIndex>,
 }
 
 impl PreviousDepGraph {
     pub fn new(graph: SerializedDepGraph) -> PreviousDepGraph {
         let index: FxHashMap<_, _> = graph.nodes
             .iter_enumerated()
-            .map(|(idx, dep_node)| {
-                (dep_node.node, SerializedDepNodeIndex::from_u32(idx.as_u32()))
-            })
+            .map(|(idx, dep_node)| (dep_node.node, idx))
             .collect();
 
-        let fingerprints: IndexVec<SerializedDepNodeIndex, _> =
-            graph.nodes.iter().map(|d| d.fingerprint).collect();
-        let nodes: IndexVec<SerializedDepNodeIndex, _> =
+        let nodes: IndexVec<DepNodeIndex, _> =
             graph.nodes.iter().map(|d| d.node).collect();
 
         let total_edge_count: usize = graph.nodes.iter().map(|d| d.edges.len()).sum();
@@ -47,9 +41,7 @@ impl PreviousDepGraph {
         for (current_dep_node_index, edges) in graph.nodes.iter_enumerated()
                                                                 .map(|(i, d)| (i, &d.edges)) {
             let start = edge_list_data.len() as u32;
-            edge_list_data.extend(edges.iter().map(|i| {
-                SerializedDepNodeIndex::from_u32(i.as_u32())
-            }));
+            edge_list_data.extend(edges.iter().cloned());
             let end = edge_list_data.len() as u32;
 
             debug_assert_eq!(current_dep_node_index.index(), edge_list_indices.len());
@@ -60,36 +52,35 @@ impl PreviousDepGraph {
         debug_assert_eq!(edge_list_data.len(), total_edge_count);
 
         PreviousDepGraph {
-            fingerprints,
+            fingerprints: graph.fingerprints,
             nodes,
             edge_list_indices,
             edge_list_data,
             index,
-            state: graph.state.convert_index_type(),
         }
     }
 
     #[inline]
     pub fn edge_targets_from(
         &self,
-        dep_node_index: SerializedDepNodeIndex
-    ) -> &[SerializedDepNodeIndex] {
+        dep_node_index: DepNodeIndex
+    ) -> &[DepNodeIndex] {
         let targets = self.edge_list_indices[dep_node_index];
         &self.edge_list_data[targets.0 as usize..targets.1 as usize]
     }
 
     #[inline]
-    pub fn index_to_node(&self, dep_node_index: SerializedDepNodeIndex) -> DepNode {
+    pub fn index_to_node(&self, dep_node_index: DepNodeIndex) -> DepNode {
         self.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()
     }
 
@@ -102,7 +93,7 @@ impl PreviousDepGraph {
 
     #[inline]
     pub fn fingerprint_by_index(&self,
-                                dep_node_index: SerializedDepNodeIndex)
+                                dep_node_index: DepNodeIndex)
                                 -> Fingerprint {
         self.fingerprints[dep_node_index]
     }

src/librustc/dep_graph/prev.rs

@@ -1,66 +1,86 @@
 use rustc_data_structures::sync::worker::{Worker, WorkerExecutor};
-use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::sync::{Lrc, AtomicCell};
 use rustc_data_structures::{unlikely, cold_path};
-use rustc_data_structures::indexed_vec::{IndexVec, Idx};
-use rustc_serialize::opaque;
-use rustc_serialize::{Decodable, Encodable};
+use rustc_data_structures::indexed_vec::{Idx, IndexVec};
+use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_serialize::{Decodable, Encodable, opaque};
 use std::mem;
 use std::fs::File;
 use std::io::Write;
+use crate::dep_graph::dep_node::DepNode;
+use super::prev::PreviousDepGraph;
 use super::graph::{DepNodeData, DepNodeIndex, DepNodeState};
 
-newtype_index! {
-    pub struct SerializedDepNodeIndex { .. }
-}
-
-impl SerializedDepNodeIndex {
-    pub fn current(self) -> DepNodeIndex {
-        DepNodeIndex::from_u32(self.as_u32())
-    }
-}
-
 #[derive(Debug, Default)]
 pub struct SerializedDepGraph {
-    pub(super) nodes: IndexVec<DepNodeIndex, DepNodeData>,
-    pub(super) state: IndexVec<DepNodeIndex, DepNodeState>,
+    pub(super) nodes: IndexVec<DepNodeIndex, SerializedDepNodeData>,
+    pub(super) fingerprints: IndexVec<DepNodeIndex, Fingerprint>,
+}
+
+#[derive(Clone, Debug, RustcDecodable, RustcEncodable)]
+pub(super) struct SerializedDepNodeData {
+    pub(super) node: DepNode,
+    pub(super) edges: Vec<DepNodeIndex>,
 }
 
 impl SerializedDepGraph {
-    pub fn decode(d: &mut opaque::Decoder<'_>) -> Result<Self, String> {
-        let mut nodes = IndexVec::new();
-        let mut invalidated_list = Vec::new();
+    pub fn decode(
+        d: &mut opaque::Decoder<'_>,
+        results_d: &mut opaque::Decoder<'_>,
+    ) -> Result<(Self, IndexVec<DepNodeIndex, AtomicCell<DepNodeState>>), String> {
+        let fingerprints: IndexVec<DepNodeIndex, Fingerprint> = IndexVec::decode(results_d)?;
+        let mut nodes = IndexVec::with_capacity(fingerprints.len());
+        let mut state: IndexVec<_, _> = (0..fingerprints.len()).map(|_| {
+            AtomicCell::new(DepNodeState::Unknown)
+        }).collect();
         loop {
             if d.position() == d.data.len() {
                 break;
             }
-            match Action::decode(d)? {
-                Action::NewNodes(new_nodes) => {
+            match SerializedAction::decode(d)? {
+                SerializedAction::NewNodes(new_nodes) => {
+                    for (i, data) in new_nodes.iter().enumerate() {
+                        // Mark the result of eval_always nodes as invalid so they will
+                        // get executed again.
+                        if unlikely!(data.node.kind.is_eval_always()) {
+                            let idx = DepNodeIndex::new(nodes.len() + i);
+                            state[idx] = AtomicCell::new(DepNodeState::Invalid);
+                        }
+                    }
                     nodes.extend(new_nodes);
                 }
-                Action::UpdateNodes(changed) => {
-                    for (i, data) in changed {
-                        nodes[i] = data;
+                SerializedAction::UpdateEdges(changed) => {
+                    for (i, edges) in changed {
+                        // Updated results are valid again, except for eval_always nodes
+                        // which always start out invalid.
+                        if likely!(!nodes[i].node.kind.is_eval_always()) {
+                            state[i] = AtomicCell::new(DepNodeState::Unknown);
+                        }
+                        nodes[i].edges = edges;
                     }
                 }
-                Action::InvalidateNodes(nodes) => {
-                    invalidated_list.extend(nodes);
+                SerializedAction::InvalidateNodes(nodes) => {
+                    for i in nodes {
+                        state[i] = AtomicCell::new(DepNodeState::Invalid);
+                    }
                 }
             }
         }
-        let mut state: IndexVec<_, _> = (0..nodes.len()).map(|_| {
-            DepNodeState::Unknown
-        }).collect();
-        for i in invalidated_list {
-            state[i] = DepNodeState::Invalidated;
-        }
-        Ok(SerializedDepGraph {
+        Ok((SerializedDepGraph {
             nodes,
-            state,
-        })
+            fingerprints,
+        }, state))
     }
 }
 
-#[derive(Debug, RustcEncodable, RustcDecodable)]
+#[derive(Debug, RustcDecodable, RustcEncodable)]
+enum SerializedAction {
+    NewNodes(Vec<SerializedDepNodeData>),
+    UpdateEdges(Vec<(DepNodeIndex, Vec<DepNodeIndex>)>),
+    InvalidateNodes(Vec<DepNodeIndex>)
+}
+
+#[derive(Debug)]
 enum Action {
     NewNodes(Vec<DepNodeData>),
     UpdateNodes(Vec<(DepNodeIndex, DepNodeData)>),
@@ -73,36 +93,66 @@ enum Action {
 }
 
 struct SerializerWorker {
+    fingerprints: IndexVec<DepNodeIndex, Fingerprint>,
+    previous: Lrc<PreviousDepGraph>,
     file: File,
 }
 
 impl Worker for SerializerWorker {
     type Message = (usize, Action);
-    type Result = ();
+    type Result = IndexVec<DepNodeIndex, Fingerprint>;
 
     fn message(&mut self, (buffer_size_est, action): (usize, Action)) {
         let mut encoder = opaque::Encoder::new(Vec::with_capacity(buffer_size_est * 5));
+        let action = match action {
+            Action::UpdateNodes(nodes) => {
+                SerializedAction::UpdateEdges(nodes.into_iter().filter(|&(i, ref data)| {
+                    self.fingerprints[i] = data.fingerprint;
+                    // Only emit nodes which actually changed
+                    &*data.edges != self.previous.edge_targets_from(i)
+                }).map(|(i, data)| (i, data.edges.into_iter().collect::<Vec<_>>())).collect())
+            }
+            Action::NewNodes(nodes) => {
+                SerializedAction::NewNodes(nodes.into_iter().map(|data| {
+                    self.fingerprints.push(data.fingerprint);
+                    SerializedDepNodeData {
+                        node: data.node,
+                        edges: data.edges.into_iter().collect(),
+                    }
+                }).collect())
+            }
+            Action::InvalidateNodes(nodes) => SerializedAction::InvalidateNodes(nodes),
+        };
         action.encode(&mut encoder).ok();
         self.file.write_all(&encoder.into_inner()).expect("unable to write to temp dep graph");
     }
 
-    fn complete(self) {}
+    fn complete(self) -> IndexVec<DepNodeIndex, Fingerprint> {
+        self.fingerprints
+    }
 }
 
 const BUFFER_SIZE: usize = 800000;
 
 pub struct Serializer {
     worker: Lrc<WorkerExecutor<SerializerWorker>>,
+    node_count: u32,
     new_buffer: Vec<DepNodeData>,
     new_buffer_size: usize,
     updated_buffer: Vec<(DepNodeIndex, DepNodeData)>,
     updated_buffer_size: usize,
 }
 
 impl Serializer {
-    pub fn new(file: File) -> Self {
+    pub fn new(
+        file: File,
+        previous: Lrc<PreviousDepGraph>,
+    ) -> Self {
         Serializer {
+            node_count: previous.node_count() as u32,
             worker: Lrc::new(WorkerExecutor::new(SerializerWorker {
+                fingerprints: previous.fingerprints.clone(),
+                previous,
                 file,
             })),
             new_buffer: Vec::with_capacity(BUFFER_SIZE),
@@ -120,7 +170,7 @@ impl Serializer {
     }
 
     #[inline]
-    pub(super) fn serialize_new(&mut self, data: DepNodeData) {
+    pub(super) fn serialize_new(&mut self, data: DepNodeData) -> DepNodeIndex {
         let edges = data.edges.len();
         self.new_buffer.push(data);
         self.new_buffer_size += 8 + edges;
@@ -129,6 +179,9 @@ impl Serializer {
                 self.flush_new();
             })
         }
+        let index = self.node_count;
+        self.node_count += 1;
+        DepNodeIndex::from_u32(index)
     }
 
     fn flush_updated(&mut self) {
@@ -153,7 +206,7 @@ impl Serializer {
     pub fn complete(
         &mut self,
         invalidate: Vec<DepNodeIndex>,
-    ) {
+    ) -> IndexVec<DepNodeIndex, Fingerprint> {
         if self.new_buffer.len() > 0 {
             self.flush_new();
         }

src/librustc/dep_graph/serialized.rs

@@ -2,7 +2,7 @@ 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::dep_graph::DepNodeIndex;
 use crate::hir::def_id::{CrateNum, DefId, DefIndex};
 use crate::mir::interpret::GlobalId;
 use crate::traits;

src/librustc/query/mod.rs

@@ -1,4 +1,4 @@
-use crate::dep_graph::SerializedDepNodeIndex;
+use crate::dep_graph::DepNodeIndex;
 use crate::dep_graph::DepNode;
 use crate::hir::def_id::{CrateNum, DefId};
 use crate::ty::TyCtxt;
@@ -53,7 +53,7 @@ pub(crate) trait QueryDescription<'tcx>: QueryAccessors<'tcx> {
     }
 
     fn try_load_from_disk(_: TyCtxt<'_, 'tcx, 'tcx>,
-                          _: SerializedDepNodeIndex)
+                          _: DepNodeIndex)
                           -> Option<Self::Value> {
         bug!("QueryDescription::load_from_disk() called for an unsupported query.")
     }
@@ -86,7 +86,7 @@ macro_rules! impl_disk_cacheable_query(
 
             #[inline]
             fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
-                                      id: SerializedDepNodeIndex)
+                                      id: DepNodeIndex)
                                       -> Option<Self::Value> {
                 tcx.queries.on_disk_cache.try_load_query_result(tcx, id)
             }