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

Fields§

§current: CurrentDepGraph<D>

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: 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§processed_side_effects: Lock<FxHashSet<DepNodeIndex>>§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§

source§

impl<D: Deps> DepGraphData<D>

source

pub fn with_task<Ctxt: HasDepContext<Deps = D>, A: Debug, R>( &self, key: DepNode, cx: Ctxt, arg: A, task: fn(_: Ctxt, _: 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). 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.
source

pub fn with_anon_task<Tcx: DepContext<Deps = D>, OP, R>( &self, cx: 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.

source§

impl<D: Deps> DepGraphData<D>

source

pub fn dep_node_index_of_opt(&self, dep_node: &DepNode) -> Option<DepNodeIndex>

source

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

source

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

source

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

source

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

source

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

source

pub fn mark_debug_loaded_from_disk(&self, dep_node: DepNode)

source§

impl<D: Deps> DepGraphData<D>

source

pub fn try_mark_green<Qcx: QueryContext<Deps = D>>( &self, qcx: Qcx, 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.

source

fn try_mark_parent_green<Qcx: QueryContext<Deps = D>>( &self, qcx: Qcx, parent_dep_node_index: SerializedDepNodeIndex, dep_node: &DepNode, frame: Option<&MarkFrame<'_>> ) -> Option<()>

source

fn try_mark_previous_green<Qcx: QueryContext<Deps = D>>( &self, qcx: Qcx, prev_dep_node_index: SerializedDepNodeIndex, dep_node: &DepNode, frame: Option<&MarkFrame<'_>> ) -> Option<DepNodeIndex>

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

source

fn emit_side_effects<Qcx: QueryContext<Deps = D>>( &self, qcx: Qcx, dep_node_index: DepNodeIndex, side_effects: QuerySideEffects )

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

Auto Trait Implementations§

§

impl<D> !RefUnwindSafe for DepGraphData<D>

§

impl<D> Send for DepGraphData<D>where D: Send,

§

impl<D> !Sync for DepGraphData<D>

§

impl<D> Unpin for DepGraphData<D>where D: Unpin,

§

impl<D> !UnwindSafe for DepGraphData<D>

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<Tcx, T> Value<Tcx> for Twhere Tcx: DepContext,

source§

default fn from_cycle_error( tcx: Tcx, cycle: &[QueryInfo], _guar: ErrorGuaranteed ) -> T

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: 776 bytes