Garbage collect dep graph

Zoxc · Zoxc · commit 4f7895fbf3df · 2019-05-28T04:22:14.000+02:00
diff --git a/src/librustc/dep_graph/mod.rs b/src/librustc/dep_graph/mod.rs
@@ -16,4 +16,4 @@ pub use self::prev::PreviousDepGraph;
 pub use self::query::DepGraphQuery;
 pub use self::safe::AssertDepGraphSafe;
 pub use self::safe::DepGraphSafe;
-pub use self::serialized::decode_dep_graph;
+pub use self::serialized::{DecodedDepGraph, decode_dep_graph, gc_dep_graph};
diff --git a/src/librustc/dep_graph/serialized.rs b/src/librustc/dep_graph/serialized.rs
@@ -1,7 +1,7 @@
 use rustc_data_structures::sync::worker::{Worker, WorkerExecutor};
 use rustc_data_structures::sync::{Lrc, AtomicCell};
 use rustc_data_structures::{unlikely, cold_path};
-use rustc_data_structures::indexed_vec::IndexVec;
+use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_serialize::{Decodable, Encodable, Encoder, Decoder, opaque};
@@ -14,15 +14,158 @@ use crate::dep_graph::dep_node::{DepKind, DepNode};
 use super::prev::PreviousDepGraph;
 use super::graph::{DepNodeData, DepNodeIndex, DepNodeState};
 
