Struct cairo_vm::vm::vm_core::VirtualMachine

pub struct VirtualMachine {
    pub builtin_runners: Vec<BuiltinRunner>,
    pub segments: MemorySegmentManager,
    /* private fields */
}

Fields

builtin_runners: Vec<BuiltinRunner>

segments: MemorySegmentManager

Implementations

impl VirtualMachine

pub fn new(trace_enabled: bool) -> VirtualMachine

pub fn compute_segments_effective_sizes(&mut self)

pub fn step_hint( &mut self, hint_processor: &mut dyn HintProcessor, exec_scopes: &mut ExecutionScopes, hint_datas: &[Box<dyn Any>], constants: &HashMap<String, Felt252>, ) -> Result<(), VirtualMachineError>

pub fn step_instruction(&mut self) -> Result<(), VirtualMachineError>

pub fn step( &mut self, hint_processor: &mut dyn HintProcessor, exec_scopes: &mut ExecutionScopes, hint_datas: &[Box<dyn Any>], constants: &HashMap<String, Felt252>, ) -> Result<(), VirtualMachineError>

pub fn compute_operands( &self, instruction: &Instruction, ) -> Result<(Operands, OperandsAddresses, DeducedOperands), VirtualMachineError>

Compute operands and result, trying to deduce them if normal memory access returns a None value.

pub fn verify_auto_deductions(&self) -> Result<(), VirtualMachineError>

Makes sure that all assigned memory cells are consistent with their auto deduction rules.

pub fn verify_auto_deductions_for_addr( &self, addr: Relocatable, builtin: &BuiltinRunner, ) -> Result<(), VirtualMachineError>

pub fn end_run( &mut self, exec_scopes: &ExecutionScopes, ) -> Result<(), VirtualMachineError>

pub fn mark_address_range_as_accessed( &mut self, base: Relocatable, len: usize, ) -> Result<(), VirtualMachineError>

pub fn add_memory_segment(&mut self) -> Relocatable

Adds a new segment and to the memory and returns its starting location as a Relocatable value.

pub fn get_ap(&self) -> Relocatable

pub fn get_fp(&self) -> Relocatable

pub fn get_pc(&self) -> Relocatable

pub fn get_integer( &self, key: Relocatable, ) -> Result<Cow<'_, Felt252>, MemoryError>

Gets the integer value corresponding to the Relocatable address

pub fn get_relocatable( &self, key: Relocatable, ) -> Result<Relocatable, MemoryError>

Gets the relocatable value corresponding to the Relocatable address

pub fn get_maybe<'a, 'b: 'a, K: 'a>( &'b self, key: &'a K, ) -> Option<MaybeRelocatable>

where Relocatable: TryFrom<&'a K>,

Gets a MaybeRelocatable value from memory indicated by a generic address

pub fn get_builtin_runners(&self) -> &Vec<BuiltinRunner>

Returns a reference to the vector with all builtins present in the virtual machine

pub fn get_builtin_runners_as_mut(&mut self) -> &mut Vec<BuiltinRunner>

Returns a mutable reference to the vector with all builtins present in the virtual machine

pub fn insert_value<T: Into<MaybeRelocatable>>( &mut self, key: Relocatable, val: T, ) -> Result<(), MemoryError>

Inserts a value into a memory address given by a Relocatable value

pub fn load_data( &mut self, ptr: Relocatable, data: &[MaybeRelocatable], ) -> Result<Relocatable, MemoryError>

Writes data into the memory from address ptr and returns the first address after the data.

pub fn write_arg( &mut self, ptr: Relocatable, arg: &dyn Any, ) -> Result<MaybeRelocatable, MemoryError>

Writes args into the memory from address ptr and returns the first address after the data.

pub fn memcmp( &self, lhs: Relocatable, rhs: Relocatable, len: usize, ) -> (Ordering, usize)

pub fn mem_eq(&self, lhs: Relocatable, rhs: Relocatable, len: usize) -> bool

pub fn get_return_values( &self, n_ret: usize, ) -> Result<Vec<MaybeRelocatable>, MemoryError>

Gets n_ret return values from memory

pub fn get_range( &self, addr: Relocatable, size: usize, ) -> Vec<Option<Cow<'_, MaybeRelocatable>>>

Gets n elements from memory starting from addr (n being size)

pub fn get_continuous_range( &self, addr: Relocatable, size: usize, ) -> Result<Vec<MaybeRelocatable>, MemoryError>

Gets n elements from memory starting from addr (n being size)

pub fn get_integer_range( &self, addr: Relocatable, size: usize, ) -> Result<Vec<Cow<'_, Felt252>>, MemoryError>

Gets n integer values from memory starting from addr (n being size),

pub fn get_range_check_builtin( &self, ) -> Result<&RangeCheckBuiltinRunner<RC_N_PARTS_STANDARD>, VirtualMachineError>

pub fn get_signature_builtin( &mut self, ) -> Result<&mut SignatureBuiltinRunner, VirtualMachineError>

pub fn get_output_builtin_mut( &mut self, ) -> Result<&mut OutputBuiltinRunner, VirtualMachineError>

pub fn get_segment_used_size(&self, index: usize) -> Option<usize>

pub fn get_segment_size(&self, index: usize) -> Option<usize>

pub fn add_temporary_segment(&mut self) -> Relocatable

pub fn add_relocation_rule( &mut self, src_ptr: Relocatable, dst_ptr: Relocatable, ) -> Result<(), MemoryError>

Add a new relocation rule.

Will return an error if any of the following conditions are not met:

• Source address’s segment must be negative (temporary).
• Source address’s offset must be zero.
• There shouldn’t already be relocation at the source segment.

pub fn gen_arg( &mut self, arg: &dyn Any, ) -> Result<MaybeRelocatable, MemoryError>

pub fn write_output( &mut self, writer: &mut impl Write, ) -> Result<(), VirtualMachineError>

Write the values hosted in the output builtin’s segment. Does nothing if the output builtin is not present in the program.

pub fn get_public_memory_addresses( &self, ) -> Result<Vec<(usize, usize)>, VirtualMachineError>

Returns a list of addresses of memory cells that constitute the public memory.

pub fn mod_builtin_fill_memory( &mut self, add_mod_ptr_n: Option<(Relocatable, usize)>, mul_mod_ptr_n: Option<(Relocatable, usize)>, batch_size: Option<usize>, ) -> Result<(), VirtualMachineError>

Fetches add_mod & mul_mod builtins according to the optional arguments and executes fill_memory Returns an error if either of this optional parameters is true but the corresponding builtin is not present Verifies that both builtin’s (if present) batch sizes match the batch_size arg if set