Struct Machine 

pub struct Machine {
    pub prog: Program,
    pub closures: ClosureStorage,
    pub heap: HeapStorage,
    pub ext_fun_table: Vec<(Symbol, ExtFunType)>,
    pub ext_cls_table: Vec<(Symbol, ExtClsType)>,
    pub arrays: ArrayStorage,
    /* private fields */
}

The virtual machine that executes mimium bytecode programs.

A Machine holds the compiled Program, value stack and all live closures. External functions and closures installed from plugins are also managed here.

Fields

prog: Program

closures: ClosureStorage

heap: HeapStorage

ext_fun_table: Vec<(Symbol, ExtFunType)>

ext_cls_table: Vec<(Symbol, ExtClsType)>

arrays: ArrayStorage

Implementations

impl Machine

pub fn drop_closure(&mut self, id: ClosureIdx)

Drop a closure by decrementing its reference count. When refcount reaches 0, recursively drops captured closures and removes the closure.

pub fn new( prog: Program, extfns: impl Iterator<Item = ExtFunInfo>, extcls: impl Iterator<Item = Box<dyn MachineFunction>>, ) -> Self

Create a new VM from a compiled Program and external functions.

pub fn new_resume(&self, prog: Program) -> Self

Create a new VM instance with the new program, preserving the current state as possible.

pub fn clear_stack(&mut self)

pub fn get_stack(&self, offset: i64) -> RawVal

pub fn get_stack_range( &self, offset: i64, word_size: TypeSize, ) -> (Range<usize>, &[RawVal])

pub fn get_stack_range_mut( &mut self, offset: i64, word_size: TypeSize, ) -> (Range<usize>, &mut [RawVal])

pub fn set_stack(&mut self, offset: i64, v: RawVal)

pub fn set_stack_range(&mut self, offset: i64, vs: &[RawVal])

pub fn get_top_n(&self, n: usize) -> &[RawVal]

pub fn get_current_ext_call_nargs(&self) -> u8

Number of argument words for the currently executing external function call.

pub fn get_current_ext_call_idx(&self) -> Option<usize>

pub fn get_closure_idx_from_heap(&self, heap_idx: HeapIdx) -> ClosureIdx

Extract the ClosureIdx stored inside a heap-allocated closure object.

During the migration period the heap object wraps a single ClosureIdx in data[0]. External callers (e.g. the scheduler plugin) can use this to obtain the underlying closure index from a HeapIdx value that lives on the VM stack.

pub fn get_open_upvalue( &self, upper_base: usize, ov: OpenUpValue, ) -> (Range<usize>, &[RawVal])

pub fn get_closure(&self, idx: ClosureIdx) -> &Closure

pub fn get_as<T>(v: RawVal) -> T

pub fn get_as_array<T>(v: &[RawVal]) -> &[T]

pub fn to_value<T>(v: T) -> RawVal

pub fn wrap_extern_cls(&mut self, extcls: ExtClsInfo) -> ClosureIdx

This API is used for defining higher-order external function that returns some external rust closure. Because the native closure cannot be called with CallCls directly, the vm appends an additional function the program, that wraps external closure call with an internal closure.

pub fn execute( &mut self, func_i: usize, cls_i: Option<ClosureIdx>, ) -> ReturnCode

Execute a function within the VM.

func_i is an index into the program’s function table and cls_i is an optional closure that provides the environment for the call. The returned ReturnCode is the number of values pushed on the stack as a result of the call.

pub fn install_extern_fn(&mut self, name: Symbol, f: ExtFunType) -> usize

pub fn install_extern_cls(&mut self, name: Symbol, f: ExtClsType) -> usize

pub fn alloc_code(&mut self, expr: ExprNodeId) -> RawVal

Store a code value (AST fragment) and return a RawVal index.

The returned value can later be passed to [get_code] to recover the original ExprNodeId.

pub fn get_code(&self, val: RawVal) -> ExprNodeId

Retrieve a previously stored code value by its RawVal index.

pub fn try_get_code(&self, val: RawVal) -> Option<ExprNodeId>

Try retrieving a previously stored code value by its RawVal index.

pub fn execute_idx(&mut self, idx: usize) -> ReturnCode

pub fn execute_entry(&mut self, entry: &str) -> ReturnCode

pub fn execute_main(&mut self) -> ReturnCode

Trait Implementations

impl RuntimePrimitives for Machine

type HeapRef = DefaultKey

type ArrayRef = u64

type StateOffset = U24

type TypeId = u8

fn heap_alloc(&mut self, size_words: WordSize) -> Self::HeapRef

fn heap_retain(&mut self, obj: Self::HeapRef)

fn heap_release(&mut self, obj: Self::HeapRef)

fn heap_load( &mut self, dst: &mut [Word], obj: Self::HeapRef, size_words: WordSize, )

fn heap_store(&mut self, obj: Self::HeapRef, src: &[Word], size_words: WordSize)

fn box_alloc(&mut self, src: &[Word], size_words: WordSize) -> Self::HeapRef

fn box_load( &mut self, dst: &mut [Word], obj: Self::HeapRef, size_words: WordSize, )

fn box_clone(&mut self, obj: Self::HeapRef)

fn box_release(&mut self, obj: Self::HeapRef)

fn box_store(&mut self, obj: Self::HeapRef, src: &[Word], size_words: WordSize)

fn usersum_clone( &mut self, value: &mut [Word], size_words: WordSize, type_id: Self::TypeId, )

fn usersum_release( &mut self, value: &mut [Word], size_words: WordSize, type_id: Self::TypeId, )

fn closure_make( &mut self, _fn_index: Word, _upvalue_count: WordSize, _state_size: WordSize, ) -> Self::HeapRef

fn closure_close(&mut self, obj: Self::HeapRef)

fn closure_call( &mut self, _obj: Self::HeapRef, _args: &[Word], _nargs_words: WordSize, _ret: &mut [Word], _nret_words: WordSize, )

fn state_push(&mut self, offset: Self::StateOffset)

fn state_pop(&mut self, offset: Self::StateOffset)

fn state_get(&mut self, dst: &mut [Word], size_words: WordSize)

fn state_set(&mut self, src: &[Word], size_words: WordSize)

fn state_delay( &mut self, dst: &mut [Word], src: &[Word], time: &[Word], max_len: Word, )

fn state_mem(&mut self, dst: &mut [Word], src: &[Word])

fn array_alloc( &mut self, len: Word, elem_size_words: WordSize, ) -> Self::ArrayRef

fn array_get_elem( &mut self, dst: &mut [Word], arr: Self::ArrayRef, index: Word, elem_size_words: WordSize, )

fn array_set_elem( &mut self, arr: Self::ArrayRef, index: Word, src: &[Word], elem_size_words: WordSize, )

fn runtime_get_now(&mut self) -> Word

fn runtime_get_samplerate(&mut self) -> Word