Only store changed dep nodes

Zoxc · Zoxc · commit 90d1dc7c60bc · 2019-05-28T04:22:11.000+02:00
diff --git a/src/librustc/dep_graph/graph.rs b/src/librustc/dep_graph/graph.rs
diff --git a/src/librustc/dep_graph/prev.rs b/src/librustc/dep_graph/prev.rs
@@ -2,9 +2,10 @@ 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};
 
-#[derive(Debug, RustcEncodable, RustcDecodable, Default)]
+#[derive(Debug, /*RustcEncodable, RustcDecodable,*/ Default)]
 pub struct PreviousDepGraph {
     /// Maps from dep nodes to their previous index, if any.
     index: FxHashMap<DepNode, SerializedDepNodeIndex>,
@@ -20,29 +21,35 @@ pub struct PreviousDepGraph {
     /// 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>,
 }
 
 impl PreviousDepGraph {
     pub fn new(graph: SerializedDepGraph) -> PreviousDepGraph {
         let index: FxHashMap<_, _> = graph.nodes
             .iter_enumerated()
-            .map(|(idx, dep_node)| (dep_node.node, idx))
+            .map(|(idx, dep_node)| {
+                (dep_node.node, SerializedDepNodeIndex::from_u32(idx.as_u32()))
+            })
             .collect();
 
         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 total_edge_count: usize = graph.nodes.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 graph.nodes.iter_enumerated()
-                                                                .map(|(i, d)| (i, &d.deps)) {
+                                                                .map(|(i, d)| (i, &d.edges)) {
             let start = edge_list_data.len() as u32;
-            edge_list_data.extend(edges.iter().cloned());
+            edge_list_data.extend(edges.iter().map(|i| {
+                SerializedDepNodeIndex::from_u32(i.as_u32())
+            }));
             let end = edge_list_data.len() as u32;
 
             debug_assert_eq!(current_dep_node_index.index(), edge_list_indices.len());
@@ -58,6 +65,7 @@ impl PreviousDepGraph {
             edge_list_indices,
             edge_list_data,
             index,
+            state: graph.state.convert_index_type(),
         }
     }
 
diff --git a/src/librustc/dep_graph/serialized.rs b/src/librustc/dep_graph/serialized.rs
@@ -3,82 +3,100 @@ use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::{unlikely, cold_path};
 use rustc_data_structures::indexed_vec::{IndexVec, Idx};
 use rustc_serialize::opaque;
-use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
+use rustc_serialize::{Decodable, Encodable};
 use std::mem;
 use std::fs::File;
 use std::io::Write;
-use super::graph::DepNodeData;
-use crate::dep_graph::DepNode;
-use crate::ich::Fingerprint;
+use super::graph::{DepNodeData, DepNodeIndex, DepNodeState};
 
 newtype_index! {
     pub struct SerializedDepNodeIndex { .. }
 }
 
-/// Data for use when recompiling the **current crate**.
+impl SerializedDepNodeIndex {
+    pub fn current(self) -> DepNodeIndex {
+        DepNodeIndex::from_u32(self.as_u32())
+    }
+}
+
 #[derive(Debug, Default)]
 pub struct SerializedDepGraph {
-    pub nodes: IndexVec<SerializedDepNodeIndex, SerializedNode>,
+    pub(super) nodes: IndexVec<DepNodeIndex, DepNodeData>,
+    pub(super) state: IndexVec<DepNodeIndex, DepNodeState>,
 }
 
-impl Decodable for SerializedDepGraph {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> {
+impl SerializedDepGraph {
+    pub fn decode(d: &mut opaque::Decoder<'_>) -> Result<Self, String> {
         let mut nodes = IndexVec::new();
+        let mut invalidated_list = Vec::new();
         loop {
-            let count = d.read_usize()?;
-            if count == 0 {
+            if d.position() == d.data.len() {
                 break;
             }
-            for _ in 0..count {
-                nodes.push(SerializedNode::decode(d)?);
+            match Action::decode(d)? {
+                Action::NewNodes(new_nodes) => {
+                    nodes.extend(new_nodes);
+                }
+                Action::UpdateNodes(changed) => {
+                    for (i, data) in changed {
+                        nodes[i] = data;
+                    }
+                }
+                Action::InvalidateNodes(nodes) => {
+                    invalidated_list.extend(nodes);
+                }
             }
         }
+        let mut state: IndexVec<_, _> = (0..nodes.len()).map(|_| {
+            DepNodeState::Unknown
+        }).collect();
+        for i in invalidated_list {
+            state[i] = DepNodeState::Invalidated;
+        }
         Ok(SerializedDepGraph {
             nodes,
+            state,
         })
     }
 }
 
-#[derive(Debug, RustcDecodable)]
-pub struct SerializedNode {
-    pub node: DepNode,
-    pub deps: Vec<SerializedDepNodeIndex>,
-    pub fingerprint: Fingerprint,
+#[derive(Debug, RustcEncodable, RustcDecodable)]
+enum Action {
+    NewNodes(Vec<DepNodeData>),
+    UpdateNodes(Vec<(DepNodeIndex, DepNodeData)>),
+    // FIXME: Is this redundant since these nodes will be also be updated?
+    // Could one of the indirect dependencies of a dep node change its result and
+    // cause a red node to be incorrectly green again?
+    // What about nodes which are in an unknown state?
+    // We must invalidate unknown nodes. Red nodes will have an entry in UpdateNodes
+    InvalidateNodes(Vec<DepNodeIndex>)
 }
 
 struct SerializerWorker {
     file: File,
 }
 
 impl Worker for SerializerWorker {
-    type Message = (usize, Vec<DepNodeData>);
+    type Message = (usize, Action);
     type Result = ();
 
-    fn message(&mut self, (buffer_size_est, nodes): (usize, Vec<DepNodeData>)) {
-        let mut encoder = opaque::Encoder::new(Vec::with_capacity(buffer_size_est * 4));
-        assert!(!nodes.is_empty());
-        encoder.emit_usize(nodes.len()).ok();
-        for data in nodes {
-            data.node.encode(&mut encoder).ok();
-            data.edges.encode(&mut encoder).ok();
-            data.fingerprint.encode(&mut encoder).ok();
-        }
+    fn message(&mut self, (buffer_size_est, action): (usize, Action)) {
+        let mut encoder = opaque::Encoder::new(Vec::with_capacity(buffer_size_est * 5));
+        action.encode(&mut encoder).ok();
         self.file.write_all(&encoder.into_inner()).expect("unable to write to temp dep graph");
     }
 
-    fn complete(mut self) {
-        let mut encoder = opaque::Encoder::new(Vec::with_capacity(16));
-        encoder.emit_usize(0).ok();
-        self.file.write_all(&encoder.into_inner()).expect("unable to write to temp dep graph");
-    }
+    fn complete(self) {}
 }
 
 const BUFFER_SIZE: usize = 800000;
 
 pub struct Serializer {
     worker: Lrc<WorkerExecutor<SerializerWorker>>,
-    buffer: Vec<DepNodeData>,
-    buffer_size: usize,
+    new_buffer: Vec<DepNodeData>,
+    new_buffer_size: usize,
+    updated_buffer: Vec<(DepNodeIndex, DepNodeData)>,
+    updated_buffer_size: usize,
 }
 
 impl Serializer {
@@ -87,33 +105,65 @@ impl Serializer {
             worker: Lrc::new(WorkerExecutor::new(SerializerWorker {
                 file,
             })),
-            buffer: Vec::with_capacity(BUFFER_SIZE),
-            buffer_size: 0,
+            new_buffer: Vec::with_capacity(BUFFER_SIZE),
+            new_buffer_size: 0,
+            updated_buffer: Vec::with_capacity(BUFFER_SIZE),
+            updated_buffer_size: 0,
+        }
+    }
+
+    fn flush_new(&mut self) {
+        let msgs = mem::replace(&mut self.new_buffer, Vec::with_capacity(BUFFER_SIZE));
+        let buffer_size = self.new_buffer_size;
+        self.new_buffer_size = 0;
+        self.worker.message_in_pool((buffer_size, Action::NewNodes(msgs)));
+    }
+
+    #[inline]
+    pub(super) fn serialize_new(&mut self, data: DepNodeData) {
+        let edges = data.edges.len();
+        self.new_buffer.push(data);
+        self.new_buffer_size += 8 + edges;
+        if unlikely!(self.new_buffer_size >= BUFFER_SIZE) {
+            cold_path(|| {
+                self.flush_new();
+            })
         }
     }
 
-    fn flush(&mut self) {
-        let msgs = mem::replace(&mut self.buffer, Vec::with_capacity(BUFFER_SIZE));
-        let buffer_size = self.buffer_size;
-        self.buffer_size = 0;
-        self.worker.message_in_pool((buffer_size, msgs));
+    fn flush_updated(&mut self) {
+        let msgs = mem::replace(&mut self.updated_buffer, Vec::with_capacity(BUFFER_SIZE));
+        let buffer_size = self.updated_buffer_size;
+        self.updated_buffer_size = 0;
+        self.worker.message_in_pool((buffer_size, Action::UpdateNodes(msgs)));
     }
 
     #[inline]
-    pub(super) fn serialize(&mut self, data: DepNodeData) {
+    pub(super) fn serialize_updated(&mut self, index: DepNodeIndex, data: DepNodeData) {
         let edges = data.edges.len();
-        self.buffer.push(data);
-        self.buffer_size += 8 + edges;
-        if unlikely!(self.buffer_size >= BUFFER_SIZE) {
+        self.updated_buffer.push((index, data));
+        self.updated_buffer_size += 9 + edges;
+        if unlikely!(self.updated_buffer_size >= BUFFER_SIZE) {
             cold_path(|| {
-                self.flush();
+                self.flush_updated();
             })
         }
     }
 
-    pub fn complete(&mut self) {
-        if self.buffer.len() > 0 {
-            self.flush();
+    pub fn complete(
+        &mut self,
+        invalidate: Vec<DepNodeIndex>,
+    ) {
+        if self.new_buffer.len() > 0 {
+            self.flush_new();
+        }
+        if self.updated_buffer.len() > 0 {
+            self.flush_updated();
+        }
+        if !invalidate.is_empty() {
+            self.worker.message_in_pool(
+                (invalidate.len(), Action::InvalidateNodes(invalidate))
+            );
         }
         self.worker.complete()
     }
diff --git a/src/librustc/ty/query/plumbing.rs b/src/librustc/ty/query/plumbing.rs
@@ -546,11 +546,14 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         //    in DepGraph::try_mark_green()
         // 2. Two distinct query keys get mapped to the same DepNode
         //    (see for example #48923)
-        assert!(!self.dep_graph.dep_node_exists(&dep_node),
-                "Forcing query with already existing DepNode.\n\
-                 - query-key: {:?}\n\
-                 - dep-node: {:?}",
-                key, dep_node);
+        /*debug_assert!(
+            !self.dep_graph.dep_node_exists(&dep_node),
+            "Forcing query with already existing DepNode.\n\
+                - query-key: {:?}\n\
+                - dep-node: {:?}",
+            key,
+            dep_node,
+        );*/
 
         profq_msg!(self, ProfileQueriesMsg::ProviderBegin);
         self.sess.profiler(|p| p.start_query(Q::NAME));
diff --git a/src/librustc_codegen_ssa/base.rs b/src/librustc_codegen_ssa/base.rs
@@ -944,9 +944,9 @@ fn determine_cgu_reuse<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     // know that later). If we are not doing LTO, there is only one optimized
     // version of each module, so we re-use that.
     let dep_node = cgu.codegen_dep_node(tcx);
-    assert!(!tcx.dep_graph.dep_node_exists(&dep_node),
+    /*debug_assert!(!tcx.dep_graph.dep_node_exists(&dep_node),
         "CompileCodegenUnit dep-node for CGU `{}` already exists before marking.",
-        cgu.name());
+        cgu.name());*/
 
     if tcx.dep_graph.try_mark_green(tcx, &dep_node).is_some() {
         // We can re-use either the pre- or the post-thinlto state
diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs
@@ -460,7 +460,7 @@ impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> {
             })
     }
 
-    fn dep_node_str(&self, dep_node: &DepNode) -> String {
+    fn _dep_node_str(&self, dep_node: &DepNode) -> String {
         if let Some(def_id) = dep_node.extract_def_id(self.tcx) {
             format!("{:?}({})",
                     dep_node.kind,
@@ -470,10 +470,10 @@ impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> {
         }
     }
 
-    fn assert_dirty(&self, item_span: Span, dep_node: DepNode) {
+    fn assert_dirty(&self, _item_span: Span, dep_node: DepNode) {
         debug!("assert_dirty({:?})", dep_node);
-
-        let dep_node_index = self.tcx.dep_graph.dep_node_index_of(&dep_node);
+        panic!()
+        /*let dep_node_index = self.tcx.dep_graph.dep_node_index_of(&dep_node);
         let current_fingerprint = self.tcx.dep_graph.fingerprint_of(dep_node_index);
         let prev_fingerprint = self.tcx.dep_graph.prev_fingerprint_of(&dep_node);
 
@@ -482,13 +482,13 @@ impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> {
             self.tcx.sess.span_err(
                 item_span,
                 &format!("`{}` should be dirty but is not", dep_node_str));
-        }
+        }*/
     }
 
-    fn assert_clean(&self, item_span: Span, dep_node: DepNode) {
+    fn assert_clean(&self, _item_span: Span, dep_node: DepNode) {
         debug!("assert_clean({:?})", dep_node);
-
-        let dep_node_index = self.tcx.dep_graph.dep_node_index_of(&dep_node);
+        panic!()
+        /*let dep_node_index = self.tcx.dep_graph.dep_node_index_of(&dep_node);
         let current_fingerprint = self.tcx.dep_graph.fingerprint_of(dep_node_index);
         let prev_fingerprint = self.tcx.dep_graph.prev_fingerprint_of(&dep_node);
 
@@ -497,7 +497,7 @@ impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> {
             self.tcx.sess.span_err(
                 item_span,
                 &format!("`{}` should be clean but is not", dep_node_str));
-        }
+        }*/
     }
 
     fn check_item(&mut self, item_id: hir::HirId, item_span: Span) {
diff --git a/src/librustc_incremental/persist/file_format.rs b/src/librustc_incremental/persist/file_format.rs
@@ -11,7 +11,7 @@
 
 use std::io::{self, Read};
 use std::path::Path;
-use std::fs;
+use std::fs::{OpenOptions, File};
 use std::env;
 
 use rustc::session::config::nightly_options;
@@ -49,13 +49,16 @@ pub fn write_file_header(stream: &mut Encoder) {
 /// - Returns `Err(..)` if some kind of IO error occurred while reading the
 ///   file.
 pub fn read_file(report_incremental_info: bool, path: &Path)
-    -> io::Result<Option<(Vec<u8>, usize)>>
+    -> io::Result<Option<(Vec<u8>, usize, File)>>
 {
     if !path.exists() {
         return Ok(None);
     }
 
-    let data = fs::read(path)?;
+    let mut real_file = OpenOptions::new().read(true).write(true).open(path)?;
+    let len = real_file.metadata().map(|m| m.len() as usize + 1).unwrap_or(0);
+    let mut data = Vec::with_capacity(len);
+    real_file.read_to_end(&mut data)?;
 
     let mut file = io::Cursor::new(data);
 
@@ -100,7 +103,7 @@ pub fn read_file(report_incremental_info: bool, path: &Path)
     }
 
     let post_header_start_pos = file.position() as usize;
-    Ok(Some((file.into_inner(), post_header_start_pos)))
+    Ok(Some((file.into_inner(), post_header_start_pos, real_file)))
 }
 
 fn report_format_mismatch(report_incremental_info: bool, file: &Path, message: &str) {
diff --git a/src/librustc_incremental/persist/load.rs b/src/librustc_incremental/persist/load.rs