+// calcutale a list of bytes to copy from the previous graph
+
+fn decode_bounds(
+    d: &mut opaque::Decoder<'_>,
+    f: impl FnOnce(&mut opaque::Decoder<'_>) -> Result<(), String>
+) -> Result<(usize, usize), String> {
+    let start = d.position();
+    f(d)?;
+    Ok((start, d.position()))
+}
+
+type NodePoisitions = Vec<Option<(usize, usize)>>;
+
+fn read_dep_graph_positions(
+    d: &mut opaque::Decoder<'_>,
+    result: &DecodedDepGraph,
+) -> Result<(NodePoisitions, NodePoisitions), String> {
+    let node_count = result.prev_graph.nodes.len();
+    let mut nodes: NodePoisitions = repeat(None).take(node_count).collect();
+    let mut edges: NodePoisitions = repeat(None).take(node_count).collect();
+
+    loop {
+        if d.position() == d.data.len() {
+            break;
+        }
+        match SerializedAction::decode(d)? {
+            SerializedAction::AllocateNodes => {
+                let len = d.read_u32()?;
+                let start = DepNodeIndex::decode(d)?.as_u32();
+                for i in 0..len {
+                    let i = (start + i) as usize;
+                    nodes[i] = Some(decode_bounds(d, |d| DepNode::decode(d).map(|_| ()))?);
+                    edges[i] = Some(decode_bounds(d, |d| {
+                        let len = d.read_u32()?;
+                        for _ in 0..len {
+                            DepNodeIndex::decode(d)?;
+                        }
+                        Ok(())
+                    })?);
+                }
+            }
+            SerializedAction::UpdateEdges => {
+                let len = d.read_u32()?;
+                for _ in 0..len {
+                    let i = DepNodeIndex::decode(d)?.as_u32() as usize;
+                    edges[i] = Some(decode_bounds(d, |d| {
+                        let len = d.read_u32()?;
+                        for _ in 0..len {
+                            DepNodeIndex::decode(d)?;
+                        }
+                        Ok(())
+                    })?);
+                }
+            }
+            SerializedAction::InvalidateNodes => {
+                let len = d.read_u32()?;
+                for _ in 0..len {
+                    let i = DepNodeIndex::decode(d)?.as_u32() as usize;
+                    nodes[i] = None;
+                    edges[i] = None;
+                }
+            }
+        }
+    }
+
+    Ok((nodes, edges))
+}
+
+pub fn gc_dep_graph(
+    time_passes: bool,
+    d: &mut opaque::Decoder<'_>,
+    result: &DecodedDepGraph,
+    file: &mut File,
+) {
+    let (nodes, edges) = time_ext(time_passes, None, "read dep-graph positions", || { 
+        read_dep_graph_positions(d, result).unwrap()
+    });
+
+    let mut i = 0;
+
+    loop {
+        // Skip empty nodes
+        while i < nodes.len() && nodes[i].is_none() {
+            i += 1;
+        }
+
+        // Break if we are done
+        if i >= nodes.len() {
+            break;
+        }
+
+        // Find out how many consecutive nodes we will emit
+        let mut len = 1;
+        while i + len < nodes.len() && nodes[i + len].is_some() {
+            len += 1;
+        }
+
+        let mut encoder = opaque::Encoder::new(Vec::with_capacity(11));
+        SerializedAction::AllocateNodes.encode(&mut encoder).ok();
+        // Emit the number of nodes we're emitting
+        encoder.emit_u32(len as u32).ok();
+
+        // Emit the dep node index of the first node
+        DepNodeIndex::new(i).encode(&mut encoder).ok();
+
+        file.write_all(&encoder.into_inner()).unwrap();
+
+        let mut buffers = Vec::with_capacity(nodes.len() * 2);
+
+        let push_buffer = |buffers: &mut Vec<(usize, usize)>, range: (usize, usize)| {
+            if let Some(last) = buffers.last_mut() {
+                if last.1 == range.0 {
+                    // Extend the last range
+                    last.1 = range.1;
+                    return;
+                }
+            }
+            buffers.push(range);
+        };
+
+        for i in i..(i + len) {
+            // Encode the node
+            push_buffer(&mut buffers, nodes[i].unwrap());
+
+            // Encode dependencies
+            push_buffer(&mut buffers, edges[i].unwrap());
+        }
+
+        for buffer in buffers {
+            file.write_all(&d.data[buffer.0..buffer.1]).unwrap();
+        }
+
+        i += len;
+    }
+}
+
+pub struct DecodedDepGraph {
+    pub prev_graph: PreviousDepGraph,
+    pub state: IndexVec<DepNodeIndex, AtomicCell<DepNodeState>>,
+    pub invalidated: Vec<DepNodeIndex>,
+    pub needs_gc: bool,
+}
+
 pub fn decode_dep_graph(
     time_passes: bool,
     d: &mut opaque::Decoder<'_>,
     results_d: &mut opaque::Decoder<'_>,
-) -> Result<(
-        PreviousDepGraph,
-        IndexVec<DepNodeIndex, AtomicCell<DepNodeState>>,
-        Vec<DepNodeIndex>,
-    ), String> {
+) -> Result<DecodedDepGraph, String> {
+    // Metrics used to decided when to GC
+    let mut valid_data = 0;
+    let mut total_data = 0;
+
     let fingerprints: IndexVec<DepNodeIndex, Fingerprint> = 
         time_ext(time_passes, None, "decode prev result fingerprints", || {
             IndexVec::decode(results_d)
@@ -35,7 +178,6 @@ pub fn decode_dep_graph(
     let mut state: IndexVec<_, _> = (0..fingerprints.len()).map(|_| {
             AtomicCell::new(DepNodeState::Invalid)
         }).collect();
-    let mut invalid = Vec::new();
     loop {
         if d.position() == d.data.len() {
             break;
@@ -48,29 +190,39 @@ pub fn decode_dep_graph(
                     let i = DepNodeIndex::from_u32(start + i);
                     let node = DepNode::decode(d)?;
                     nodes[i] = node;
-                    edges[i] = Some(Box::<[DepNodeIndex]>::decode(d)?);
+                    let node_edges = Box::<[DepNodeIndex]>::decode(d)?;
+                    valid_data += node_edges.len();
+                    total_data += node_edges.len();
+                    edges[i] = Some(node_edges);
 
                     if unlikely!(node.kind.is_eval_always()) {
                         state[i] = AtomicCell::new(DepNodeState::UnknownEvalAlways);
                     } else {
                         state[i] = AtomicCell::new(DepNodeState::Unknown);
                     }
                 }
+                valid_data += len as usize * 8;
+                total_data += len as usize * 8;
             }
             SerializedAction::UpdateEdges => {
                 let len = d.read_u32()?;
                 for _ in 0..len {
                     let i = DepNodeIndex::decode(d)?;
-                    edges[i] = Some(Box::<[DepNodeIndex]>::decode(d)?);
+                    valid_data -= edges[i].as_ref().map_or(0, |edges| edges.len());
+                    let node_edges = Box::<[DepNodeIndex]>::decode(d)?;
+                    valid_data += node_edges.len();
+                    total_data += node_edges.len();
+                    edges[i] = Some(node_edges);
                 }
             }
             SerializedAction::InvalidateNodes => {
                 let len = d.read_u32()?;
                 for _ in 0..len {
                     let i = DepNodeIndex::decode(d)?;
+                    valid_data -= edges[i].as_ref().map_or(0, |edges| edges.len());
                     state[i] = AtomicCell::new(DepNodeState::Invalid);
-                    invalid.push(i);
                 }
+                valid_data -= len as usize * 8;
             }
         }
     }
@@ -81,12 +233,27 @@ pub fn decode_dep_graph(
             .map(|(idx, dep_node)| (*dep_node, idx))
             .collect()
     });
-    Ok((PreviousDepGraph {
-        index,
-        nodes,
-        fingerprints,
-        edges,
-    }, state, invalid))
+
+    debug!(
+        "valid bytes {} total bytes {} ratio {}",
+        valid_data,
+        total_data,
+        valid_data as f32 / total_data as f32
+    );
+
+    Ok(DecodedDepGraph {
+        prev_graph: PreviousDepGraph {
+            index,
+            nodes,
+            fingerprints,
+            edges,
+        },
+        invalidated: state.indices()
+            .filter(|&i| *state[i].get_mut() == DepNodeState::Invalid)
+            .collect(),
+        state,
+        needs_gc: valid_data + valid_data / 3 < total_data,
+    })
 }
 
 #[derive(Debug, RustcDecodable, RustcEncodable)]
diff --git a/src/librustc_incremental/persist/load.rs b/src/librustc_incremental/persist/load.rs
@@ -1,7 +1,7 @@
 //! Code to save/load the dep-graph from files.
 
 use rustc_data_structures::fx::FxHashMap;
-use rustc::dep_graph::{DepGraph, DepGraphArgs, decode_dep_graph};
+use rustc::dep_graph::{DepGraph, DepGraphArgs, decode_dep_graph, gc_dep_graph};
 use rustc::session::Session;
 use rustc::ty::TyCtxt;
 use rustc::ty::query::OnDiskCache;
@@ -11,6 +11,7 @@ use rustc_serialize::opaque::Decoder;
 use rustc_serialize::Encodable;
 use std::path::Path;
 use std::fs::{self, File};
+use std::io::{Seek, SeekFrom};
 
 use super::data::*;
 use super::fs::*;
@@ -225,7 +226,7 @@ pub fn load_dep_graph(sess: &Session) -> DepGraphFuture {
 
     MaybeAsync::Async(std::thread::spawn(move || {
         time_ext(time_passes, None, "background load prev dep-graph", move || {
-            let (bytes, pos, file) = match load_graph_file(
+            let (bytes, pos, mut file) = match load_graph_file(
                 report_incremental_info,
                 &path,
                 expected_hash
@@ -247,23 +248,35 @@ pub fn load_dep_graph(sess: &Session) -> DepGraphFuture {
 
             let mut decoder = Decoder::new(&bytes, pos);
             let mut results_decoder = Decoder::new(&results_bytes, results_pos);
-            time_ext(time_passes, None, "decode prev dep-graph", || {
-                let (prev_graph, state, invalidated) = decode_dep_graph(
+        
+            let result = time_ext(time_passes, None, "decode prev dep-graph", || { 
+                decode_dep_graph(
                     time_passes,
                     &mut decoder,
                     &mut results_decoder,
-                ).expect("Error reading cached dep-graph");
-
-                LoadResult::Ok {
-                    data: DepGraphArgs {
-                        prev_graph,
-                        prev_work_products,
-                        file,
-                        state,
-                        invalidated,
-                    }
+                ).expect("Error reading cached dep-graph")
+            });
+
+            if result.needs_gc {
+                // Reset the file to just the header
+                file.seek(SeekFrom::Start(pos as u64)).unwrap();
+                file.set_len(pos as u64).unwrap();
+
+                time_ext(time_passes, None, "garbage collect prev dep-graph", || { 
+                    let mut decoder = Decoder::new(&bytes, pos);
+                    gc_dep_graph(time_passes, &mut decoder, &result, &mut file);
+                });
+            }
+
+            LoadResult::Ok {
+                data: DepGraphArgs {
+                    prev_graph: result.prev_graph,
+                    prev_work_products,
+                    file,
+                    state: result.state,
+                    invalidated: result.invalidated,
                 }
-            })
+            }
         })
     }))
 }
