rustc_mir_transform::coverage::counters::node_flow

Struct NodeFlowData

Help

pub(crate) struct NodeFlowData<Node>where
    Node: Idx,{
    pub supernodes: IndexVec<Node, Node>,
    pub succ_supernodes: IndexVec<Node, Node>,
}

Expand description

Data representing a view of some underlying graph, in which each node’s successors have been merged into a single “supernode”.

The resulting supernodes have no obvious meaning on their own. However, merging successor nodes means that a node’s out-edges can all be combined into a single out-edge, whose flow is the same as the flow (execution count) of its corresponding node in the original graph.

With all node flows now in the original graph now represented as edge flows in the merged graph, it becomes possible to analyze the original node flows using techniques for analyzing edge flows.

Fields§

§supernodes: IndexVec<Node, Node>

Maps each node to the supernode that contains it, indicated by some arbitrary “root” node that is part of that supernode.

§succ_supernodes: IndexVec<Node, Node>

For each node, stores the single supernode that all of its successors have been merged into.

(Note that each node in a supernode can potentially have a different successor supernode from its peers.)

Struct NodeFlowDataCopy item path

Fields§

Trait Implementations§

impl<Node> Clone for NodeFlowData<Node>where Node: Clone + Idx,

fn clone(&self) -> NodeFlowData<Node>

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

impl<Node> Debug for NodeFlowData<Node>where Node: Debug + Idx,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<Node, __D> Decodable<__D> for NodeFlowData<Node>where Node: Idx, __D: TyDecoder, IndexVec<Node, Node>: Decodable<__D>,

fn decode(__decoder: &mut __D) -> NodeFlowData<Node>

impl<Node, __E> Encodable<__E> for NodeFlowData<Node>where Node: Idx, __E: TyEncoder, IndexVec<Node, Node>: Encodable<__E>,

fn encode(&self, __encoder: &mut __E)

impl<Node> Hash for NodeFlowData<Node>where Node: Hash + Idx,

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

impl<'__ctx, Node> HashStable<StableHashingContext<'__ctx>> for NodeFlowData<Node>where Node: Idx + HashStable<StableHashingContext<'__ctx>>,

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<SipHasher128>, )

Auto Trait Implementations§

impl<Node> DynSend for NodeFlowData<Node>where Node: DynSend,

impl<Node> DynSync for NodeFlowData<Node>where Node: DynSync,

impl<Node> Freeze for NodeFlowData<Node>

impl<Node> RefUnwindSafe for NodeFlowData<Node>where Node: RefUnwindSafe,

impl<Node> Send for NodeFlowData<Node>where Node: Send,

impl<Node> Sync for NodeFlowData<Node>where Node: Sync,

impl<Node> Unpin for NodeFlowData<Node>where Node: Unpin,

impl<Node> UnwindSafe for NodeFlowData<Node>where Node: UnwindSafe,

Blanket Implementations§

impl<T> Aligned for T

const ALIGN: Alignment

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dst: *mut u8)

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

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

type Output = R

impl<Tcx, T> DepNodeParams<Tcx> for Twhere Tcx: DepContext, T: for<'a> HashStable<StableHashingContext<'a>> + Debug,

default fn fingerprint_style() -> FingerprintStyle

default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint

default fn to_debug_str(&self, _: Tcx) -> String

default fn recover(_: Tcx, _: &DepNode) -> Option<T>

impl<T> Filterable for T

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

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

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

fn in_current_span(self) -> Instrumented<Self>

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

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<P> IntoQueryParam<P> for P

fn into_query_param(self) -> P

impl<T> MaybeResult<T> for T

type Error = !

fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

impl<T> Pointable for T

const ALIGN: usize

type Init = T

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

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

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

unsafe fn drop(ptr: usize)

impl<T> Same for T

type Output = T

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

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

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

type Error = Infallible

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

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

Struct NodeFlowData

impl<Node> Clone for NodeFlowData<Node>
where Node: Clone + Idx,

impl<Node> Debug for NodeFlowData<Node>
where Node: Debug + Idx,

impl<Node, D> Decodable<D> for NodeFlowData<Node>
where Node: Idx, D: TyDecoder, IndexVec<Node, Node>: Decodable<D>,

fn decode(decoder: &mut D) -> NodeFlowData<Node>

impl<Node, E> Encodable<E> for NodeFlowData<Node>
where Node: Idx, E: TyEncoder, IndexVec<Node, Node>: Encodable<E>,

fn encode(&self, encoder: &mut E)

impl<Node> Hash for NodeFlowData<Node>
where Node: Hash + Idx,

fn hash<H>(&self, state: &mut H)
where __H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

impl<'ctx, Node> HashStable<StableHashingContext<'ctx>> for NodeFlowData<Node>
where Node: Idx + HashStable<StableHashingContext<'__ctx>>,

fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher<SipHasher128>, )

impl<Node> DynSend for NodeFlowData<Node>
where Node: DynSend,

impl<Node> DynSync for NodeFlowData<Node>
where Node: DynSync,

impl<Node> RefUnwindSafe for NodeFlowData<Node>
where Node: RefUnwindSafe,

impl<Node> Send for NodeFlowData<Node>
where Node: Send,

impl<Node> Sync for NodeFlowData<Node>
where Node: Sync,

impl<Node> Unpin for NodeFlowData<Node>
where Node: Unpin,

impl<Node> UnwindSafe for NodeFlowData<Node>
where Node: UnwindSafe,

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

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

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

impl<T> CloneToUninit for T
where T: Clone,

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

impl<Tcx, T> DepNodeParams<Tcx> for T
where Tcx: DepContext, T: for<'a> HashStable<StableHashingContext<'a>> + Debug,

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

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

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

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

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

impl<I, T, U> Upcast<I, U> for T
where U: UpcastFrom<I, T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

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

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

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

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

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

impl<T> MaybeSendSync for T
where T: Send + Sync,