Fix_no_trace_padding_flow_in_proof_mode

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 #### Upcoming Changes
 
+* fix: Fix no trace padding flow in proof mode [#1909](https://github.com/lambdaclass/cairo-vm/pull/1909)
+
 * feat: implement `kzg` data availability hints [#1887](https://github.com/lambdaclass/cairo-vm/pull/1887)
 
 #### [2.0.0-rc3] - 2024-12-26

cairo1-run/src/cairo_run.rs

@@ -258,6 +258,7 @@ pub fn cairo_run_program(
         cairo_run_config.dynamic_layout_params.clone(),
         runner_mode,
         cairo_run_config.trace_enabled,
+        false,
     )?;
     let end = runner.initialize(cairo_run_config.proof_mode)?;
     load_arguments(&mut runner, &cairo_run_config, main_func, initial_gas)?;

hint_accountant/src/main.rs

@@ -49,7 +49,7 @@ fn run() {
             whitelists.push(whitelist_file.allowed_hint_expressions);
         }
     }
-    let mut vm = VirtualMachine::new(false);
+    let mut vm = VirtualMachine::new(false, false);
     let mut hint_executor = BuiltinHintProcessor::new_empty();
     let (ap_tracking_data, reference_ids, references, mut exec_scopes, constants) = (
         ApTracking::default(),

vm/src/cairo_run.rs

@@ -75,6 +75,7 @@ pub fn cairo_run_program_with_initial_scope(
         cairo_run_config.dynamic_layout_params.clone(),
         cairo_run_config.proof_mode,
         cairo_run_config.trace_enabled,
+        cairo_run_config.disable_trace_padding,
     )?;
 
     cairo_runner.exec_scopes = exec_scopes;
@@ -162,6 +163,7 @@ pub fn cairo_run_pie(
         cairo_run_config.dynamic_layout_params.clone(),
         false,
         cairo_run_config.trace_enabled,
+        cairo_run_config.disable_trace_padding,
     )?;
 
     let end = cairo_runner.initialize(allow_missing_builtins)?;
@@ -235,6 +237,7 @@ pub fn cairo_run_fuzzed_program(
         cairo_run_config.dynamic_layout_params.clone(),
         cairo_run_config.proof_mode,
         cairo_run_config.trace_enabled,
+        cairo_run_config.disable_trace_padding,
     )?;
 
     let _end = cairo_runner.initialize(allow_missing_builtins)?;

vm/src/tests/mod.rs

@@ -116,6 +116,7 @@ fn run_cairo_1_entrypoint(
         None,
         false,
         false,
+        false,
     )
     .unwrap();
 
@@ -221,6 +222,7 @@ fn run_cairo_1_entrypoint_with_run_resources(
         None,
         false,
         false,
+        false,
     )
     .unwrap();
 

vm/src/utils.rs

@@ -234,7 +234,7 @@ pub mod test_utils {
 
     macro_rules! vm_with_range_check {
         () => {{
-            let mut vm = VirtualMachine::new(false);
+            let mut vm = VirtualMachine::new(false, false);
             vm.builtin_runners = vec![
                 $crate::vm::runners::builtin_runner::RangeCheckBuiltinRunner::<8>::new(
                     Some(8),
@@ -255,12 +255,13 @@ pub mod test_utils {
                 None,
                 false,
                 false,
+                false,
             )
             .unwrap()
         };
         ($program:expr, $layout:expr) => {
             crate::vm::runners::cairo_runner::CairoRunner::new(
-                &$program, $layout, None, false, false,
+                &$program, $layout, None, false, false, false,
             )
             .unwrap()
         };
@@ -271,6 +272,7 @@ pub mod test_utils {
                 None,
                 $proof_mode,
                 false,
+                false,
             )
             .unwrap()
         };
@@ -281,6 +283,7 @@ pub mod test_utils {
                 None,
                 $proof_mode,
                 $trace_enabled,
+                false,
             )
             .unwrap()
         };
@@ -405,11 +408,11 @@ pub mod test_utils {
 
     macro_rules! vm {
         () => {{
-            crate::vm::vm_core::VirtualMachine::new(false)
+            crate::vm::vm_core::VirtualMachine::new(false, false)
         }};
 
         ($use_trace:expr) => {{
-            crate::vm::vm_core::VirtualMachine::new($use_trace)
+            crate::vm::vm_core::VirtualMachine::new($use_trace, false)
         }};
     }
     pub(crate) use vm;

vm/src/vm/runners/builtin_runner/mod.rs

@@ -212,14 +212,19 @@ impl BuiltinRunner {
                             )
                             .into());
                         };
+                        let numerator = if let Some(ratio_den) = self.ratio_den() {
+                            vm.current_step * ratio_den as usize
+                        } else {
+                            vm.current_step
+                        };
 
-                        let allocated_instances = if let Some(ratio_den) = self.ratio_den() {
-                            safe_div_usize(vm.current_step * ratio_den as usize, ratio as usize)
-                                .map_err(|_| MemoryError::ErrorCalculatingMemoryUnits)?
+                        let allocated_instances = if vm.disable_trace_padding {
+                            div_ceil(numerator, ratio as usize)
                         } else {
-                            safe_div_usize(vm.current_step, ratio as usize)
+                            safe_div_usize(numerator, ratio as usize)
                                 .map_err(|_| MemoryError::ErrorCalculatingMemoryUnits)?
                         };
+
                         Ok(allocated_instances)
                     }
                 }

vm/src/vm/runners/cairo_runner.rs

@@ -176,6 +176,7 @@ impl CairoRunner {
         dynamic_layout_params: Option<CairoLayoutParams>,
         mode: RunnerMode,
         trace_enabled: bool,
+        disable_trace_padding: bool,
     ) -> Result<CairoRunner, RunnerError> {
         let cairo_layout = match layout {
             LayoutName::plain => CairoLayout::plain_instance(),
@@ -197,7 +198,7 @@ impl CairoRunner {
         };
         Ok(CairoRunner {
             program: program.clone(),
-            vm: VirtualMachine::new(trace_enabled),
+            vm: VirtualMachine::new(trace_enabled, disable_trace_padding),
             layout: cairo_layout,
             final_pc: None,
             program_base: None,
@@ -226,6 +227,7 @@ impl CairoRunner {
         dynamic_layout_params: Option<CairoLayoutParams>,
         proof_mode: bool,
         trace_enabled: bool,
+        disable_trace_padding: bool,
     ) -> Result<CairoRunner, RunnerError> {
         if proof_mode {
             Self::new_v2(
@@ -234,6 +236,7 @@ impl CairoRunner {
                 dynamic_layout_params,
                 RunnerMode::ProofModeCanonical,
                 trace_enabled,
+                disable_trace_padding,
             )
         } else {
             Self::new_v2(
@@ -242,6 +245,7 @@ impl CairoRunner {
                 dynamic_layout_params,
                 RunnerMode::ExecutionMode,
                 trace_enabled,
+                disable_trace_padding,
             )
         }
     }

vm/src/vm/vm_core.rs

@@ -89,14 +89,15 @@ pub struct VirtualMachine {
     pub(crate) rc_limits: Option<(isize, isize)>,
     skip_instruction_execution: bool,
     run_finished: bool,
+    pub(crate) disable_trace_padding: bool,
     instruction_cache: Vec<Option<Instruction>>,
     #[cfg(feature = "test_utils")]
     pub(crate) hooks: crate::vm::hooks::Hooks,
     pub(crate) relocation_table: Option<Vec<usize>>,
 }
 
 impl VirtualMachine {
-    pub fn new(trace_enabled: bool) -> VirtualMachine {
+    pub fn new(trace_enabled: bool, disable_trace_padding: bool) -> VirtualMachine {
         let run_context = RunContext {
             pc: Relocatable::from((0, 0)),
             ap: 0,
@@ -118,6 +119,7 @@ impl VirtualMachine {
             segments: MemorySegmentManager::new(),
             rc_limits: None,
             run_finished: false,
+            disable_trace_padding,
             instruction_cache: Vec::new(),
             #[cfg(feature = "test_utils")]
             hooks: Default::default(),
@@ -1255,6 +1257,7 @@ impl VirtualMachineBuilder {
             #[cfg(feature = "test_utils")]
             hooks: self.hooks,
             relocation_table: None,
+            disable_trace_padding: false,
         }
     }
 }
@@ -1444,7 +1447,7 @@ mod tests {
             op1: MaybeRelocatable::Int(Felt252::from(10)),
         };
 
-        let mut vm = VirtualMachine::new(false);
+        let mut vm = VirtualMachine::new(false, false);
         vm.run_context.pc = Relocatable::from((0, 4));
         vm.run_context.ap = 5;
         vm.run_context.fp = 6;