Struct Vm

pub struct Vm {
    pub pc: usize,
    pub stack: Stack,
    pub memory: Memory,
    pub parent_memory: Vec<Arc<Memory>>,
    pub halt: bool,
    pub repeat: Repeat,
    pub cache: Arc<LazyCache>,
}

The operation execution state of the VM.

Fields

pc: usize

The program counter, i.e. index of the current operation within the program.

stack: Stack

The stack machine.

memory: Memory

The memory for temporary storage of words.

parent_memory: Vec<Arc<Memory>>

The stack of parent Memorys.

This is empty at the beginning of execution, but is pushed to each time we enter a [Compute] op context with the parent’s Memory.

This can also be used to observe the Compute op depth.

halt: bool

Propagation of Halt encountered in compute program.

repeat: Repeat

The repeat stack.

cache: Arc<LazyCache>

Lazily cached data for the VM.

Implementations

impl Vm

pub fn exec_ops<S>( &mut self, ops: &[Op], access: Access, state_reads: &S, op_gas_cost: &impl OpGasCost, gas_limit: GasLimit, ) -> Result<Gas, ExecError<S::Error>>

where S: StateReads,

Execute the given operations from the current state of the VM.

This function uses synchronous state reading and is intended for use with in-memory state implementations.

Upon reaching a Halt operation or reaching the end of the operation sequence, returns the gas spent and the Vm will be left in the resulting state.

This is a wrapper around Vm::exec that expects operation access in the form of a &[Op].

If memory bloat is a concern, consider using the Vm::exec_bytecode method which allows for providing a more compact representation of the operations in the form of mapped bytecode.

pub fn exec_bytecode<S, B>( &mut self, bytecode_mapped: &BytecodeMapped<B>, access: Access, state_reads: &S, op_gas_cost: &impl OpGasCost, gas_limit: GasLimit, ) -> Result<Gas, ExecError<S::Error>>

where S: StateReads, B: Deref<Target = [u8]> + Send + Sync,

Execute the given mapped bytecode from the current state of the VM.

This function uses synchronous state reading and is intended for use with in-memory state implementations.

Upon reaching a Halt operation or reaching the end of the operation sequence, returns the gas spent and the Vm will be left in the resulting state.

This is a wrapper around Vm::exec that expects operation access in the form of &BytecodeMapped.

This can be a more memory efficient alternative to Vm::exec_ops due to the compact representation of operations in the form of bytecode and indices.

pub fn exec<S, OA>( &mut self, access: Access, state_reads: &S, op_access: OA, op_gas_cost: &impl OpGasCost, gas_limit: GasLimit, ) -> Result<Gas, ExecError<S::Error>>

where S: StateReads, OA: OpAccess<Op = Op>, OA::Error: Into<OpError<S::Error>>,

Execute the given operations synchronously from the current state of the VM.

This function uses synchronous state reading and is intended for use with in-memory state implementations.

Upon reaching a Halt operation or reaching the end of the operation sequence, returns the gas spent and the Vm will be left in the resulting state.

pub fn eval_ops<S>( &mut self, ops: &[Op], access: Access, state: &S, op_gas_cost: &impl OpGasCost, gas_limit: GasLimit, ) -> EvalResult<bool, S::Error>

where S: StateReads,

Evaluate a slice of synchronous operations and return their boolean result.

This is the same as [exec_ops], but retrieves the boolean result from the resulting stack.

pub fn eval<OA, S>( &mut self, op_access: OA, access: Access, state: &S, op_gas_cost: &impl OpGasCost, gas_limit: GasLimit, ) -> EvalResult<bool, S::Error>

where OA: OpAccess<Op = Op>, OA::Error: Into<OpError<S::Error>>, S: StateReads,

This is the same as [exec], but retrieves the boolean result from the resulting stack.

Trait Implementations

impl Clone for Vm

fn clone(&self) -> Vm

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Vm

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

Formats the value using the given formatter.

impl Default for Vm

fn default() -> Vm

Returns the “default value” for a type.

impl PartialEq for Vm

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Vm