Serialize dep nodes in the background

Author: Zoxc

src/librustc/dep_graph/graph.rs

@@ -5,6 +5,7 @@ use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use smallvec::SmallVec;
 use rustc_data_structures::sync::{Lrc, Lock, AtomicU32, Ordering};
 use std::env;
+use std::fs::File;
 use std::hash::Hash;
 use std::collections::hash_map::Entry;
 use crate::ty::{self, TyCtxt};
@@ -17,7 +18,7 @@ use super::debug::EdgeFilter;
 use super::dep_node::{DepNode, DepKind, WorkProductId};
 use super::query::DepGraphQuery;
 use super::safe::DepGraphSafe;
-use super::serialized::{SerializedDepGraph, SerializedDepNodeIndex};
+use super::serialized::{SerializedDepNodeIndex, Serializer};
 use super::prev::PreviousDepGraph;
 
 #[derive(Clone)]
@@ -30,7 +31,7 @@ newtype_index! {
 }
 
 impl DepNodeIndex {
-    const INVALID: DepNodeIndex = DepNodeIndex::MAX;
+    pub(super) const INVALID: DepNodeIndex = DepNodeIndex::MAX;
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
@@ -76,7 +77,7 @@ struct DepGraphData {
     dep_node_debug: Lock<FxHashMap<DepNode, String>>,
 
     // Used for testing, only populated when -Zquery-dep-graph is specified.
-    loaded_from_cache: Lock<FxHashMap<DepNodeIndex, bool>>,
+    loaded_from_cache: Lock<FxHashMap<DepNode, bool>>,
 }
 
 pub fn hash_result<R>(hcx: &mut StableHashingContext<'_>, result: &R) -> Option<Fingerprint>
@@ -90,15 +91,18 @@ where
 }
 
 impl DepGraph {
-    pub fn new(prev_graph: PreviousDepGraph,
-               prev_work_products: FxHashMap<WorkProductId, WorkProduct>) -> DepGraph {
+    pub fn new(
+        prev_graph: PreviousDepGraph,
+        prev_work_products: FxHashMap<WorkProductId, WorkProduct>,
+        file: File,
+    ) -> DepGraph {
         let prev_graph_node_count = prev_graph.node_count();
 
         DepGraph {
             data: Some(Lrc::new(DepGraphData {
                 previous_work_products: prev_work_products,
                 dep_node_debug: Default::default(),
-                current: Lock::new(CurrentDepGraph::new(prev_graph_node_count)),
+                current: Lock::new(CurrentDepGraph::new(prev_graph_node_count, file)),
                 emitted_diagnostics: Default::default(),
                 emitted_diagnostics_cond_var: Condvar::new(),
                 previous: prev_graph,
@@ -121,6 +125,8 @@ impl DepGraph {
     }
 
     pub fn query(&self) -> DepGraphQuery {
+        // FIXME
+        panic!()/*
         let current_dep_graph = self.data.as_ref().unwrap().current.borrow();
         let nodes: Vec<_> = current_dep_graph.data.iter().map(|n| n.node).collect();
         let mut edges = Vec::new();
@@ -132,7 +138,7 @@ impl DepGraph {
             }
         }
 
-        DepGraphQuery::new(&nodes[..], &edges[..])
+        DepGraphQuery::new(&nodes[..], &edges[..])*/
     }
 
     pub fn assert_ignored(&self)
@@ -435,9 +441,10 @@ impl DepGraph {
     }
 
     #[inline]
-    pub fn fingerprint_of(&self, dep_node_index: DepNodeIndex) -> Fingerprint {
+    pub fn fingerprint_of(&self, _dep_node_index: DepNodeIndex) -> Fingerprint {
+        panic!()/*
         let current = self.data.as_ref().expect("dep graph enabled").current.borrow_mut();
-        current.data[dep_node_index].fingerprint
+        current.data[dep_node_index].fingerprint*/
     }
 
     pub fn prev_fingerprint_of(&self, dep_node: &DepNode) -> Option<Fingerprint> {
@@ -500,41 +507,9 @@ impl DepGraph {
         }
     }
 
-    pub fn serialize(&self) -> SerializedDepGraph {
-        let current_dep_graph = self.data.as_ref().unwrap().current.borrow();
-
-        let fingerprints: IndexVec<SerializedDepNodeIndex, _> =
-            current_dep_graph.data.iter().map(|d| d.fingerprint).collect();
-        let nodes: IndexVec<SerializedDepNodeIndex, _> =
-            current_dep_graph.data.iter().map(|d| d.node).collect();
-
-        let total_edge_count: usize = current_dep_graph.data.iter()
-                                                            .map(|d| d.edges.len())
-                                                            .sum();
-
-        let mut edge_list_indices = IndexVec::with_capacity(nodes.len());
-        let mut edge_list_data = Vec::with_capacity(total_edge_count);
-
-        for (current_dep_node_index, edges) in current_dep_graph.data.iter_enumerated()
-                                                                .map(|(i, d)| (i, &d.edges)) {
-            let start = edge_list_data.len() as u32;
-            // This should really just be a memcpy :/
-            edge_list_data.extend(edges.iter().map(|i| SerializedDepNodeIndex::new(i.index())));
-            let end = edge_list_data.len() as u32;
-
-            debug_assert_eq!(current_dep_node_index.index(), edge_list_indices.len());
-            edge_list_indices.push((start, end));
-        }
-
-        debug_assert!(edge_list_data.len() <= ::std::u32::MAX as usize);
-        debug_assert_eq!(edge_list_data.len(), total_edge_count);
-
-        SerializedDepGraph {
-            nodes,
-            fingerprints,
-            edge_list_indices,
-            edge_list_data,
-        }
+    pub fn serialize(&self) {
+        // FIXME: Can this deadlock?
+        self.data.as_ref().unwrap().current.lock().serializer.complete()
     }
 
     pub fn node_color(&self, dep_node: &DepNode) -> Option<DepNodeColor> {
@@ -870,23 +845,20 @@ impl DepGraph {
         }
     }
 
-    pub fn mark_loaded_from_cache(&self, dep_node_index: DepNodeIndex, state: bool) {
-        debug!("mark_loaded_from_cache({:?}, {})",
-               self.data.as_ref().unwrap().current.borrow().data[dep_node_index].node,
-               state);
+    pub fn mark_loaded_from_cache(&self, dep_node: DepNode, state: bool) {
+        debug!("mark_loaded_from_cache({:?}, {})", dep_node, state);
 
         self.data
             .as_ref()
             .unwrap()
             .loaded_from_cache
             .borrow_mut()
-            .insert(dep_node_index, state);
+            .insert(dep_node, state);
     }
 
     pub fn was_loaded_from_cache(&self, dep_node: &DepNode) -> Option<bool> {
         let data = self.data.as_ref().unwrap();
-        let dep_node_index = data.current.borrow().node_to_node_index[dep_node];
-        data.loaded_from_cache.borrow().get(&dep_node_index).cloned()
+        data.loaded_from_cache.borrow().get(&dep_node).cloned()
     }
 }
 
@@ -935,15 +907,15 @@ pub enum WorkProductFileKind {
     BytecodeCompressed,
 }
 
-#[derive(Clone)]
-struct DepNodeData {
-    node: DepNode,
-    edges: SmallVec<[DepNodeIndex; 8]>,
-    fingerprint: Fingerprint,
+#[derive(Clone, Debug)]
+pub(super) struct DepNodeData {
+    pub(super) node: DepNode,
+    pub(super) edges: SmallVec<[DepNodeIndex; 8]>,
+    pub(super) fingerprint: Fingerprint,
 }
 
 pub(super) struct CurrentDepGraph {
-    data: IndexVec<DepNodeIndex, DepNodeData>,
+    nodes: usize,
     node_to_node_index: FxHashMap<DepNode, DepNodeIndex>,
     #[allow(dead_code)]
     forbidden_edge: Option<EdgeFilter>,
@@ -963,10 +935,13 @@ pub(super) struct CurrentDepGraph {
 
     total_read_count: u64,
     total_duplicate_read_count: u64,
+
+    /// Produces the serialized dep graph for the next session,
+    serializer: Serializer,
 }
 
 impl CurrentDepGraph {
-    fn new(prev_graph_node_count: usize) -> CurrentDepGraph {
+    fn new(prev_graph_node_count: usize, file: File) -> CurrentDepGraph {
         use std::time::{SystemTime, UNIX_EPOCH};
 
         let duration = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
@@ -996,7 +971,7 @@ impl CurrentDepGraph {
         let new_node_count_estimate = (prev_graph_node_count * 102) / 100 + 200;
 
         CurrentDepGraph {
-            data: IndexVec::with_capacity(new_node_count_estimate),
+            nodes: 0,
             node_to_node_index: FxHashMap::with_capacity_and_hasher(
                 new_node_count_estimate,
                 Default::default(),
@@ -1005,6 +980,7 @@ impl CurrentDepGraph {
             forbidden_edge,
             total_read_count: 0,
             total_duplicate_read_count: 0,
+            serializer: Serializer::new(file),
         }
     }
 
@@ -1057,13 +1033,14 @@ impl CurrentDepGraph {
         edges: SmallVec<[DepNodeIndex; 8]>,
         fingerprint: Fingerprint
     ) -> (DepNodeIndex, bool) {
-        debug_assert_eq!(self.node_to_node_index.len(), self.data.len());
+        debug_assert_eq!(self.node_to_node_index.len(), self.nodes);
 
         match self.node_to_node_index.entry(dep_node) {
             Entry::Occupied(entry) => (*entry.get(), false),
             Entry::Vacant(entry) => {
-                let dep_node_index = DepNodeIndex::new(self.data.len());
-                self.data.push(DepNodeData {
+                let dep_node_index = DepNodeIndex::new(self.nodes);
+                self.nodes += 1;
+                self.serializer.serialize(DepNodeData {
                     node: dep_node,
                     edges,
                     fingerprint
@@ -1087,7 +1064,7 @@ impl DepGraphData {
                 if task_deps.read_set.insert(source) {
                     task_deps.reads.push(source);
 
-                    #[cfg(debug_assertions)]
+                    /*#[cfg(debug_assertions)]
                     {
                         if let Some(target) = task_deps.node {
                             let graph = self.current.lock();
@@ -1100,7 +1077,7 @@ impl DepGraphData {
                                 }
                             }
                         }
-                    }
+                    }*/
                 } else if cfg!(debug_assertions) {
                     self.current.lock().total_duplicate_read_count += 1;
                 }
@@ -1111,6 +1088,7 @@ impl DepGraphData {
 
 pub struct TaskDeps {
     #[cfg(debug_assertions)]
+    #[allow(dead_code)]
     node: Option<DepNode>,
     reads: SmallVec<[DepNodeIndex; 8]>,
     read_set: FxHashSet<DepNodeIndex>,

src/librustc/dep_graph/prev.rs

@@ -1,34 +1,78 @@
 use crate::ich::Fingerprint;
 use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::indexed_vec::IndexVec;
 use super::dep_node::DepNode;
 use super::serialized::{SerializedDepGraph, SerializedDepNodeIndex};
 
 #[derive(Debug, RustcEncodable, RustcDecodable, Default)]
 pub struct PreviousDepGraph {
-    data: SerializedDepGraph,
+    /// Maps from dep nodes to their previous index, if any.
     index: FxHashMap<DepNode, SerializedDepNodeIndex>,
+    /// The set of all DepNodes in the graph
+    nodes: IndexVec<SerializedDepNodeIndex, 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>,
+    /// 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)>,
+    /// A flattened list of all edge targets in the graph. Edge sources are
+    /// implicit in edge_list_indices.
+    edge_list_data: Vec<SerializedDepNodeIndex>,
 }
 
 impl PreviousDepGraph {
-    pub fn new(data: SerializedDepGraph) -> PreviousDepGraph {
-        let index: FxHashMap<_, _> = data.nodes
+    pub fn new(graph: SerializedDepGraph) -> PreviousDepGraph {
+        let index: FxHashMap<_, _> = graph.nodes
             .iter_enumerated()
-            .map(|(idx, &dep_node)| (dep_node, idx))
+            .map(|(idx, dep_node)| (dep_node.node, idx))
             .collect();
-        PreviousDepGraph { data, index }
+
+        let fingerprints: IndexVec<SerializedDepNodeIndex, _> =
+            graph.nodes.iter().map(|d| d.fingerprint).collect();
+        let nodes: IndexVec<SerializedDepNodeIndex, _> =
+            graph.nodes.iter().map(|d| d.node).collect();
+
+        let total_edge_count: usize = graph.nodes.iter().map(|d| d.deps.len()).sum();
+
+        let mut edge_list_indices = IndexVec::with_capacity(nodes.len());
+        let mut edge_list_data = Vec::with_capacity(total_edge_count);
+
+        for (current_dep_node_index, edges) in graph.nodes.iter_enumerated()
+                                                                .map(|(i, d)| (i, &d.deps)) {
+            let start = edge_list_data.len() 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());
+            edge_list_indices.push((start, end));
+        }
+
+        debug_assert!(edge_list_data.len() <= ::std::u32::MAX as usize);
+        debug_assert_eq!(edge_list_data.len(), total_edge_count);
+
+        PreviousDepGraph {
+            fingerprints,
+            nodes,
+            edge_list_indices,
+            edge_list_data,
+            index,
+        }
     }
 
     #[inline]
     pub fn edge_targets_from(
         &self,
         dep_node_index: SerializedDepNodeIndex
     ) -> &[SerializedDepNodeIndex] {
-        self.data.edge_targets_from(dep_node_index)
+        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 {
-        self.data.nodes[dep_node_index]
+        self.nodes[dep_node_index]
     }
 
     #[inline]
@@ -45,14 +89,14 @@ impl PreviousDepGraph {
     pub fn fingerprint_of(&self, dep_node: &DepNode) -> Option<Fingerprint> {
         self.index
             .get(dep_node)
-            .map(|&node_index| self.data.fingerprints[node_index])
+            .map(|&node_index| self.fingerprints[node_index])
     }
 
     #[inline]
     pub fn fingerprint_by_index(&self,
                                 dep_node_index: SerializedDepNodeIndex)
                                 -> Fingerprint {
-        self.data.fingerprints[dep_node_index]
+        self.fingerprints[dep_node_index]
     }
 
     pub fn node_count(&self) -> usize {