Struct DepGraphData 

pub struct DepGraphData {
    current: CurrentDepGraph,
    previous: Arc<SerializedDepGraph>,
    colors: DepNodeColorMap,
    previous_work_products: WorkProductMap,
    dep_node_debug: Lock<FxHashMap<DepNode, String>>,
    debug_loaded_from_disk: Lock<FxHashSet<DepNode>>,
}

Fields

current: CurrentDepGraph

The new encoding of the dependency graph, optimized for red/green tracking. The current field is the dependency graph of only the current compilation session: We don’t merge the previous dep-graph into current one anymore, but we do reference shared data to save space.

previous: Arc<SerializedDepGraph>

The dep-graph from the previous compilation session. It contains all nodes and edges as well as all fingerprints of nodes that have them.

colors: DepNodeColorMap

previous_work_products: WorkProductMap

When we load, there may be .o files, cached MIR, or other such things available to us. If we find that they are not dirty, we load the path to the file storing those work-products here into this map. We can later look for and extract that data.

dep_node_debug: Lock<FxHashMap<DepNode, String>>

debug_loaded_from_disk: Lock<FxHashSet<DepNode>>

Used by incremental compilation tests to assert that a particular query result was decoded from disk (not just marked green)

Implementations

impl DepGraphData

pub fn with_task<'tcx, A: Debug, R>( &self, dep_node: DepNode, tcx: TyCtxt<'tcx>, task_arg: A, task_fn: fn(tcx: TyCtxt<'tcx>, task_arg: A) -> R, hash_result: Option<fn(&mut StableHashingContext<'_>, &R) -> Fingerprint>, ) -> (R, DepNodeIndex)

Starts a new dep-graph task. Dep-graph tasks are specified using a free function (task) and not a closure – this is intentional because we want to exercise tight control over what state they have access to. In particular, we want to prevent implicit ‘leaks’ of tracked state into the task (which could then be read without generating correct edges in the dep-graph – see the rustc dev guide for more details on the dep-graph).

Therefore, the task function takes a TyCtxt, plus exactly one additional argument, task_arg. The additional argument type can be () if no argument is needed, or a tuple if multiple arguments are needed.

pub fn with_anon_task_inner<'tcx, OP, R>( &self, cx: TyCtxt<'tcx>, dep_kind: DepKind, op: OP, ) -> (R, DepNodeIndex)

where OP: FnOnce() -> R,

Executes something within an “anonymous” task, that is, a task the DepNode of which is determined by the list of inputs it read from.

NOTE: this does not actually count as a read of the DepNode here. Using the result of this task without reading the DepNode will result in untracked dependencies which may lead to ICEs as nodes are incorrectly marked green.

FIXME: This could perhaps return a WithDepNode to ensure that the user of this function actually performs the read; we’ll have to see how to make that work with anon in execute_job_incr, though.

fn hash_result_and_alloc_node<'tcx, R>( &self, tcx: TyCtxt<'tcx>, node: DepNode, edges: EdgesVec, result: &R, hash_result: Option<fn(&mut StableHashingContext<'_>, &R) -> Fingerprint>, ) -> DepNodeIndex

Intern the new DepNode with the dependencies up-to-now.

impl DepGraphData

fn assert_dep_node_not_yet_allocated_in_current_session<S: Display>( &self, sess: &Session, dep_node: &DepNode, msg: impl FnOnce() -> S, )

fn node_color(&self, dep_node: &DepNode) -> DepNodeColor

pub fn is_index_green(&self, prev_index: SerializedDepNodeIndex) -> bool

Returns true if the given node has been marked as green during the current compilation session. Used in various assertions

pub fn prev_value_fingerprint_of( &self, prev_index: SerializedDepNodeIndex, ) -> Fingerprint

pub(crate) fn prev_node_of( &self, prev_index: SerializedDepNodeIndex, ) -> &DepNode

pub fn mark_debug_loaded_from_disk(&self, dep_node: DepNode)

fn encode_side_effect<'tcx>( &self, tcx: TyCtxt<'tcx>, side_effect: QuerySideEffect, ) -> DepNodeIndex

This encodes a side effect by creating a node with an unique index and associating it with the node, for use in the next session.

fn force_side_effect<'tcx>( &self, tcx: TyCtxt<'tcx>, prev_index: SerializedDepNodeIndex, )

This forces a side effect node green by running its side effect. prev_index would refer to a node created used encode_side_effect in the previous session.

fn alloc_and_color_node( &self, key: DepNode, edges: EdgesVec, value_fingerprint: Option<Fingerprint>, ) -> DepNodeIndex

fn promote_node_and_deps_to_current( &self, prev_index: SerializedDepNodeIndex, ) -> Option<DepNodeIndex>

impl DepGraphData

pub fn try_mark_green<'tcx>( &self, tcx: TyCtxt<'tcx>, dep_node: &DepNode, ) -> Option<(SerializedDepNodeIndex, DepNodeIndex)>

Try to mark a node index for the node dep_node.

A node will have an index, when it’s already been marked green, or when we can mark it green. This function will mark the current task as a reader of the specified node, when a node index can be found for that node.

fn try_mark_parent_green<'tcx>( &self, tcx: TyCtxt<'tcx>, parent_dep_node_index: SerializedDepNodeIndex, frame: &MarkFrame<'_>, ) -> Option<()>

fn try_mark_previous_green<'tcx>( &self, tcx: TyCtxt<'tcx>, prev_dep_node_index: SerializedDepNodeIndex, frame: Option<&MarkFrame<'_>>, ) -> Option<DepNodeIndex>

Try to mark a dep-node which existed in the previous compilation session as green.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 656 bytes