Type Alias DepGraph

pub type DepGraph = DepGraph<DepsType>;

Aliased Type

struct DepGraph { /* private fields */ }

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

Implementations

impl<D> DepGraph<D>

where D: Deps,

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

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

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

where Tcx: DepContext,

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.

pub fn print_incremental_info(&self)

pub fn finish_encoding(&self) -> Result<usize, (PathBuf, Error)>

impl<D> DepGraph<D>

where D: Deps,

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

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) -> &UnordMap<WorkProductId, WorkProduct>

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

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

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

pub fn try_mark_green<Qcx>( &self, qcx: Qcx, dep_node: &DepNode, ) -> Option<(SerializedDepNodeIndex, DepNodeIndex)>

where Qcx: QueryContext<Deps = D>,

impl<D> DepGraph<D>

where D: Deps,

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

pub fn new_disabled() -> DepGraph<D>

pub fn is_fully_enabled(&self) -> bool

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

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

pub fn assert_ignored(&self)

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

where OP: FnOnce() -> R,

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 DepNodes 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 DepPathHashes), 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.

pub fn with_task<Ctxt, A, R>( &self, key: DepNode, cx: Ctxt, arg: A, task: fn(_: Ctxt, _: A) -> R, hash_result: Option<fn(_: &mut StableHashingContext<'_>, _: &R) -> Fingerprint>, ) -> (R, DepNodeIndex)

where Ctxt: HasDepContext<Deps = D>, A: Debug,

pub fn with_anon_task<Tcx, OP, R>( &self, cx: Tcx, dep_kind: DepKind, op: OP, ) -> (R, DepNodeIndex)

where Tcx: DepContext<Deps = D>, OP: FnOnce() -> R,

impl<D> DepGraph<D>

where D: Deps,

pub fn read_index(&self, dep_node_index: DepNodeIndex)

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

where Ctxt: DepContext<Deps = D>, A: Debug, R: Debug,

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.

Trait Implementations

impl<D> Clone for DepGraph<D>

where D: Clone + Deps,

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

Returns a copy of the value.

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

Performs copy-assignment from source.