fix termination

Author: Zoxc

compiler/rustc_query_system/src/dep_graph/serialized.rs

@@ -198,19 +198,20 @@ impl SerializedDepGraph {
 
         // `node_max` is the number of indices including empty nodes while `node_count`
         // is the number of actually encoded nodes.
-        let (node_max, node_count, edge_count) =
-            d.with_position(d.len() - 3 * IntEncodedWithFixedSize::ENCODED_SIZE, |d| {
+        let (node_max, node_count, edge_count, chunk_count) =
+            d.with_position(d.len() - 4 * IntEncodedWithFixedSize::ENCODED_SIZE, |d| {
                 debug!("position: {:?}", d.position());
                 let node_max = IntEncodedWithFixedSize::decode(d).0 as usize;
                 let node_count = IntEncodedWithFixedSize::decode(d).0 as usize;
                 let edge_count = IntEncodedWithFixedSize::decode(d).0 as usize;
-                (node_max, node_count, edge_count)
+                let chunk_count = IntEncodedWithFixedSize::decode(d).0 as usize;
+                (node_max, node_count, edge_count, chunk_count)
             });
         debug!("position: {:?}", d.position());
 
         debug!(?node_count, ?edge_count);
 
-        let graph_bytes = d.len() - (3 * IntEncodedWithFixedSize::ENCODED_SIZE) - d.position();
+        let graph_bytes = d.len() - (4 * IntEncodedWithFixedSize::ENCODED_SIZE) - d.position();
 
         let mut nodes = IndexVec::from_elem_n(
             DepNode { kind: D::DEP_KIND_NULL, hash: PackedFingerprint::from(Fingerprint::ZERO) },
@@ -232,8 +233,7 @@ impl SerializedDepGraph {
         let mut edge_list_data =
             Vec::with_capacity(graph_bytes - node_count * size_of::<SerializedNodeHeader<D>>());
 
-        let mut decoded_nodes = 0;
-        while decoded_nodes < node_count {
+        for _ in 0..chunk_count {
             let mut current_index = d.read_u32();
 
             loop {
@@ -246,8 +246,6 @@ impl SerializedDepGraph {
                     break;
                 }
 
-                decoded_nodes += 1;
-
                 let index = SerializedDepNodeIndex::from_u32(current_index);
                 current_index += 1;
 
@@ -524,6 +522,7 @@ struct LocalEncoderState {
     encoder: MemEncoder,
     node_count: usize,
     edge_count: usize,
+    chunk_count: usize,
 
     in_chunk: bool,
 
@@ -535,6 +534,7 @@ struct LocalEncoderResult {
     node_max: u32,
     node_count: usize,
     edge_count: usize,
+    chunk_count: usize,
 
     /// Stores the number of times we've encoded each dep kind.
     kind_stats: Vec<u32>,
@@ -562,6 +562,7 @@ impl<D: Deps> EncoderState<D> {
                     remaining_node_index: 0,
                     edge_count: 0,
                     node_count: 0,
+                    chunk_count: 0,
                     in_chunk: false,
                     encoder: MemEncoder::new(),
                     kind_stats: iter::repeat_n(0, D::DEP_KIND_MAX as usize + 1).collect(),
@@ -592,6 +593,7 @@ impl<D: Deps> EncoderState<D> {
             self.end_chunk(local);
         }
         local.in_chunk = true;
+        local.chunk_count += 1;
         local.encoder.emit_u32(first_index);
     }
 
@@ -758,21 +760,26 @@ impl<D: Deps> EncoderState<D> {
                 node_max: local.next_node_index,
                 node_count: local.node_count,
                 edge_count: local.edge_count,
+                chunk_count: local.chunk_count,
             }
         });
 
         let mut encoder = self.file.lock().take().unwrap();
 
+        encoder.emit_u64(0xAC75672356237839);
+
         let mut kind_stats: Vec<u32> = iter::repeat_n(0, D::DEP_KIND_MAX as usize + 1).collect();
 
         let mut node_max = 0;
         let mut node_count = 0;
         let mut edge_count = 0;
+        let mut chunk_count = 0;
 
         for result in results {
             node_max = max(node_max, result.node_max);
             node_count += result.node_count;
             edge_count += result.edge_count;
+            chunk_count += result.chunk_count;
             for (i, stat) in result.kind_stats.iter().enumerate() {
                 kind_stats[i] += stat;
             }
@@ -790,6 +797,7 @@ impl<D: Deps> EncoderState<D> {
         IntEncodedWithFixedSize(node_max.try_into().unwrap()).encode(&mut encoder);
         IntEncodedWithFixedSize(node_count.try_into().unwrap()).encode(&mut encoder);
         IntEncodedWithFixedSize(edge_count.try_into().unwrap()).encode(&mut encoder);
+        IntEncodedWithFixedSize(chunk_count.try_into().unwrap()).encode(&mut encoder);
         debug!("position: {:?}", encoder.position());
         // Drop the encoder so that nothing is written after the counts.
         let result = encoder.finish();