Add support for precompiling hints

Author: JulianGCalderon

vm/src/vm/runners/cairo_runner.rs

@@ -162,7 +162,7 @@ pub struct CairoRunnerBuilder {
     // Set after loading instruction cache.
     // instructions: Vec<Option<Instruction>>,
     // Set after compiling hints.
-    // hints: Vec<Rc<dyn Any>>,
+    hints: Option<Vec<Rc<Box<dyn Any>>>>,
 }
 
 impl CairoRunnerBuilder {
@@ -203,6 +203,7 @@ impl CairoRunnerBuilder {
             execution_base: None,
             memory: MemorySegmentManager::new(),
             loaded_program: false,
+            hints: None,
         })
     }
 
@@ -221,7 +222,7 @@ impl CairoRunnerBuilder {
             || self.runner_mode == RunnerMode::ProofModeCairo1
     }
 
-    fn add_memory_segment(&mut self) -> Relocatable {
+    pub fn add_memory_segment(&mut self) -> Relocatable {
         self.memory.add()
     }
 
@@ -352,9 +353,12 @@ impl CairoRunnerBuilder {
         Ok(())
     }
 
-    pub fn initialize_segments(&mut self) {
+    pub fn initialize_base_segments(&mut self) {
         self.program_base = Some(self.add_memory_segment());
         self.execution_base = Some(self.add_memory_segment());
+    }
+
+    pub fn initialize_builtin_segments(&mut self) {
         for builtin_runner in self.builtin_runners.iter_mut() {
             builtin_runner.initialize_segments(&mut self.memory);
         }
@@ -372,6 +376,33 @@ impl CairoRunnerBuilder {
         Ok(())
     }
 
+    pub fn compile_hints(
+        &mut self,
+        hint_processor: &mut dyn HintProcessor,
+    ) -> Result<(), VirtualMachineError> {
+        let constants = Rc::new(self.program.constants.clone());
+        let references = &self.program.shared_program_data.reference_manager;
+        let compiled_hints = self
+            .program
+            .shared_program_data
+            .hints_collection
+            .iter_hints()
+            .map(|hint| {
+                let hint = hint_processor.compile_hint(
+                    &hint.code,
+                    &hint.flow_tracking_data.ap_tracking,
+                    &hint.flow_tracking_data.reference_ids,
+                    references,
+                    constants.clone(),
+                )?;
+
+                Ok(Rc::new(hint))
+            })
+            .collect::<Result<Vec<Rc<Box<dyn Any>>>, VirtualMachineError>>()?;
+        self.hints = Some(compiled_hints);
+        Ok(())
+    }
+
     pub fn build(self) -> Result<CairoRunner, RunnerError> {
         let mut vm = VirtualMachine::new(self.enable_trace, self.disable_trace_padding);
 
@@ -401,6 +432,7 @@ impl CairoRunnerBuilder {
             relocated_trace: None,
             program: self.program,
             loaded_program: self.loaded_program,
+            hints: self.hints,
         })
     }
 }
@@ -424,6 +456,7 @@ pub struct CairoRunner {
     pub exec_scopes: ExecutionScopes,
     pub relocated_trace: Option<Vec<RelocatedTraceEntry>>,
     loaded_program: bool,
+    hints: Option<Vec<Rc<Box<dyn Any>>>>,
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -486,6 +519,7 @@ impl CairoRunner {
             },
             relocated_trace: None,
             loaded_program: false,
+            hints: None,
         })
     }
 
@@ -991,6 +1025,57 @@ impl CairoRunner {
         Ok(())
     }
 
