pub(crate) struct DepGraphData<D: Deps> {
current: CurrentDepGraph<D>,
previous: Arc<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: 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
§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>
impl<D: Deps> DepGraphData<D>
sourcepub(crate) 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)
pub(crate) 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 thearg
parameter. - If you need 3+ arguments, use a tuple for the
arg
parameter.
sourcepub(crate) fn with_anon_task<Tcx: DepContext<Deps = D>, OP, R>(
&self,
cx: Tcx,
dep_kind: DepKind,
op: OP,
) -> (R, DepNodeIndex)where
OP: FnOnce() -> R,
pub(crate) 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>
impl<D: Deps> DepGraphData<D>
fn dep_node_index_of_opt(&self, dep_node: &DepNode) -> Option<DepNodeIndex>
fn dep_node_exists(&self, dep_node: &DepNode) -> bool
fn node_color(&self, dep_node: &DepNode) -> Option<DepNodeColor>
sourcepub(crate) fn is_index_green(&self, prev_index: SerializedDepNodeIndex) -> bool
pub(crate) 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(crate) fn prev_fingerprint_of( &self, prev_index: SerializedDepNodeIndex, ) -> Fingerprint
pub(crate) fn prev_node_of(&self, prev_index: SerializedDepNodeIndex) -> DepNode
pub(crate) fn mark_debug_loaded_from_disk(&self, dep_node: DepNode)
source§impl<D: Deps> DepGraphData<D>
impl<D: Deps> DepGraphData<D>
sourcepub(crate) fn try_mark_green<Qcx: QueryContext<Deps = D>>(
&self,
qcx: Qcx,
dep_node: &DepNode,
) -> Option<(SerializedDepNodeIndex, DepNodeIndex)>
pub(crate) 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.
fn try_mark_parent_green<Qcx: QueryContext<Deps = D>>( &self, qcx: Qcx, parent_dep_node_index: SerializedDepNodeIndex, frame: Option<&MarkFrame<'_>>, ) -> Option<()>
sourcefn try_mark_previous_green<Qcx: QueryContext<Deps = D>>(
&self,
qcx: Qcx,
prev_dep_node_index: SerializedDepNodeIndex,
dep_node: &DepNode,
frame: Option<&MarkFrame<'_>>,
) -> Option<DepNodeIndex>
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.
sourcefn emit_side_effects<Qcx: QueryContext<Deps = D>>(
&self,
qcx: Qcx,
dep_node_index: DepNodeIndex,
side_effects: QuerySideEffects,
)
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> !Freeze for DepGraphData<D>
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> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
source§impl<T> Filterable for T
impl<T> Filterable for T
source§fn filterable(
self,
filter_name: &'static str,
) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
fn filterable( self, filter_name: &'static str, ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
source§impl<I, T> UpcastFrom<I, T> for T
impl<I, T> UpcastFrom<I, T> for T
fn upcast_from(from: T, _tcx: I) -> T
source§impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T
source§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
source§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
source§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
impl<T> ErasedDestructor for Twhere
T: 'static,
impl<T> MaybeSendSync for 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: 696 bytes