Struct MemoryChannelState 

pub struct MemoryChannelState {
    pub coarse: WrittenSpacesState,
    pub precise: Option<Footprint>,
    pub materialized: Option<MemoryInterfaceMap>,
}

The memory-channel component of a function’s effects: the coarse written-space tri-state plus the precise RAM Footprint the same solve derived.

The two components are independently ⊤: coarse is deliberately laxer, so a function whose footprint defies classification (precise == None) usually still has a bounded space set.

Fields

coarse: WrittenSpacesState

The coarse set of non-register spaces this function may (transitively) write. Subsumes the retired written_spaces + written_spaces_stamped signature pair.

precise: Option<Footprint>

The exhaustive outward memory footprint this function may touch, or None for ⊤ — inexpressible in the lattice (an unclassifiable access, a non-lockstep interface, budget saturation, or an unrebasable call edge).

Persisted so that a memory-channel effect delta can compare addresses, not merely space granularity: two solves that both write {ram} at different addresses must not compare Equal, since Equal is the one verdict that licenses stopping invalidation propagation.

#[serde(default)] (→ None, i.e. ⊤) so snapshots written before the footprint was persisted still load, conservatively.

materialized: Option<MemoryInterfaceMap>

The materialized memory interface: where each by-value memory input is bound from and each write-set output replayed to, once the RAM channel has functionalized this function. None while the memory channel is not materialized (the default and, today, the only state any pass sets).

The memory analogue of RegisterChannelState::Materialized. Unlike the register channel this is a field rather than a lattice state, because coarse and precise are independently ⊤ and materialization is orthogonal to both.

#[serde(default)] (→ None) so snapshots predating the memory interface load unchanged.

Implementations

impl MemoryChannelState

pub fn materialized(&self) -> Option<&MemoryInterfaceMap>

The materialized memory interface, if the memory channel has been materialized.

Trait Implementations

impl Clone for MemoryChannelState

fn clone(&self) -> MemoryChannelState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryChannelState

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

Formats the value using the given formatter.

impl Default for MemoryChannelState

fn default() -> MemoryChannelState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MemoryChannelState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for MemoryChannelState

impl PartialEq for MemoryChannelState

fn eq(&self, other: &MemoryChannelState) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for MemoryChannelState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MemoryChannelState