feat: generic cairo run config for runner ctors

CHANGELOG.md

@@ -12,6 +12,8 @@ Both branches support Stwo prover opcodes (Blake2s, QM31) since v2.0.0.
 
 #### Upcoming Changes
 
+* feat: generic cairo run config for runner ctors [#2360](https://github.com/phil-starkware/cairo-vm/pull/2360)
+
 * Add Stwo cairo runner API [#2351](https://github.com/lambdaclass/cairo-vm/pull/2351)
 
 * Add union merge strategy for CHANGELOG.md [#2345](https://github.com/lambdaclass/cairo-vm/pull/2345)

bench/criterion_benchmark.rs

@@ -1,4 +1,5 @@
 use cairo_vm::{
+    cairo_run::CairoRunConfig,
     types::{layout_name::LayoutName, program::Program},
     vm::runners::cairo_runner::CairoRunner,
 };
@@ -29,11 +30,10 @@ fn build_many_runners(c: &mut Criterion) {
             _ = black_box(
                 CairoRunner::new(
                     black_box(&program),
-                    black_box(LayoutName::starknet_with_keccak),
-                    black_box(None),
-                    black_box(false),
-                    black_box(false),
-                    black_box(false),
+                    black_box(&CairoRunConfig {
+                        layout: LayoutName::starknet_with_keccak,
+                        ..Default::default()
+                    }),
                 )
                 .unwrap(),
             );
@@ -50,11 +50,10 @@ fn load_program_data(c: &mut Criterion) {
             || {
                 CairoRunner::new(
                     &program,
-                    LayoutName::starknet_with_keccak,
-                    None,
-                    false,
-                    false,
-                    false,
+                    &CairoRunConfig {
+                        layout: LayoutName::starknet_with_keccak,
+                        ..Default::default()
+                    },
                 )
                 .unwrap()
             },

bench/iai_benchmark.rs

@@ -36,11 +36,10 @@ fn build_runner() {
     let program = parse_program_helper();
     let runner = CairoRunner::new(
         black_box(&program),
-        LayoutName::starknet_with_keccak,
-        None,
-        false,
-        false,
-        false,
+        &CairoRunConfig {
+            layout: LayoutName::starknet_with_keccak,
+            ..Default::default()
+        },
     )
     .unwrap();
     core::mem::drop(black_box(runner));
@@ -54,11 +53,10 @@ fn build_runner_helper() -> CairoRunner {
     let program = Program::from_bytes(program.as_slice(), Some("main")).unwrap();
     CairoRunner::new(
         &program,
-        LayoutName::starknet_with_keccak,
-        None,
-        false,
-        false,
-        false,
+        &CairoRunConfig {
+            layout: LayoutName::starknet_with_keccak,
+            ..Default::default()
+        },
     )
     .unwrap()
 }

cairo-vm-cli/src/main.rs

@@ -280,8 +280,15 @@ mod tests {
         hint_processor: &mut dyn HintProcessor,
     ) -> Result<CairoRunner, CairoRunError> {
         let program = Program::from_bytes(program_content, Some("main")).unwrap();
-        let mut cairo_runner =
-            CairoRunner::new(&program, LayoutName::all_cairo, None, false, true, false).unwrap();
+        let mut cairo_runner = CairoRunner::new(
+            &program,
+            &CairoRunConfig {
+                layout: LayoutName::all_cairo,
+                trace_enabled: true,
+                ..Default::default()
+            },
+        )
+        .unwrap();
         let end = cairo_runner
             .initialize(false)
             .map_err(CairoRunError::Runner)?;

cairo1-run/src/cairo_run.rs

@@ -37,6 +37,7 @@ use cairo_lang_utils::{
 use std::{collections::HashMap, iter::Peekable};
 
 use cairo_vm::{
+    cairo_run::CommonCairoRunConfig,
     hint_processor::cairo_1_hint_processor::hint_processor::Cairo1HintProcessor,
     math_utils::signed_felt,
     serde::deserialize_program::{ApTracking, FlowTrackingData, HintParams, ReferenceManager},
@@ -119,6 +120,33 @@ impl Default for Cairo1RunConfig<'_> {
     }
 }
 
+impl CommonCairoRunConfig for Cairo1RunConfig<'_> {
+    fn trace_enabled(&self) -> bool {
+        self.trace_enabled
+    }
+
+    fn relocate_mem(&self) -> bool {
+        self.relocate_mem
+    }
+
+    fn layout(&self) -> LayoutName {
+        self.layout
+    }
+
+    fn dynamic_layout_params(&self) -> Option<CairoLayoutParams> {
+        self.dynamic_layout_params.clone()
+    }
+
+    fn proof_mode(&self) -> bool {
+        self.proof_mode
+    }
+
+    fn disable_trace_padding(&self) -> bool {
+        // Always false in Cairo1.
+        false
+    }
+}
+
 impl Cairo1RunConfig<'_> {
     // Returns true if the flags in the config enable adding the output builtin and
     // copying input and output values into it's segment
@@ -256,14 +284,7 @@ pub fn cairo_run_program(
         RunnerMode::ExecutionMode
     };
 
-    let mut runner = CairoRunner::new_v2(
-        &program,
-        cairo_run_config.layout,
-        cairo_run_config.dynamic_layout_params.clone(),
-        runner_mode,
-        cairo_run_config.trace_enabled,
-        false,
-    )?;
+    let mut runner = CairoRunner::new_v2(&program, &cairo_run_config, runner_mode)?;
     let end = runner.initialize(cairo_run_config.proof_mode)?;
     load_arguments(&mut runner, &cairo_run_config, main_func)?;
 

vm/src/cairo_run.rs

@@ -24,7 +24,17 @@ use arbitrary::{self, Arbitrary};
 use core::fmt;
 use tracing::{info, span, Level};
 
+pub trait CommonCairoRunConfig {
+    fn trace_enabled(&self) -> bool;
+    fn relocate_mem(&self) -> bool;
+    fn layout(&self) -> LayoutName;
+    fn dynamic_layout_params(&self) -> Option<CairoLayoutParams>;
+    fn proof_mode(&self) -> bool;
+    fn disable_trace_padding(&self) -> bool;
+}
+
 #[cfg_attr(feature = "test_utils", derive(Arbitrary))]
+#[derive(Clone)]
 pub struct CairoRunConfig<'a> {
     #[cfg_attr(feature = "test_utils", arbitrary(value = "main"))]
     pub entrypoint: &'a str,
@@ -70,6 +80,32 @@ impl Default for CairoRunConfig<'_> {
     }
 }
 
+impl CommonCairoRunConfig for CairoRunConfig<'_> {
+    fn trace_enabled(&self) -> bool {
+        self.trace_enabled
+    }
+
+    fn relocate_mem(&self) -> bool {
+        self.relocate_mem
+    }
+
+    fn layout(&self) -> LayoutName {
+        self.layout
+    }
+
+    fn dynamic_layout_params(&self) -> Option<CairoLayoutParams> {
+        self.dynamic_layout_params.clone()
+    }
+
+    fn proof_mode(&self) -> bool {
+        self.proof_mode
+    }
+
+    fn disable_trace_padding(&self) -> bool {
+        self.disable_trace_padding
+    }
+}
+
 pub struct StwoCairoRunConfig {
     pub trace_enabled: bool,
     pub relocate_mem: bool,
@@ -92,6 +128,33 @@ impl Default for StwoCairoRunConfig {
     }
 }
 
+impl CommonCairoRunConfig for StwoCairoRunConfig {
+    fn trace_enabled(&self) -> bool {
+        self.trace_enabled
+    }
+
+    fn relocate_mem(&self) -> bool {
+        self.relocate_mem
+    }
+
+    fn layout(&self) -> LayoutName {
+        LayoutName::all_cairo_stwo
+    }
+
+    fn dynamic_layout_params(&self) -> Option<CairoLayoutParams> {
+        None
+    }
+
+    fn proof_mode(&self) -> bool {
+        // Unused.
+        true
+    }
+
+    fn disable_trace_padding(&self) -> bool {
+        self.disable_trace_padding
+    }
+}
+
 #[allow(clippy::result_large_err)]
 pub fn cairo_run_stwo(
     program: &Program,
@@ -104,12 +167,7 @@ pub fn cairo_run_stwo(
     let _span = span!(Level::INFO, "cairo run stwo").entered();
 
     let proof_mode = runner_mode != RunnerMode::ExecutionMode;
-    let mut cairo_runner = CairoRunner::new_stwo(
-        program,
-        runner_mode,
-        cairo_run_config.trace_enabled,
-        cairo_run_config.disable_trace_padding,
-    )?;
+    let mut cairo_runner = CairoRunner::new_stwo(program, cairo_run_config, runner_mode)?;
     cairo_runner.exec_scopes = exec_scopes;
 
     let end = cairo_runner.initialize_stwo(allowed_builtins)?;
@@ -163,14 +221,7 @@ pub fn cairo_run_program_with_initial_scope(
         .allow_missing_builtins
         .unwrap_or(cairo_run_config.proof_mode);
 
-    let mut cairo_runner = CairoRunner::new(
-        program,
-        cairo_run_config.layout,
-        cairo_run_config.dynamic_layout_params.clone(),
-        cairo_run_config.proof_mode,
-        cairo_run_config.trace_enabled,
-        cairo_run_config.disable_trace_padding,
-    )?;
+    let mut cairo_runner = CairoRunner::new(program, cairo_run_config)?;
 
     cairo_runner.exec_scopes = exec_scopes;
 
@@ -272,11 +323,10 @@ pub fn cairo_run_pie(
     let program = Program::from_stripped_program(&pie.metadata.program);
     let mut cairo_runner = CairoRunner::new(
         &program,
-        cairo_run_config.layout,
-        cairo_run_config.dynamic_layout_params.clone(),
-        false,
-        cairo_run_config.trace_enabled,
-        cairo_run_config.disable_trace_padding,
+        &CairoRunConfig {
+            proof_mode: false,
+            ..cairo_run_config.clone()
+        },
     )?;
 
     let end = cairo_runner.initialize(allow_missing_builtins)?;
@@ -352,12 +402,8 @@ pub fn cairo_run_pie_stwo(
     pie.run_validity_checks()?;
 
     let program = Program::from_stripped_program(&pie.metadata.program);
-    let mut cairo_runner = CairoRunner::new_stwo(
-        &program,
-        RunnerMode::ExecutionMode,
-        cairo_run_config.trace_enabled,
-        cairo_run_config.disable_trace_padding,
-    )?;
+    let mut cairo_runner =
+        CairoRunner::new_stwo(&program, cairo_run_config, RunnerMode::ExecutionMode)?;
 
     let end = cairo_runner.initialize_stwo(allowed_builtins)?;
     cairo_runner.vm.finalize_segments_by_cairo_pie(pie);
@@ -428,14 +474,7 @@ pub fn cairo_run_fuzzed_program(
         .allow_missing_builtins
         .unwrap_or(cairo_run_config.proof_mode);
 
-    let mut cairo_runner = CairoRunner::new(
-        &program,
-        cairo_run_config.layout,
-        cairo_run_config.dynamic_layout_params.clone(),
-        cairo_run_config.proof_mode,
-        cairo_run_config.trace_enabled,
-        cairo_run_config.disable_trace_padding,
-    )?;
+    let mut cairo_runner = CairoRunner::new(&program, &cairo_run_config)?;
 
     let _end = cairo_runner.initialize(allow_missing_builtins)?;
 

vm/src/tests/cairo_run_test.rs

@@ -1069,15 +1069,7 @@ fn run_program_with_custom_mod_builtin_params(
     };
     let mut hint_processor = BuiltinHintProcessor::new_empty();
     let program = Program::from_bytes(data, Some(cairo_run_config.entrypoint)).unwrap();
-    let mut cairo_runner = CairoRunner::new(
-        &program,
-        cairo_run_config.layout,
-        cairo_run_config.dynamic_layout_params,
-        cairo_run_config.proof_mode,
-        cairo_run_config.trace_enabled,
-        cairo_run_config.disable_trace_padding,
-    )
-    .unwrap();
+    let mut cairo_runner = CairoRunner::new(&program, &cairo_run_config).unwrap();
 
     let end = cairo_runner.initialize(false).unwrap();
     // Modify add_mod & mul_mod params

vm/src/tests/mod.rs

@@ -106,11 +106,10 @@ fn run_cairo_1_entrypoint(
 
     let mut runner = CairoRunner::new(
         &(contract_class.clone().try_into().unwrap()),
-        LayoutName::all_cairo,
-        None,
-        false,
-        false,
-        false,
+        &CairoRunConfig {
+            layout: LayoutName::all_cairo,
+            ..Default::default()
+        },
     )
     .unwrap();
 
@@ -213,11 +212,10 @@ fn run_cairo_1_entrypoint_with_run_resources(
 ) -> Result<Vec<Felt252>, CairoRunError> {
     let mut runner = CairoRunner::new(
         &(contract_class.clone().try_into().unwrap()),
-        LayoutName::all_cairo,
-        None,
-        false,
-        false,
-        false,
+        &CairoRunConfig {
+            layout: LayoutName::all_cairo,
+            ..Default::default()
+        },
     )
     .unwrap();