Enum Continuation 

pub enum Continuation<F> {
    StartNode(MastNodeId),
    FinishJoin(MastNodeId),
    FinishSplit(MastNodeId),
    FinishLoop(MastNodeId),
    FinishCall(MastNodeId),
    FinishDyn(MastNodeId),
    ResumeBasicBlock {
        node_id: MastNodeId,
        batch_index: usize,
        op_idx_in_batch: usize,
    },
    Respan {
        node_id: MastNodeId,
        batch_index: usize,
    },
    FinishBasicBlock(MastNodeId),
    EnterForest {
        forest: F,
        package_debug_info: Option<Arc<PackageDebugInfo>>,
        inline_context_depth: usize,
    },
}

Represents a unit of work in the continuation stack.

This enum defines the different types of continuations that can be performed on MAST nodes during program execution.

The type parameter F is the representation of a MAST forest carried by the Continuation::EnterForest variant. For live execution this is Arc<MastForest>; for the snapshotted continuation stack inside a trace fragment it is a usize index into the mast_forest_store of the trace generation context.

Variants

StartNode(MastNodeId)

Start processing a node in the MAST forest.

FinishJoin(MastNodeId)

Process the finish phase of a Join node.

FinishSplit(MastNodeId)

Process the finish phase of a Split node.

FinishLoop(MastNodeId)

Process the finish phase of a Loop node.

Reached after the loop body has finished executing. Inspects the condition the body left on top of the stack and either fires REPEAT (re-enter the body) or END (exit the loop). Loop bodies are entered unconditionally — a while.true source construct is desugared into a SPLIT that wraps the LOOP, so the LOOP itself sees a do-while body.

FinishCall(MastNodeId)

Process the finish phase of a Call node.

FinishDyn(MastNodeId)

Process the finish phase of a Dyn node.

ResumeBasicBlock

Resume execution at the specified operation of the specified batch in the given basic block node.

Fields

node_id: MastNodeId

batch_index: usize

op_idx_in_batch: usize

Respan

Resume execution at the RESPAN operation before the specific batch within a basic block node.

Fields

node_id: MastNodeId

batch_index: usize

FinishBasicBlock(MastNodeId)

Process the finish phase of a basic block node.

This corresponds to incrementing the clock to account for the inserted END operation.

EnterForest

Enter a new MAST forest, where all subsequent MastNodeIds will be relative to this forest.

When we encounter an ExternalNode, we enter the corresponding MAST forest directly, and push an EnterForest continuation to restore the previous forest when done.

Fields

forest: F

package_debug_info: Option<Arc<PackageDebugInfo>>

inline_context_depth: usize

Inline-context stack depth to restore when returning to this forest.

Implementations

impl<F> Continuation<F>

pub fn increments_clk(&self) -> bool

Returns true if executing this continuation increments the processor clock, and false otherwise.

pub fn exec_node(&self) -> Option<MastNodeId>

Trait Implementations

impl<F: Clone> Clone for Continuation<F>

fn clone(&self) -> Continuation<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug> Debug for Continuation<F>

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

Formats the value using the given formatter.

impl Deserializable for Continuation<MastForestId>

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

fn read_from_bytes_with_budget( bytes: &[u8], budget: usize, ) -> Result<Self, DeserializationError>

Deserializes Self from bytes with a byte budget limit.

impl<F: Eq> Eq for Continuation<F>

impl<F: PartialEq> PartialEq for Continuation<F>

fn eq(&self, other: &Continuation<F>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serializable for Continuation<MastForestId>

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl<F: PartialEq> StructuralPartialEq for Continuation<F>