# Struct rustc_query_system::dep_graph::graph::DepGraph

source ·

    pub struct DepGraph<D: Deps> {
        data: Option<Lrc<DepGraphData<D>>>,
        virtual_dep_node_index: Lrc<AtomicU32>,
    }

## Fields§

§`data: Option<Lrc<DepGraphData<D>>>`§`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§

source§

### impl<D: Deps> DepGraph<D>

source

#### pub fn new( profiler: &SelfProfilerRef, prev_graph: Arc<SerializedDepGraph>, prev_work_products: WorkProductMap, encoder: FileEncoder, record_graph: bool, record_stats: bool ) -> DepGraph<D>

source

#### pub fn new_disabled() -> DepGraph<D>

source

#### pub(crate) fn data(&self) -> Option<&DepGraphData<D>>

source

#### pub fn is_fully_enabled(&self) -> bool

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

source

#### pub fn with_query(&self, f: impl Fn(&DepGraphQuery))

source

#### pub fn assert_ignored(&self)

source

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

source

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

Used to wrap the deserialization of a query result from disk, This method enforces that no new `DepNodes` are created during query result deserialization.

Enforcing this makes the query dep graph simpler - all nodes must be created during the query execution, and should be created from inside the ‘body’ of a query (the implementation provided by a particular compiler crate).

Consider the case of three queries `A`, `B`, and `C`, where `A` invokes `B` and `B` invokes `C`:

`A -> B -> C`

Suppose that decoding the result of query `B` required re-computing the query `C`. If we did not create a fresh `TaskDeps` when decoding `B`, we would still be using the `TaskDeps` for query `A` (if we needed to re-execute `A`). This would cause us to create a new edge `A -> C`. If this edge did not previously exist in the `DepGraph`, then we could end up with a different `DepGraph` at the end of compilation, even if there were no meaningful changes to the overall program (e.g. a newline was added). In addition, this edge might cause a subsequent compilation run to try to force `C` before marking other necessary nodes green. If `C` did not exist in the new compilation session, then we could get an ICE. Normally, we would have tried (and failed) to mark some other query green (e.g. `item_children`) which was used to obtain `C`, which would prevent us from ever trying to force a nonexistent `D`.

It might be possible to enforce that all `DepNode`s read during deserialization already exist in the previous `DepGraph`. In the above example, we would invoke `D` during the deserialization of `B`. Since we correctly create a new `TaskDeps` from the decoding of `B`, this would result in an edge `B -> D`. If that edge already existed (with the same `DepPathHash`es), then it should be correct to allow the invocation of the query to proceed during deserialization of a query result. We would merely assert that the dep-graph fragment that would have been added by invoking `C` while decoding `B` is equivalent to the dep-graph fragment that we already instantiated for B (at the point where we successfully marked B as green).

However, this would require additional complexity in the query infrastructure, and is not currently needed by the decoding of any query results. Should the need arise in the future, we should consider extending the query system with this functionality.

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)

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,

source§

### impl<D: Deps> DepGraph<D>

source

#### pub fn read_index(&self, dep_node_index: DepNodeIndex)

source

#### pub fn with_feed_task<Ctxt: DepContext<Deps = D>, A: Debug, R: Debug>( &self, node: DepNode, cx: Ctxt, key: A, result: &R, hash_result: Option<fn(_: &mut StableHashingContext<'_>, _: &R) -> Fingerprint> ) -> DepNodeIndex

Create a node when we force-feed a value into the query cache. This is used to remove cycles during type-checking const generic parameters.

As usual in the query system, we consider the current state of the calling query only depends on the list of dependencies up to now. As a consequence, the value that this query gives us can only depend on those dependencies too. Therefore, it is sound to use the current dependency set for the created node.

During replay, the order of the nodes is relevant in the dependency graph. So the unchanged replay will mark the caller query before trying to mark this one. If there is a change to report, the caller query will be re-executed before this one.

FIXME: If the code is changed enough for this node to be marked before requiring the caller’s node, we suppose that those changes will be enough to mark this node red and force a recomputation using the “normal” way.

source§

### impl<D: Deps> DepGraph<D>

source

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

source

#### 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.

source

#### pub fn previous_work_products(&self) -> &WorkProductMap

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

source

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

source

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

source

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

source

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

source

#### pub fn try_mark_green<Qcx: QueryContext<Deps = D>>( &self, qcx: Qcx, dep_node: &DepNode ) -> Option<(SerializedDepNodeIndex, DepNodeIndex)>

source§

### impl<D: Deps> DepGraph<D>

source

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

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

source

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

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

source

#### pub fn exec_cache_promotions<Tcx: DepContext>(&self, tcx: Tcx)

This method loads all on-disk cacheable query results into memory, so they can be written out to the new cache file again. Most query results will already be in memory but in the case where we marked something as green but then did not need the value, that value will never have been loaded from disk.

This method will only load queries that will end up in the disk cache. Other queries will not be executed.

source

#### pub fn print_incremental_info(&self)

source

#### pub fn finish_encoding(&self) -> FileEncodeResult

source

#### pub(crate) fn next_virtual_depnode_index(&self) -> DepNodeIndex

## Trait Implementations§

source§

### impl<D: Clone + Deps> Clone for DepGraph<D>

source§

#### fn clone(&self) -> DepGraph<D>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more

## Auto Trait Implementations§

§

### impl<D> DynSend for DepGraph<D>
where D: DynSend,

§

### impl<D> DynSync for DepGraph<D>
where D: DynSend,

§

### impl<D> Freeze for DepGraph<D>

§

### impl<D> !RefUnwindSafe for DepGraph<D>

§

### impl<D> !Send for DepGraph<D>

§

### impl<D> !Sync for DepGraph<D>

§

### impl<D> Unpin for DepGraph<D>

§

### impl<D> !UnwindSafe for DepGraph<D>

## Blanket Implementations§

source§

### impl<T> Aligned for T

source§

#### const ALIGN: Alignment = _

Alignment of `Self`.
source§

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

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for T
where T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

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

Mutably borrows from an owned value. Read more
source§

### impl<T, R> CollectAndApply<T, R> for T

source§

#### fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to `f(&iter.collect::<Vec<_>>())`.

§

#### type Output = R

source§

### impl<T> Filterable for T

source§

#### fn filterable( self, filter_name: &'static str ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

Creates a filterable data provider with the given name for debugging. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T> Instrument for T

source§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
source§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
source§

### impl<T, U> Into<U> for T
where 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> Pointable for T

source§

#### const ALIGN: usize = _

The alignment of pointer.
§

#### type Init = T

The type for initializers.
source§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
source§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
source§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
source§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

### impl<T> Same for T

§

#### type Output = T

Should always be `Self`
source§

### impl<T> ToOwned for T
where T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<T, U> TryFrom<U> for T
where 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 T
where 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<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

#### fn vzip(self) -> V

source§

### impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

source§

#### default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed ) -> T

source§

### impl<T> WithSubscriber for T

source§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
source§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
source§

### impl<'a, T> Captures<'a> for T
where T: ?Sized,

source§

### impl<T> ErasedDestructor for T
where T: 'static,

## 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: 16 bytes