+    pub fn run_until_pc_v2(
+        &mut self,
+        address: Relocatable,
+        hint_processor: &mut dyn HintProcessor,
+    ) -> Result<(), VirtualMachineError> {
+        let references = &self.program.shared_program_data.reference_manager;
+        #[cfg_attr(not(feature = "extensive_hints"), allow(unused_mut))]
+        let mut hint_data = if let Some(hints) = self.hints.take() {
+            hints
+        } else {
+            self.get_hint_data(references, hint_processor)?
+                .into_iter()
+                .map(Rc::new)
+                .collect()
+        };
+        #[cfg(feature = "extensive_hints")]
+        let mut hint_ranges = self
+            .program
+            .shared_program_data
+            .hints_collection
+            .hints_ranges
+            .clone();
+        while self.vm.get_pc() != address && !hint_processor.consumed() {
+            self.vm.step_v2(
+                hint_processor,
+                &mut self.exec_scopes,
+                #[cfg(feature = "extensive_hints")]
+                &mut hint_data,
+                #[cfg(not(feature = "extensive_hints"))]
+                self.program
+                    .shared_program_data
+                    .hints_collection
+                    .get_hint_range_for_pc(self.vm.get_pc().offset)
+                    .and_then(|range| {
+                        range.and_then(|(start, length)| hint_data.get(start..start + length.get()))
+                    })
+                    .unwrap_or(&[]),
+                #[cfg(feature = "extensive_hints")]
+                &mut hint_ranges,
+            )?;
+
+            hint_processor.consume_step();
+        }
+
+        if self.vm.get_pc() != address {
+            return Err(VirtualMachineError::UnfinishedExecution);
+        }
+
+        Ok(())
+    }
+
     /// Execute an exact number of steps on the program from the actual position.
     pub fn run_for_steps(
         &mut self,

vm/src/vm/vm_core.rs

@@ -1,5 +1,5 @@
 use crate::math_utils::signed_felt;
-use crate::stdlib::{any::Any, borrow::Cow, collections::HashMap, prelude::*};
+use crate::stdlib::{any::Any, borrow::Cow, collections::HashMap, prelude::*, rc::Rc};
 use crate::types::builtin_name::BuiltinName;
 #[cfg(feature = "extensive_hints")]
 use crate::types::program::HintRange;
@@ -535,6 +535,21 @@ impl VirtualMachine {
         Ok(())
     }
 
+    #[cfg(not(feature = "extensive_hints"))]
+    pub fn step_hint_v2(
+        &mut self,
+        hint_processor: &mut dyn HintProcessor,
+        exec_scopes: &mut ExecutionScopes,
+        hint_datas: &[Rc<Box<dyn Any>>],
+    ) -> Result<(), VirtualMachineError> {
+        for (hint_index, hint_data) in hint_datas.iter().enumerate() {
+            hint_processor
+                .execute_hint(self, exec_scopes, hint_data.as_ref())
+                .map_err(|err| VirtualMachineError::Hint(Box::new((hint_index, err))))?
+        }
+        Ok(())
+    }
+
     #[cfg(feature = "extensive_hints")]
     pub fn step_hint(
         &mut self,
@@ -568,6 +583,39 @@ impl VirtualMachine {
         Ok(())
     }
 
+    #[cfg(feature = "extensive_hints")]
+    pub fn step_hint_v2(
+        &mut self,
+        hint_processor: &mut dyn HintProcessor,
+        exec_scopes: &mut ExecutionScopes,
+        hint_datas: &mut Vec<Rc<Box<dyn Any>>>,
+        hint_ranges: &mut HashMap<Relocatable, HintRange>,
+    ) -> Result<(), VirtualMachineError> {
+        // Check if there is a hint range for the current pc
+        if let Some((s, l)) = hint_ranges.get(&self.run_context.pc) {
+            // Re-binding to avoid mutability problems
+            let s = *s;
+            // Execute each hint for the given range
+            for idx in s..(s + l.get()) {
+                let hint_data = hint_datas
+                    .get(idx)
+                    .ok_or(VirtualMachineError::Unexpected)?
+                    .as_ref();
+                let hint_extension = hint_processor
+                    .execute_hint_extensive(self, exec_scopes, hint_data)
+                    .map_err(|err| VirtualMachineError::Hint(Box::new((idx - s, err))))?;
+                // Update the hint_ranges & hint_datas with the hints added by the executed hint
+                for (hint_pc, hints) in hint_extension {
+                    if let Ok(len) = NonZeroUsize::try_from(hints.len()) {
+                        hint_ranges.insert(hint_pc, (hint_datas.len(), len));
+                        hint_datas.extend(hints.into_iter().map(Rc::new));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
     pub fn step_instruction(&mut self) -> Result<(), VirtualMachineError> {
         if self.run_context.pc.segment_index == 0 {
             // Run instructions from program segment, using instruction cache
@@ -633,6 +681,27 @@ impl VirtualMachine {
         Ok(())
     }
 
+    pub fn step_v2(
+        &mut self,
+        hint_processor: &mut dyn HintProcessor,
+        exec_scopes: &mut ExecutionScopes,
+        #[cfg(feature = "extensive_hints")] hint_datas: &mut Vec<Rc<Box<dyn Any>>>,
+        #[cfg(not(feature = "extensive_hints"))] hint_datas: &[Rc<Box<dyn Any>>],
+        #[cfg(feature = "extensive_hints")] hint_ranges: &mut HashMap<Relocatable, HintRange>,
+    ) -> Result<(), VirtualMachineError> {
+        self.step_hint_v2(
+            hint_processor,
+            exec_scopes,
+            hint_datas,
+            #[cfg(feature = "extensive_hints")]
+            hint_ranges,
+        )?;
+
+        self.step_instruction()?;
+
+        Ok(())
+    }
+
     fn compute_op0_deductions(
         &self,
         op0_addr: Relocatable,