Add_option_to_simulate_builtins (#1956)

Author: YairVaknin-starkware

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 #### Upcoming Changes
 
+* feat: adding option to simulate builtins [#1956](https://github.com/lambdaclass/cairo-vm/pull/1956)
+
 * feat: adding `all_cairo_stwo` layout to vm [#1957](https://github.com/lambdaclass/cairo-vm/pull/1957)
 
 * chore: update Rust required version to 1.85.0 [#1990](https://github.com/lambdaclass/cairo-vm/pull/1990)

vm/src/vm/runners/builtin_runner/ec_op.rs

@@ -23,7 +23,7 @@ pub struct EcOpBuiltinRunner {
 }
 
 impl EcOpBuiltinRunner {
-    pub(crate) fn new(ratio: Option<u32>, included: bool) -> Self {
+    pub fn new(ratio: Option<u32>, included: bool) -> Self {
         EcOpBuiltinRunner {
             base: 0,
             ratio,

vm/src/vm/runners/builtin_runner/keccak.rs

@@ -31,7 +31,7 @@ pub struct KeccakBuiltinRunner {
 }
 
 impl KeccakBuiltinRunner {
-    pub(crate) fn new(ratio: Option<u32>, included: bool) -> Self {
+    pub fn new(ratio: Option<u32>, included: bool) -> Self {
         KeccakBuiltinRunner {
             base: 0,
             ratio,

vm/src/vm/runners/builtin_runner/signature.rs

@@ -35,13 +35,13 @@ lazy_static! {
 pub struct SignatureBuiltinRunner {
     pub(crate) included: bool,
     ratio: Option<u32>,
-    base: usize,
+    pub base: usize,
     pub(crate) stop_ptr: Option<usize>,
-    signatures: Rc<RefCell<HashMap<Relocatable, Signature>>>,
+    pub signatures: Rc<RefCell<HashMap<Relocatable, Signature>>>,
 }
 
 impl SignatureBuiltinRunner {
-    pub(crate) fn new(ratio: Option<u32>, included: bool) -> Self {
+    pub fn new(ratio: Option<u32>, included: bool) -> Self {
         SignatureBuiltinRunner {
             base: 0,
             included,

vm/src/vm/vm_core.rs

@@ -88,6 +88,7 @@ impl DeducedOperands {
 pub struct VirtualMachine {
     pub(crate) run_context: RunContext,
     pub builtin_runners: Vec<BuiltinRunner>,
+    pub simulated_builtin_runners: Vec<BuiltinRunner>,
     pub segments: MemorySegmentManager,
     pub(crate) trace: Option<Vec<TraceEntry>>,
     pub(crate) current_step: usize,
@@ -119,6 +120,7 @@ impl VirtualMachine {
         VirtualMachine {
             run_context,
             builtin_runners: Vec::new(),
+            simulated_builtin_runners: Vec::new(),
             trace,
             current_step: 0,
             skip_instruction_execution: false,
@@ -296,12 +298,17 @@ impl VirtualMachine {
         &self,
         address: Relocatable,
     ) -> Result<Option<MaybeRelocatable>, VirtualMachineError> {
-        for builtin in self.builtin_runners.iter() {
-            if builtin.base() as isize == address.segment_index {
-                match builtin.deduce_memory_cell(address, &self.segments.memory) {
-                    Ok(maybe_reloc) => return Ok(maybe_reloc),
-                    Err(error) => return Err(VirtualMachineError::RunnerError(error)),
-                };
+        let memory = &self.segments.memory;
+
+        for runner in self
+            .builtin_runners
+            .iter()
+            .chain(self.simulated_builtin_runners.iter())
+        {
+            if runner.base() as isize == address.segment_index {
+                return runner
+                    .deduce_memory_cell(address, memory)
+                    .map_err(VirtualMachineError::RunnerError);
             }
         }
         Ok(None)
@@ -916,6 +923,16 @@ impl VirtualMachine {
         &mut self.builtin_runners
     }
 
+    /// Returns a mutable iterator over all builtin runners used. That is, both builtin_runners and
+    /// simulated_builtin_runners.
+    pub fn get_all_builtin_runners_as_mut_iter(
+        &mut self,
+    ) -> impl Iterator<Item = &mut BuiltinRunner> {
+        self.builtin_runners
+            .iter_mut()
+            .chain(self.simulated_builtin_runners.iter_mut())
+    }
+
     ///Inserts a value into a memory address given by a Relocatable value
     pub fn insert_value<T: Into<MaybeRelocatable>>(
         &mut self,
@@ -1004,7 +1021,7 @@ impl VirtualMachine {
     pub fn get_signature_builtin(
         &mut self,
     ) -> Result<&mut SignatureBuiltinRunner, VirtualMachineError> {
-        for builtin in self.get_builtin_runners_as_mut() {
+        for builtin in self.get_all_builtin_runners_as_mut_iter() {
             if let BuiltinRunner::Signature(signature_builtin) = builtin {
                 return Ok(signature_builtin);
             };
@@ -1309,6 +1326,7 @@ impl VirtualMachineBuilder {
         VirtualMachine {
             run_context: self.run_context,
             builtin_runners: self.builtin_runners,
+            simulated_builtin_runners: Vec::new(),
             trace: self.trace,
             current_step: self.current_step,
             skip_instruction_execution: self.skip_instruction_execution,

vm/src/vm/vm_memory/memory_segments.rs

@@ -23,7 +23,7 @@ use super::memory::MemoryCell;
 pub struct MemorySegmentManager {
     pub segment_sizes: HashMap<usize, usize>,
     pub segment_used_sizes: Option<Vec<usize>>,
-    pub(crate) memory: Memory,
+    pub memory: Memory,
     // A map from segment index to a list of pairs (offset, page_id) that constitute the
     // public memory. Note that the offset is absolute (not based on the page_id).
     pub public_memory_offsets: HashMap<usize, Vec<(usize, usize)>>,