rustc_query_system/dep_graph/
serialized.rs

1//! The data that we will serialize and deserialize.
2//!
3//! Notionally, the dep-graph is a sequence of NodeInfo with the dependencies
4//! specified inline. The total number of nodes and edges are stored as the last
5//! 16 bytes of the file, so we can find them easily at decoding time.
6//!
7//! The serialisation is performed on-demand when each node is emitted. Using this
8//! scheme, we do not need to keep the current graph in memory.
9//!
10//! The deserialization is performed manually, in order to convert from the stored
11//! sequence of NodeInfos to the different arrays in SerializedDepGraph. Since the
12//! node and edge count are stored at the end of the file, all the arrays can be
13//! pre-allocated with the right length.
14//!
15//! The encoding of the de-pgraph is generally designed around the fact that fixed-size
16//! reads of encoded data are generally faster than variable-sized reads. Ergo we adopt
17//! essentially the same varint encoding scheme used in the rmeta format; the edge lists
18//! for each node on the graph store a 2-bit integer which is the number of bytes per edge
19//! index in that node's edge list. We effectively ignore that an edge index of 0 could be
20//! encoded with 0 bytes in order to not require 3 bits to store the byte width of the edges.
21//! The overhead of calculating the correct byte width for each edge is mitigated by
22//! building edge lists with [`EdgesVec`] which keeps a running max of the edges in a node.
23//!
24//! When we decode this data, we do not immediately create [`SerializedDepNodeIndex`] and
25//! instead keep the data in its denser serialized form which lets us turn our on-disk size
26//! efficiency directly into a peak memory reduction. When we convert these encoded-in-memory
27//! values into their fully-deserialized type, we use a fixed-size read of the encoded array
28//! then mask off any errant bytes we read. The array of edge index bytes is padded to permit this.
29//!
30//! We also encode and decode the entire rest of each node using [`SerializedNodeHeader`]
31//! to let this encoding and decoding be done in one fixed-size operation. These headers contain
32//! two [`Fingerprint`]s along with the serialized [`DepKind`], and the number of edge indices
33//! in the node and the number of bytes used to encode the edge indices for this node. The
34//! [`DepKind`], number of edges, and bytes per edge are all bit-packed together, if they fit.
35//! If the number of edges in this node does not fit in the bits available in the header, we
36//! store it directly after the header with leb128.
37
38use std::iter;
39use std::marker::PhantomData;
40use std::sync::Arc;
41
42use rustc_data_structures::fingerprint::{Fingerprint, PackedFingerprint};
43use rustc_data_structures::fx::FxHashMap;
44use rustc_data_structures::outline;
45use rustc_data_structures::profiling::SelfProfilerRef;
46use rustc_data_structures::sync::Lock;
47use rustc_data_structures::unhash::UnhashMap;
48use rustc_index::{Idx, IndexVec};
49use rustc_serialize::opaque::{FileEncodeResult, FileEncoder, IntEncodedWithFixedSize, MemDecoder};
50use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
51use tracing::{debug, instrument};
52
53use super::query::DepGraphQuery;
54use super::{DepKind, DepNode, DepNodeIndex, Deps};
55use crate::dep_graph::edges::EdgesVec;
56
57// The maximum value of `SerializedDepNodeIndex` leaves the upper two bits
58// unused so that we can store multiple index types in `CompressedHybridIndex`,
59// and use those bits to encode which index type it contains.
60rustc_index::newtype_index! {
61    #[encodable]
62    #[max = 0x7FFF_FFFF]
63    pub struct SerializedDepNodeIndex {}
64}
65
66const DEP_NODE_SIZE: usize = std::mem::size_of::<SerializedDepNodeIndex>();
67/// Amount of padding we need to add to the edge list data so that we can retrieve every
68/// SerializedDepNodeIndex with a fixed-size read then mask.
69const DEP_NODE_PAD: usize = DEP_NODE_SIZE - 1;
70/// Number of bits we need to store the number of used bytes in a SerializedDepNodeIndex.
71/// Note that wherever we encode byte widths like this we actually store the number of bytes used
72/// minus 1; for a 4-byte value we technically would have 5 widths to store, but using one byte to
73/// store zeroes (which are relatively rare) is a decent tradeoff to save a bit in our bitfields.
74const DEP_NODE_WIDTH_BITS: usize = DEP_NODE_SIZE / 2;
75
76/// Data for use when recompiling the **current crate**.
77#[derive(Debug, Default)]
78pub struct SerializedDepGraph {
79    /// The set of all DepNodes in the graph
80    nodes: IndexVec<SerializedDepNodeIndex, DepNode>,
81    /// The set of all Fingerprints in the graph. Each Fingerprint corresponds to
82    /// the DepNode at the same index in the nodes vector.
83    fingerprints: IndexVec<SerializedDepNodeIndex, Fingerprint>,
84    /// For each DepNode, stores the list of edges originating from that
85    /// DepNode. Encoded as a [start, end) pair indexing into edge_list_data,
86    /// which holds the actual DepNodeIndices of the target nodes.
87    edge_list_indices: IndexVec<SerializedDepNodeIndex, EdgeHeader>,
88    /// A flattened list of all edge targets in the graph, stored in the same
89    /// varint encoding that we use on disk. Edge sources are implicit in edge_list_indices.
90    edge_list_data: Vec<u8>,
91    /// Stores a map from fingerprints to nodes per dep node kind.
92    /// This is the reciprocal of `nodes`.
93    index: Vec<UnhashMap<PackedFingerprint, SerializedDepNodeIndex>>,
94}
95
96impl SerializedDepGraph {
97    #[inline]
98    pub fn edge_targets_from(
99        &self,
100        source: SerializedDepNodeIndex,
101    ) -> impl Iterator<Item = SerializedDepNodeIndex> + Clone + '_ {
102        let header = self.edge_list_indices[source];
103        let mut raw = &self.edge_list_data[header.start()..];
104        // Figure out where the edge list for `source` ends by getting the start index of the next
105        // edge list, or the end of the array if this is the last edge.
106        let end = self
107            .edge_list_indices
108            .get(source + 1)
109            .map(|h| h.start())
110            .unwrap_or_else(|| self.edge_list_data.len() - DEP_NODE_PAD);
111
112        // The number of edges for this node is implicitly stored in the combination of the byte
113        // width and the length.
114        let bytes_per_index = header.bytes_per_index();
115        let len = (end - header.start()) / bytes_per_index;
116
117        // LLVM doesn't hoist EdgeHeader::mask so we do it ourselves.
118        let mask = header.mask();
119        (0..len).map(move |_| {
120            // Doing this slicing in this order ensures that the first bounds check suffices for
121            // all the others.
122            let index = &raw[..DEP_NODE_SIZE];
123            raw = &raw[bytes_per_index..];
124            let index = u32::from_le_bytes(index.try_into().unwrap()) & mask;
125            SerializedDepNodeIndex::from_u32(index)
126        })
127    }
128
129    #[inline]
130    pub fn index_to_node(&self, dep_node_index: SerializedDepNodeIndex) -> DepNode {
131        self.nodes[dep_node_index]
132    }
133
134    #[inline]
135    pub fn node_to_index_opt(&self, dep_node: &DepNode) -> Option<SerializedDepNodeIndex> {
136        self.index.get(dep_node.kind.as_usize())?.get(&dep_node.hash).cloned()
137    }
138
139    #[inline]
140    pub fn fingerprint_by_index(&self, dep_node_index: SerializedDepNodeIndex) -> Fingerprint {
141        self.fingerprints[dep_node_index]
142    }
143
144    #[inline]
145    pub fn node_count(&self) -> usize {
146        self.nodes.len()
147    }
148}
149
150/// A packed representation of an edge's start index and byte width.
151///
152/// This is packed by stealing 2 bits from the start index, which means we only accommodate edge
153/// data arrays up to a quarter of our address space. Which seems fine.
154#[derive(Debug, Clone, Copy)]
155struct EdgeHeader {
156    repr: usize,
157}
158
159impl EdgeHeader {
160    #[inline]
161    fn start(self) -> usize {
162        self.repr >> DEP_NODE_WIDTH_BITS
163    }
164
165    #[inline]
166    fn bytes_per_index(self) -> usize {
167        (self.repr & mask(DEP_NODE_WIDTH_BITS)) + 1
168    }
169
170    #[inline]
171    fn mask(self) -> u32 {
172        mask(self.bytes_per_index() * 8) as u32
173    }
174}
175
176#[inline]
177fn mask(bits: usize) -> usize {
178    usize::MAX >> ((std::mem::size_of::<usize>() * 8) - bits)
179}
180
181impl SerializedDepGraph {
182    #[instrument(level = "debug", skip(d))]
183    pub fn decode<D: Deps>(d: &mut MemDecoder<'_>) -> Arc<SerializedDepGraph> {
184        // The last 16 bytes are the node count and edge count.
185        debug!("position: {:?}", d.position());
186        let (node_count, edge_count) =
187            d.with_position(d.len() - 2 * IntEncodedWithFixedSize::ENCODED_SIZE, |d| {
188                debug!("position: {:?}", d.position());
189                let node_count = IntEncodedWithFixedSize::decode(d).0 as usize;
190                let edge_count = IntEncodedWithFixedSize::decode(d).0 as usize;
191                (node_count, edge_count)
192            });
193        debug!("position: {:?}", d.position());
194
195        debug!(?node_count, ?edge_count);
196
197        let graph_bytes = d.len() - (2 * IntEncodedWithFixedSize::ENCODED_SIZE) - d.position();
198
199        let mut nodes = IndexVec::with_capacity(node_count);
200        let mut fingerprints = IndexVec::with_capacity(node_count);
201        let mut edge_list_indices = IndexVec::with_capacity(node_count);
202        // This estimation assumes that all of the encoded bytes are for the edge lists or for the
203        // fixed-size node headers. But that's not necessarily true; if any edge list has a length
204        // that spills out of the size we can bit-pack into SerializedNodeHeader then some of the
205        // total serialized size is also used by leb128-encoded edge list lengths. Neglecting that
206        // contribution to graph_bytes means our estimation of the bytes needed for edge_list_data
207        // slightly overshoots. But it cannot overshoot by much; consider that the worse case is
208        // for a node with length 64, which means the spilled 1-byte leb128 length is 1 byte of at
209        // least (34 byte header + 1 byte len + 64 bytes edge data), which is ~1%. A 2-byte leb128
210        // length is about the same fractional overhead and it amortizes for yet greater lengths.
211        let mut edge_list_data = Vec::with_capacity(
212            graph_bytes - node_count * std::mem::size_of::<SerializedNodeHeader<D>>(),
213        );
214
215        for _index in 0..node_count {
216            // Decode the header for this edge; the header packs together as many of the fixed-size
217            // fields as possible to limit the number of times we update decoder state.
218            let node_header =
219                SerializedNodeHeader::<D> { bytes: d.read_array(), _marker: PhantomData };
220
221            let _i: SerializedDepNodeIndex = nodes.push(node_header.node());
222            debug_assert_eq!(_i.index(), _index);
223
224            let _i: SerializedDepNodeIndex = fingerprints.push(node_header.fingerprint());
225            debug_assert_eq!(_i.index(), _index);
226
227            // If the length of this node's edge list is small, the length is stored in the header.
228            // If it is not, we fall back to another decoder call.
229            let num_edges = node_header.len().unwrap_or_else(|| d.read_usize());
230
231            // The edges index list uses the same varint strategy as rmeta tables; we select the
232            // number of byte elements per-array not per-element. This lets us read the whole edge
233            // list for a node with one decoder call and also use the on-disk format in memory.
234            let edges_len_bytes = node_header.bytes_per_index() * num_edges;
235            // The in-memory structure for the edges list stores the byte width of the edges on
236            // this node with the offset into the global edge data array.
237            let edges_header = node_header.edges_header(&edge_list_data);
238
239            edge_list_data.extend(d.read_raw_bytes(edges_len_bytes));
240
241            let _i: SerializedDepNodeIndex = edge_list_indices.push(edges_header);
242            debug_assert_eq!(_i.index(), _index);
243        }
244
245        // When we access the edge list data, we do a fixed-size read from the edge list data then
246        // mask off the bytes that aren't for that edge index, so the last read may dangle off the
247        // end of the array. This padding ensure it doesn't.
248        edge_list_data.extend(&[0u8; DEP_NODE_PAD]);
249
250        // Read the number of each dep kind and use it to create an hash map with a suitable size.
251        let mut index: Vec<_> = (0..(D::DEP_KIND_MAX + 1))
252            .map(|_| UnhashMap::with_capacity_and_hasher(d.read_u32() as usize, Default::default()))
253            .collect();
254
255        for (idx, node) in nodes.iter_enumerated() {
256            index[node.kind.as_usize()].insert(node.hash, idx);
257        }
258
259        Arc::new(SerializedDepGraph {
260            nodes,
261            fingerprints,
262            edge_list_indices,
263            edge_list_data,
264            index,
265        })
266    }
267}
268
269/// A packed representation of all the fixed-size fields in a `NodeInfo`.
270///
271/// This stores in one byte array:
272/// * The `Fingerprint` in the `NodeInfo`
273/// * The `Fingerprint` in `DepNode` that is in this `NodeInfo`
274/// * The `DepKind`'s discriminant (a u16, but not all bits are used...)
275/// * The byte width of the encoded edges for this node
276/// * In whatever bits remain, the length of the edge list for this node, if it fits
277struct SerializedNodeHeader<D> {
278    // 2 bytes for the DepNode
279    // 16 for Fingerprint in DepNode
280    // 16 for Fingerprint in NodeInfo
281    bytes: [u8; 34],
282    _marker: PhantomData<D>,
283}
284
285// The fields of a `SerializedNodeHeader`, this struct is an implementation detail and exists only
286// to make the implementation of `SerializedNodeHeader` simpler.
287struct Unpacked {
288    len: Option<usize>,
289    bytes_per_index: usize,
290    kind: DepKind,
291    hash: PackedFingerprint,
292    fingerprint: Fingerprint,
293}
294
295// Bit fields, where
296// M: bits used to store the length of a node's edge list
297// N: bits used to store the byte width of elements of the edge list
298// are
299// 0..M    length of the edge
300// M..M+N  bytes per index
301// M+N..16 kind
302impl<D: Deps> SerializedNodeHeader<D> {
303    const TOTAL_BITS: usize = std::mem::size_of::<DepKind>() * 8;
304    const LEN_BITS: usize = Self::TOTAL_BITS - Self::KIND_BITS - Self::WIDTH_BITS;
305    const WIDTH_BITS: usize = DEP_NODE_WIDTH_BITS;
306    const KIND_BITS: usize = Self::TOTAL_BITS - D::DEP_KIND_MAX.leading_zeros() as usize;
307    const MAX_INLINE_LEN: usize = (u16::MAX as usize >> (Self::TOTAL_BITS - Self::LEN_BITS)) - 1;
308
309    #[inline]
310    fn new(
311        node: DepNode,
312        fingerprint: Fingerprint,
313        edge_max_index: u32,
314        edge_count: usize,
315    ) -> Self {
316        debug_assert_eq!(Self::TOTAL_BITS, Self::LEN_BITS + Self::WIDTH_BITS + Self::KIND_BITS);
317
318        let mut head = node.kind.as_inner();
319
320        let free_bytes = edge_max_index.leading_zeros() as usize / 8;
321        let bytes_per_index = (DEP_NODE_SIZE - free_bytes).saturating_sub(1);
322        head |= (bytes_per_index as u16) << Self::KIND_BITS;
323
324        // Encode number of edges + 1 so that we can reserve 0 to indicate that the len doesn't fit
325        // in this bitfield.
326        if edge_count <= Self::MAX_INLINE_LEN {
327            head |= (edge_count as u16 + 1) << (Self::KIND_BITS + Self::WIDTH_BITS);
328        }
329
330        let hash: Fingerprint = node.hash.into();
331
332        // Using half-open ranges ensures an unconditional panic if we get the magic numbers wrong.
333        let mut bytes = [0u8; 34];
334        bytes[..2].copy_from_slice(&head.to_le_bytes());
335        bytes[2..18].copy_from_slice(&hash.to_le_bytes());
336        bytes[18..].copy_from_slice(&fingerprint.to_le_bytes());
337
338        #[cfg(debug_assertions)]
339        {
340            let res = Self { bytes, _marker: PhantomData };
341            assert_eq!(fingerprint, res.fingerprint());
342            assert_eq!(node, res.node());
343            if let Some(len) = res.len() {
344                assert_eq!(edge_count, len);
345            }
346        }
347        Self { bytes, _marker: PhantomData }
348    }
349
350    #[inline]
351    fn unpack(&self) -> Unpacked {
352        let head = u16::from_le_bytes(self.bytes[..2].try_into().unwrap());
353        let hash = self.bytes[2..18].try_into().unwrap();
354        let fingerprint = self.bytes[18..].try_into().unwrap();
355
356        let kind = head & mask(Self::KIND_BITS) as u16;
357        let bytes_per_index = (head >> Self::KIND_BITS) & mask(Self::WIDTH_BITS) as u16;
358        let len = (head as usize) >> (Self::WIDTH_BITS + Self::KIND_BITS);
359
360        Unpacked {
361            len: len.checked_sub(1),
362            bytes_per_index: bytes_per_index as usize + 1,
363            kind: DepKind::new(kind),
364            hash: Fingerprint::from_le_bytes(hash).into(),
365            fingerprint: Fingerprint::from_le_bytes(fingerprint),
366        }
367    }
368
369    #[inline]
370    fn len(&self) -> Option<usize> {
371        self.unpack().len
372    }
373
374    #[inline]
375    fn bytes_per_index(&self) -> usize {
376        self.unpack().bytes_per_index
377    }
378
379    #[inline]
380    fn fingerprint(&self) -> Fingerprint {
381        self.unpack().fingerprint
382    }
383
384    #[inline]
385    fn node(&self) -> DepNode {
386        let Unpacked { kind, hash, .. } = self.unpack();
387        DepNode { kind, hash }
388    }
389
390    #[inline]
391    fn edges_header(&self, edge_list_data: &[u8]) -> EdgeHeader {
392        EdgeHeader {
393            repr: (edge_list_data.len() << DEP_NODE_WIDTH_BITS) | (self.bytes_per_index() - 1),
394        }
395    }
396}
397
398#[derive(Debug)]
399struct NodeInfo {
400    node: DepNode,
401    fingerprint: Fingerprint,
402    edges: EdgesVec,
403}
404
405impl NodeInfo {
406    fn encode<D: Deps>(&self, e: &mut FileEncoder) {
407        let NodeInfo { node, fingerprint, ref edges } = *self;
408        let header =
409            SerializedNodeHeader::<D>::new(node, fingerprint, edges.max_index(), edges.len());
410        e.write_array(header.bytes);
411
412        if header.len().is_none() {
413            e.emit_usize(edges.len());
414        }
415
416        let bytes_per_index = header.bytes_per_index();
417        for node_index in edges.iter() {
418            e.write_with(|dest| {
419                *dest = node_index.as_u32().to_le_bytes();
420                bytes_per_index
421            });
422        }
423    }
424
425    /// Encode a node that was promoted from the previous graph. It reads the edges directly from
426    /// the previous dep graph and expects all edges to already have a new dep node index assigned.
427    /// This avoids the overhead of constructing `EdgesVec`, which would be needed to call `encode`.
428    #[inline]
429    fn encode_promoted<D: Deps>(
430        e: &mut FileEncoder,
431        node: DepNode,
432        fingerprint: Fingerprint,
433        prev_index: SerializedDepNodeIndex,
434        prev_index_to_index: &IndexVec<SerializedDepNodeIndex, Option<DepNodeIndex>>,
435        previous: &SerializedDepGraph,
436    ) -> usize {
437        let edges = previous.edge_targets_from(prev_index);
438        let edge_count = edges.size_hint().0;
439
440        // Find the highest edge in the new dep node indices
441        let edge_max =
442            edges.clone().map(|i| prev_index_to_index[i].unwrap().as_u32()).max().unwrap_or(0);
443
444        let header = SerializedNodeHeader::<D>::new(node, fingerprint, edge_max, edge_count);
445        e.write_array(header.bytes);
446
447        if header.len().is_none() {
448            e.emit_usize(edge_count);
449        }
450
451        let bytes_per_index = header.bytes_per_index();
452        for node_index in edges {
453            let node_index = prev_index_to_index[node_index].unwrap();
454            e.write_with(|dest| {
455                *dest = node_index.as_u32().to_le_bytes();
456                bytes_per_index
457            });
458        }
459
460        edge_count
461    }
462}
463
464struct Stat {
465    kind: DepKind,
466    node_counter: u64,
467    edge_counter: u64,
468}
469
470struct EncoderState<D: Deps> {
471    previous: Arc<SerializedDepGraph>,
472    encoder: FileEncoder,
473    total_node_count: usize,
474    total_edge_count: usize,
475    stats: Option<FxHashMap<DepKind, Stat>>,
476
477    /// Stores the number of times we've encoded each dep kind.
478    kind_stats: Vec<u32>,
479    marker: PhantomData<D>,
480}
481
482impl<D: Deps> EncoderState<D> {
483    fn new(encoder: FileEncoder, record_stats: bool, previous: Arc<SerializedDepGraph>) -> Self {
484        Self {
485            previous,
486            encoder,
487            total_edge_count: 0,
488            total_node_count: 0,
489            stats: record_stats.then(FxHashMap::default),
490            kind_stats: iter::repeat(0).take(D::DEP_KIND_MAX as usize + 1).collect(),
491            marker: PhantomData,
492        }
493    }
494
495    #[inline]
496    fn record(
497        &mut self,
498        node: DepNode,
499        edge_count: usize,
500        edges: impl FnOnce(&mut Self) -> Vec<DepNodeIndex>,
501        record_graph: &Option<Lock<DepGraphQuery>>,
502    ) -> DepNodeIndex {
503        let index = DepNodeIndex::new(self.total_node_count);
504
505        self.total_node_count += 1;
506        self.kind_stats[node.kind.as_usize()] += 1;
507        self.total_edge_count += edge_count;
508
509        if let Some(record_graph) = &record_graph {
510            // Call `edges` before the outlined code to allow the closure to be optimized out.
511            let edges = edges(self);
512
513            // Outline the build of the full dep graph as it's typically disabled and cold.
514            outline(move || {
515                // Do not ICE when a query is called from within `with_query`.
516                if let Some(record_graph) = &mut record_graph.try_lock() {
517                    record_graph.push(index, node, &edges);
518                }
519            });
520        }
521
522        if let Some(stats) = &mut self.stats {
523            let kind = node.kind;
524
525            // Outline the stats code as it's typically disabled and cold.
526            outline(move || {
527                let stat =
528                    stats.entry(kind).or_insert(Stat { kind, node_counter: 0, edge_counter: 0 });
529                stat.node_counter += 1;
530                stat.edge_counter += edge_count as u64;
531            });
532        }
533
534        index
535    }
536
537    /// Encodes a node to the current graph.
538    fn encode_node(
539        &mut self,
540        node: &NodeInfo,
541        record_graph: &Option<Lock<DepGraphQuery>>,
542    ) -> DepNodeIndex {
543        node.encode::<D>(&mut self.encoder);
544        self.record(node.node, node.edges.len(), |_| node.edges[..].to_vec(), record_graph)
545    }
546
547    /// Encodes a node that was promoted from the previous graph. It reads the information directly from
548    /// the previous dep graph for performance reasons.
549    ///
550    /// This differs from `encode_node` where you have to explicitly provide the relevant `NodeInfo`.
551    ///
552    /// It expects all edges to already have a new dep node index assigned.
553    #[inline]
554    fn encode_promoted_node(
555        &mut self,
556        prev_index: SerializedDepNodeIndex,
557        record_graph: &Option<Lock<DepGraphQuery>>,
558        prev_index_to_index: &IndexVec<SerializedDepNodeIndex, Option<DepNodeIndex>>,
559    ) -> DepNodeIndex {
560        let node = self.previous.index_to_node(prev_index);
561
562        let fingerprint = self.previous.fingerprint_by_index(prev_index);
563        let edge_count = NodeInfo::encode_promoted::<D>(
564            &mut self.encoder,
565            node,
566            fingerprint,
567            prev_index,
568            prev_index_to_index,
569            &self.previous,
570        );
571
572        self.record(
573            node,
574            edge_count,
575            |this| {
576                this.previous
577                    .edge_targets_from(prev_index)
578                    .map(|i| prev_index_to_index[i].unwrap())
579                    .collect()
580            },
581            record_graph,
582        )
583    }
584
585    fn finish(self, profiler: &SelfProfilerRef) -> FileEncodeResult {
586        let Self {
587            mut encoder,
588            total_node_count,
589            total_edge_count,
590            stats: _,
591            kind_stats,
592            marker: _,
593            previous: _,
594        } = self;
595
596        let node_count = total_node_count.try_into().unwrap();
597        let edge_count = total_edge_count.try_into().unwrap();
598
599        // Encode the number of each dep kind encountered
600        for count in kind_stats.iter() {
601            count.encode(&mut encoder);
602        }
603
604        debug!(?node_count, ?edge_count);
605        debug!("position: {:?}", encoder.position());
606        IntEncodedWithFixedSize(node_count).encode(&mut encoder);
607        IntEncodedWithFixedSize(edge_count).encode(&mut encoder);
608        debug!("position: {:?}", encoder.position());
609        // Drop the encoder so that nothing is written after the counts.
610        let result = encoder.finish();
611        if let Ok(position) = result {
612            // FIXME(rylev): we hardcode the dep graph file name so we
613            // don't need a dependency on rustc_incremental just for that.
614            profiler.artifact_size("dep_graph", "dep-graph.bin", position as u64);
615        }
616        result
617    }
618}
619
620pub(crate) struct GraphEncoder<D: Deps> {
621    profiler: SelfProfilerRef,
622    status: Lock<Option<EncoderState<D>>>,
623    record_graph: Option<Lock<DepGraphQuery>>,
624}
625
626impl<D: Deps> GraphEncoder<D> {
627    pub(crate) fn new(
628        encoder: FileEncoder,
629        prev_node_count: usize,
630        record_graph: bool,
631        record_stats: bool,
632        profiler: &SelfProfilerRef,
633        previous: Arc<SerializedDepGraph>,
634    ) -> Self {
635        let record_graph = record_graph.then(|| Lock::new(DepGraphQuery::new(prev_node_count)));
636        let status = Lock::new(Some(EncoderState::new(encoder, record_stats, previous)));
637        GraphEncoder { status, record_graph, profiler: profiler.clone() }
638    }
639
640    pub(crate) fn with_query(&self, f: impl Fn(&DepGraphQuery)) {
641        if let Some(record_graph) = &self.record_graph {
642            f(&record_graph.lock())
643        }
644    }
645
646    pub(crate) fn print_incremental_info(
647        &self,
648        total_read_count: u64,
649        total_duplicate_read_count: u64,
650    ) {
651        let mut status = self.status.lock();
652        let status = status.as_mut().unwrap();
653        if let Some(record_stats) = &status.stats {
654            let mut stats: Vec<_> = record_stats.values().collect();
655            stats.sort_by_key(|s| -(s.node_counter as i64));
656
657            const SEPARATOR: &str = "[incremental] --------------------------------\
658                                     ----------------------------------------------\
659                                     ------------";
660
661            eprintln!("[incremental]");
662            eprintln!("[incremental] DepGraph Statistics");
663            eprintln!("{SEPARATOR}");
664            eprintln!("[incremental]");
665            eprintln!("[incremental] Total Node Count: {}", status.total_node_count);
666            eprintln!("[incremental] Total Edge Count: {}", status.total_edge_count);
667
668            if cfg!(debug_assertions) {
669                eprintln!("[incremental] Total Edge Reads: {total_read_count}");
670                eprintln!("[incremental] Total Duplicate Edge Reads: {total_duplicate_read_count}");
671            }
672
673            eprintln!("[incremental]");
674            eprintln!(
675                "[incremental]  {:<36}| {:<17}| {:<12}| {:<17}|",
676                "Node Kind", "Node Frequency", "Node Count", "Avg. Edge Count"
677            );
678            eprintln!("{SEPARATOR}");
679
680            for stat in stats {
681                let node_kind_ratio =
682                    (100.0 * (stat.node_counter as f64)) / (status.total_node_count as f64);
683                let node_kind_avg_edges = (stat.edge_counter as f64) / (stat.node_counter as f64);
684
685                eprintln!(
686                    "[incremental]  {:<36}|{:>16.1}% |{:>12} |{:>17.1} |",
687                    format!("{:?}", stat.kind),
688                    node_kind_ratio,
689                    stat.node_counter,
690                    node_kind_avg_edges,
691                );
692            }
693
694            eprintln!("{SEPARATOR}");
695            eprintln!("[incremental]");
696        }
697    }
698
699    pub(crate) fn send(
700        &self,
701        node: DepNode,
702        fingerprint: Fingerprint,
703        edges: EdgesVec,
704    ) -> DepNodeIndex {
705        let _prof_timer = self.profiler.generic_activity("incr_comp_encode_dep_graph");
706        let node = NodeInfo { node, fingerprint, edges };
707        self.status.lock().as_mut().unwrap().encode_node(&node, &self.record_graph)
708    }
709
710    /// Encodes a node that was promoted from the previous graph. It reads the information directly from
711    /// the previous dep graph and expects all edges to already have a new dep node index assigned.
712    #[inline]
713    pub(crate) fn send_promoted(
714        &self,
715        prev_index: SerializedDepNodeIndex,
716        prev_index_to_index: &IndexVec<SerializedDepNodeIndex, Option<DepNodeIndex>>,
717    ) -> DepNodeIndex {
718        let _prof_timer = self.profiler.generic_activity("incr_comp_encode_dep_graph");
719        self.status.lock().as_mut().unwrap().encode_promoted_node(
720            prev_index,
721            &self.record_graph,
722            prev_index_to_index,
723        )
724    }
725
726    pub(crate) fn finish(&self) -> FileEncodeResult {
727        let _prof_timer = self.profiler.generic_activity("incr_comp_encode_dep_graph_finish");
728
729        self.status.lock().take().unwrap().finish(&self.profiler)
730    }
731}