Add support for caching Cairo 1 runners

Author: JulianGCalderon

vm/src/vm/runners/cairo_runner.rs

@@ -241,6 +241,10 @@ impl CairoRunnerBuilder {
             || self.runner_mode == RunnerMode::ProofModeCairo1
     }
 
+    pub fn get_program_base(&self) -> Option<Relocatable> {
+        self.program_base
+    }
+
     pub fn add_memory_segment(&mut self) -> Relocatable {
         self.memory.add()
     }
@@ -378,6 +382,41 @@ impl CairoRunnerBuilder {
         Ok(())
     }
 
+    /// *Initializes* and *includes* all the given builtins.
+    ///
+    /// Doesn't take the current layout into account.
+    pub fn initialize_builtin_runners(
+        &mut self,
+        builtins: &[BuiltinName],
+    ) -> Result<(), RunnerError> {
+        for builtin_name in builtins {
+            let builtin_runner = match builtin_name {
+                BuiltinName::pedersen => HashBuiltinRunner::new(Some(32), true).into(),
+                BuiltinName::range_check => {
+                    RangeCheckBuiltinRunner::<RC_N_PARTS_STANDARD>::new(Some(1), true).into()
+                }
+                BuiltinName::output => OutputBuiltinRunner::new(true).into(),
+                BuiltinName::ecdsa => SignatureBuiltinRunner::new(Some(1), true).into(),
+                BuiltinName::bitwise => BitwiseBuiltinRunner::new(Some(1), true).into(),
+                BuiltinName::ec_op => EcOpBuiltinRunner::new(Some(1), true).into(),
+                BuiltinName::keccak => KeccakBuiltinRunner::new(Some(1), true).into(),
+                BuiltinName::poseidon => PoseidonBuiltinRunner::new(Some(1), true).into(),
+                BuiltinName::segment_arena => SegmentArenaBuiltinRunner::new(true).into(),
+                BuiltinName::range_check96 => {
+                    RangeCheckBuiltinRunner::<RC_N_PARTS_96>::new(Some(1), true).into()
+                }
+                BuiltinName::add_mod => {
+                    ModBuiltinRunner::new_add_mod(&ModInstanceDef::new(Some(1), 1, 96), true).into()
+                }
+                BuiltinName::mul_mod => {
+                    ModBuiltinRunner::new_mul_mod(&ModInstanceDef::new(Some(1), 1, 96), true).into()
+                }
+            };
+            self.builtin_runners.push(builtin_runner);
+        }
+        Ok(())
+    }
+
     pub fn initialize_base_segments(&mut self) {
         self.program_base = Some(self.add_memory_segment());
         self.execution_base = Some(self.add_memory_segment());
@@ -412,6 +451,16 @@ impl CairoRunnerBuilder {
         Ok(())
     }
 
+    /// Preallocates memory for `n` more elements in the given segment.
+    pub fn preallocate_segment(
+        &mut self,
+        segment: Relocatable,
+        n: usize,
+    ) -> Result<(), RunnerError> {
+        self.memory.memory.preallocate_segment(segment, n)?;
+        Ok(())
+    }
+
     /// Loads decoded program instructions.
     ///
     /// # Safety

vm/src/vm/vm_memory/memory.rs

@@ -747,6 +747,22 @@ impl Memory {
         self.mark_as_accessed(key);
         Ok(())
     }
+
+    /// Preallocates memory for `n` more elements in the given segment.
+    ///
+    /// Why not using using `reserve`? When cloning a vector, the capacity
+    /// of the clone is not necessary equal to the capacity of the original.
+    /// Because of this, to actually preallocate memory in the builder, we need
+    /// to insert empty memory cells.
+    pub fn preallocate_segment(
+        &mut self,
+        segment: Relocatable,
+        n: usize,
+    ) -> Result<(), MemoryError> {
+        let segment = self.get_segment(segment)?;
+        segment.extend((0..n).map(|_| MemoryCell::NONE));
+        Ok(())
+    }
 }
 
 impl From<&Memory> for CairoPieMemory {