add relocate trace flag to the runner

Author: Stavbe

cairo-vm-cli/src/main.rs

@@ -189,6 +189,7 @@ fn run(args: impl Iterator<Item = String>) -> Result<(), Error> {
         entrypoint: &args.entrypoint,
         trace_enabled,
         relocate_mem: args.memory_file.is_some() || args.air_public_input.is_some(),
+        relocate_trace: trace_enabled,
         layout: args.layout,
         proof_mode: args.proof_mode,
         secure_run: args.secure_run,

cairo1-run/src/cairo_run.rs

@@ -341,7 +341,7 @@ pub fn cairo_run_program(
         }
     }
 
-    runner.relocate(true)?;
+    runner.relocate(true, true)?;
 
     Ok((runner, return_values, serialized_output))
 }

vm/src/cairo_run.rs

@@ -27,7 +27,10 @@ pub struct CairoRunConfig<'a> {
     #[cfg_attr(feature = "test_utils", arbitrary(value = "main"))]
     pub entrypoint: &'a str,
     pub trace_enabled: bool,
+    /// Relocate memory if `true`, otherwise memory is not relocated.
     pub relocate_mem: bool,
+    // When `relocate_trace` is set to `false`, the trace will not be relocated even if `trace_enabled` is `true`.
+    pub relocate_trace: bool,
     pub layout: LayoutName,
     /// The `dynamic_layout_params` argument should only be used with dynamic layout.
     /// It is ignored otherwise.
@@ -51,6 +54,8 @@ impl Default for CairoRunConfig<'_> {
             entrypoint: "main",
             trace_enabled: false,
             relocate_mem: false,
+            // Set to true to match expected behavior: trace is relocated only if trace_enabled is true.
+            relocate_trace: true,
             layout: LayoutName::plain,
             proof_mode: false,
             secure_run: None,
@@ -113,7 +118,10 @@ pub fn cairo_run_program_with_initial_scope(
     if secure_run {
         verify_secure_runner(&cairo_runner, true, None)?;
     }
-    cairo_runner.relocate(cairo_run_config.relocate_mem)?;
+    cairo_runner.relocate(
+        cairo_run_config.relocate_mem,
+        cairo_run_config.relocate_trace,
+    )?;
 
     Ok(cairo_runner)
 }
@@ -218,7 +226,10 @@ pub fn cairo_run_pie(
         // Check that the Cairo PIE produced by this run is compatible with the Cairo PIE received
         cairo_runner.get_cairo_pie()?.check_pie_compatibility(pie)?;
     }
-    cairo_runner.relocate(cairo_run_config.relocate_mem)?;
+    cairo_runner.relocate(
+        cairo_run_config.relocate_mem,
+        cairo_run_config.relocate_trace,
+    )?;
 
     Ok(cairo_runner)
 }
@@ -267,7 +278,10 @@ pub fn cairo_run_fuzzed_program(
     if secure_run {
         verify_secure_runner(&cairo_runner, true, None)?;
     }
-    cairo_runner.relocate(cairo_run_config.relocate_mem)?;
+    cairo_runner.relocate(
+        cairo_run_config.relocate_mem,
+        cairo_run_config.relocate_trace,
+    )?;
 
     Ok(cairo_runner)
 }
@@ -367,7 +381,7 @@ mod tests {
 
         let end = cairo_runner.initialize(false).unwrap();
         assert!(cairo_runner.run_until_pc(end, &mut hint_processor).is_ok());
-        assert!(cairo_runner.relocate(true).is_ok());
+        assert!(cairo_runner.relocate(true, true).is_ok());
         // `main` returns without doing nothing, but `not_main` sets `[ap]` to `1`
         // Memory location was found empirically and simply hardcoded
         assert_eq!(cairo_runner.relocated_memory[2], Some(Felt252::from(123)));
@@ -433,7 +447,7 @@ mod tests {
         let mut hint_processor = BuiltinHintProcessor::new_empty();
         let mut cairo_runner = run_test_program(program_content, &mut hint_processor).unwrap();
 
-        assert!(cairo_runner.relocate(false).is_ok());
+        assert!(cairo_runner.relocate(false, true).is_ok());
 
         let trace_entries = cairo_runner.relocated_trace.unwrap();
         let mut buffer = [0; 24];
@@ -457,7 +471,7 @@ mod tests {
         let mut cairo_runner = run_test_program(program_content, &mut hint_processor).unwrap();
 
         // relocate memory so we can dump it to file
-        assert!(cairo_runner.relocate(true).is_ok());
+        assert!(cairo_runner.relocate(true, true).is_ok());
 
         let mut buffer = [0; 120];
         let mut buff_writer = SliceWriter::new(&mut buffer);
@@ -481,7 +495,7 @@ mod tests {
         let mut cairo_runner = cairo_runner!(program);
         let end = cairo_runner.initialize(false).unwrap();
         assert!(cairo_runner.run_until_pc(end, &mut hint_processor).is_ok());
-        assert!(cairo_runner.relocate(false).is_ok());
+        assert!(cairo_runner.relocate(false, false).is_ok());
         assert!(cairo_runner.relocated_trace.is_none());
     }
 

vm/src/vm/runners/cairo_runner.rs

@@ -984,9 +984,9 @@ impl CairoRunner {
         Ok(())
     }
 
-    pub fn relocate(&mut self, relocate_mem: bool) -> Result<(), TraceError> {
+    pub fn relocate(&mut self, relocate_mem: bool, relocate_trace: bool) -> Result<(), TraceError> {
         self.vm.segments.compute_effective_sizes();
-        if !relocate_mem && self.vm.trace.is_none() {
+        if !relocate_mem && (self.vm.trace.is_none() || !relocate_trace) {
             return Ok(());
         }
         // relocate_segments can fail if compute_effective_sizes is not called before.
@@ -1002,7 +1002,7 @@ impl CairoRunner {
                 return Err(TraceError::MemoryError(memory_error));
             }
         }
-        if self.vm.trace.is_some() {
+        if self.vm.trace.is_some() && relocate_trace {
             self.relocate_trace(&relocation_table)?;
         }
         self.vm.relocation_table = Some(relocation_table);