Struct VirtualMachine 

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

Fields

builtin_runners: Vec<BuiltinRunner>

simulated_builtin_runners: Vec<BuiltinRunner>

A simulated builtin is being verified in the executed Cairo code (so proving them only involves proving cairo steps), rather than being outputted as their own segment and proven later using dedicated AIRs.

These builtins won’t be included in the layout, hence the builtin segment pointer won’t be passed as argument to the program. The program needs a mechanism for obtaining the segment pointer. See example implementation of this mechanism in simulated_builtins.cairo, or cairo-lang’s simple_bootloader.cairo.

segments: MemorySegmentManager

Implementations

impl VirtualMachine

pub fn new(trace_enabled: bool, disable_trace_padding: 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>], ) -> Result<(), VirtualMachineError>

Available on non-crate feature extensive_hints only.

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>], ) -> 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 complete_builtin_auto_deductions( &mut self, ) -> Result<(), VirtualMachineError>

Updates the memory with missing built-in deductions and verifies the existing ones.

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, fill_holes: bool, ) -> Result<(), VirtualMachineError>

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

pub fn get_traceback_entries(&self) -> Vec<(Relocatable, Relocatable)>

Returns the values (fp, pc) corresponding to each call instruction in the traceback. Returns the most recent call last.

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_current_step(&self) -> usize

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 get_all_builtin_runners_as_mut_iter( &mut self, ) -> impl Iterator<Item = &mut BuiltinRunner>

Returns a mutable iterator over all builtin runners used. That is, both builtin_runners and simulated_builtin_runners.

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 is_accessed(&self, addr: &Relocatable) -> Result<bool, MemoryError>

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_u32_range( &self, addr: Relocatable, size: usize, ) -> Result<Vec<u32>, MemoryError>

Gets n u32 values from memory starting from addr (n being size). Returns an error if any of the values inside the range is missing (memory gap) or is not a u32.

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.

When using feature “extensive_hints” the destination is allowed to be an Integer (via MaybeRelocatable). Relocating memory to anything other than a Relocatable is generally not useful, but it does make the implementation consistent with the pythonic version.

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