Struct rustc_query_system::dep_graph::graph::DepGraph

pub struct DepGraph<K: DepKind> {
    data: Option<Lrc<DepGraphData<K>>>,
    virtual_dep_node_index: Lrc<AtomicU32>,
}

Fields

data: Option<Lrc<DepGraphData<K>>>

virtual_dep_node_index: Lrc<AtomicU32>

This field is used for assigning DepNodeIndices when running in non-incremental mode. Even in non-incremental mode we make sure that each task has a DepNodeIndex that uniquely identifies it. This unique ID is used for self-profiling.

Implementations

impl<K: DepKind> DepGraph<K>

pub fn new(
    prev_graph: PreviousDepGraph<K>,
    prev_work_products: FxHashMap<WorkProductId, WorkProduct>
) -> DepGraph<K>

pub fn new_disabled() -> DepGraph<K>

pub fn is_fully_enabled(&self) -> bool

Returns true if we are actually building the full dep-graph, and false otherwise.

pub fn query(&self) -> DepGraphQuery<K>

pub fn assert_ignored(&self)

pub fn with_ignore<OP, R>(&self, op: OP) -> R where
    OP: FnOnce() -> R, 

pub fn with_task<Ctxt: DepContext<DepKind = K>, A, R>(
    &self,
    key: DepNode<K>,
    cx: Ctxt,
    arg: A,
    task: fn(_: Ctxt, _: A) -> R,
    hash_result: impl FnOnce(&mut Ctxt::StableHashingContext, &R) -> Option<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). To this end, the task function gets exactly two pieces of state: the context cx and an argument arg. Both of these bits of state must be of some type that implements DepGraphSafe and hence does not leak.

The choice of two arguments is not fundamental. One argument would work just as well, since multiple values can be collected using tuples. However, using two arguments works out to be quite convenient, since it is common to need a context (cx) and some argument (e.g., a DefId identifying what item to process).

For cases where you need some other number of arguments:

• If you only need one argument, just use () for the arg parameter.
• If you need 3+ arguments, use a tuple for the arg parameter.

pub(in dep_graph::graph) fn with_task_impl<Ctxt: DepContext<DepKind = K>, A, R>(
    &self,
    key: DepNode<K>,
    cx: Ctxt,
    arg: A,
    no_tcx: bool,
    task: fn(_: Ctxt, _: A) -> R,
    create_task: fn(_: DepNode<K>) -> Option<TaskDeps<K>>,
    finish_task_and_alloc_depnode: fn(_: &CurrentDepGraph<K>, _: DepNode<K>, _: Fingerprint, _: Option<TaskDeps<K>>) -> DepNodeIndex,
    hash_result: impl FnOnce(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>
) -> (R, DepNodeIndex)

pub fn with_anon_task<OP, R>(&self, dep_kind: K, 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.

pub fn with_eval_always_task<Ctxt: DepContext<DepKind = K>, A, R>(
    &self,
    key: DepNode<K>,
    cx: Ctxt,
    arg: A,
    task: fn(_: Ctxt, _: A) -> R,
    hash_result: impl FnOnce(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>
) -> (R, DepNodeIndex)

Executes something within an "eval-always" task which is a task that runs whenever anything changes.

pub fn read(&self, v: DepNode<K>)

pub fn read_index(&self, dep_node_index: DepNodeIndex)

pub fn dep_node_index_of(&self, dep_node: &DepNode<K>) -> DepNodeIndex

pub fn dep_node_exists(&self, dep_node: &DepNode<K>) -> bool

pub fn fingerprint_of(&self, dep_node_index: DepNodeIndex) -> Fingerprint

pub fn prev_fingerprint_of(&self, dep_node: &DepNode<K>) -> Option<Fingerprint>

pub fn previous_work_product(&self, v: &WorkProductId) -> Option<WorkProduct>

Checks whether a previous work product exists for v and, if so, return the path that leads to it. Used to skip doing work.

pub fn previous_work_products(&self) -> &FxHashMap<WorkProductId, WorkProduct>

Access the map of work-products created during the cached run. Only used during saving of the dep-graph.

pub fn register_dep_node_debug_str<F>(
    &self,
    dep_node: DepNode<K>,
    debug_str_gen: F
) where
    F: FnOnce() -> String, 

pub fn dep_node_debug_str(&self, dep_node: DepNode<K>) -> Option<String>

pub fn edge_deduplication_data(&self) -> Option<(u64, u64)>

pub fn serialize(&self) -> SerializedDepGraph<K>

pub fn node_color(&self, dep_node: &DepNode<K>) -> Option<DepNodeColor>

pub fn try_mark_green_and_read<Ctxt: DepContext<DepKind = K>>(
    &self,
    tcx: Ctxt,
    dep_node: &DepNode<K>
) -> Option<(SerializedDepNodeIndex, DepNodeIndex)>

Try to read 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.

pub fn try_mark_green<Ctxt: DepContext<DepKind = K>>(
    &self,
    tcx: Ctxt,
    dep_node: &DepNode<K>
) -> Option<(SerializedDepNodeIndex, DepNodeIndex)>

pub(in dep_graph::graph) fn try_mark_previous_green<Ctxt: DepContext<DepKind = K>>(
    &self,
    tcx: Ctxt,
    data: &DepGraphData<K>,
    prev_dep_node_index: SerializedDepNodeIndex,
    dep_node: &DepNode<K>
) -> Option<DepNodeIndex>

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

pub(in dep_graph::graph) fn emit_diagnostics<Ctxt: DepContext<DepKind = K>>(
    &self,
    tcx: Ctxt,
    data: &DepGraphData<K>,
    dep_node_index: DepNodeIndex,
    prev_dep_node_index: SerializedDepNodeIndex,
    diagnostics: Vec<Diagnostic>
)

Atomically emits some loaded diagnostics. This may be called concurrently on multiple threads for the same dep node.

pub fn is_green(&self, dep_node: &DepNode<K>) -> bool

pub fn exec_cache_promotions<Ctxt: DepContext<DepKind = K>>(&self, tcx: Ctxt)

pub(in dep_graph::graph) fn next_virtual_depnode_index(
    &self
) -> DepNodeIndex

Trait Implementations

impl<K: Clone + DepKind> Clone for DepGraph<K>

pub fn clone(&self) -> DepGraph<K>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.