fix(new-execution): make rv32im hintstore work (#1616)

- make `Rv32HintStoreChip` use the `NewVmChipWrapper`
- rename `SingleTraceStep` to `TraceStep` and update it to work for
chips whose execution creates multiple trace rows
- comment out criterion execute benchmarks for now

Author: jonathanpwang

Cargo.lock

@@ -28,6 +28,7 @@ tracing-subscriber = { version = "0.3.17", features = ["std", "env-filter"] }
 
 [dev-dependencies]
 criterion = { version = "0.5", features = ["html_reports"] }
+divan = { version = "0.1.21" }
 
 [features]
 default = ["jemalloc"]
@@ -37,12 +38,16 @@ jemalloc-prof = ["openvm-circuit/jemalloc-prof"]
 nightly-features = ["openvm-circuit/nightly-features"]
 profiling = ["openvm-circuit/function-span", "openvm-transpiler/function-span"]
 
-[[bench]]
-name = "fibonacci_execute"
-harness = false
+# [[bench]]
+# name = "fibonacci_execute"
+# harness = false
+
+# [[bench]]
+# name = "regex_execute"
+# harness = false
 
 [[bench]]
-name = "regex_execute"
+name = "execute"
 harness = false
 
 [package.metadata.cargo-shear]

benchmarks/execute/Cargo.toml

@@ -0,0 +1,57 @@
+use divan;
+use eyre::Result;
+use openvm_benchmarks_utils::{get_elf_path, get_programs_dir, read_elf_file};
+use openvm_circuit::arch::{instructions::exe::VmExe, VmExecutor};
+use openvm_rv32im_circuit::Rv32ImConfig;
+use openvm_rv32im_transpiler::{
+    Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension,
+};
+use openvm_stark_sdk::p3_baby_bear::BabyBear;
+use openvm_transpiler::{transpiler::Transpiler, FromElf};
+use std::path::PathBuf;
+
+static AVAILABLE_PROGRAMS: &[&str] = &[
+    "fibonacci_recursive",
+    "fibonacci_iterative",
+    "quicksort",
+    "bubblesort",
+    // "pairing",
+    // "keccak256",
+    // "keccak256_iter",
+    // "sha256",
+    // "sha256_iter",
+    // "revm_transfer",
+    // "revm_snailtracer",
+];
+
+fn main() {
+    divan::main();
+}
+
+/// Run a specific OpenVM program
+fn run_program(program: &str) -> Result<()> {
+    let program_dir = get_programs_dir().join(program);
+    let elf_path = get_elf_path(&program_dir);
+    let elf = read_elf_file(&elf_path)?;
+
+    let vm_config = Rv32ImConfig::default();
+
+    let transpiler = Transpiler::<BabyBear>::default()
+        .with_extension(Rv32ITranspilerExtension)
+        .with_extension(Rv32IoTranspilerExtension)
+        .with_extension(Rv32MTranspilerExtension);
+
+    let exe = VmExe::from_elf(elf, transpiler)?;
+
+    let executor = VmExecutor::new(vm_config);
+    executor
+        .execute_e1(exe, vec![])
+        .expect("Failed to execute program");
+
+    Ok(())
+}
+
+#[divan::bench(args = AVAILABLE_PROGRAMS, sample_count=10)]
+fn benchmark_execute(program: &str) {
+    run_program(program).unwrap();
+}

benchmarks/execute/benches/execute.rs

@@ -5,7 +5,8 @@ use openvm_rv32im_circuit::Rv32ImConfig;
 use openvm_rv32im_transpiler::{
     Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension,
 };
-use openvm_sdk::StdIn;
+// TODO(ayush): add this back
+// use openvm_sdk::StdIn;
 use openvm_stark_sdk::p3_baby_bear::BabyBear;
 use openvm_transpiler::{transpiler::Transpiler, FromElf};
 
@@ -28,10 +29,11 @@ fn benchmark_function(c: &mut Criterion) {
 
     group.bench_function("execute", |b| {
         b.iter(|| {
-            let n = 100_000u64;
-            let mut stdin = StdIn::default();
-            stdin.write(&n);
-            executor.execute(exe.clone(), stdin).unwrap();
+            // TODO(ayush): add this back
+            // let n = 100_000u64;
+            // let mut stdin = StdIn::default();
+            // stdin.write(&n);
+            executor.execute(exe.clone(), vec![]).unwrap();
         })
     });
 

benchmarks/execute/benches/fibonacci_execute.rs

@@ -1,47 +1,47 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use openvm_benchmarks_utils::{build_elf, get_programs_dir};
-use openvm_circuit::arch::{instructions::exe::VmExe, VmExecutor};
-use openvm_keccak256_circuit::Keccak256Rv32Config;
-use openvm_keccak256_transpiler::Keccak256TranspilerExtension;
-use openvm_rv32im_transpiler::{
-    Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension,
-};
-use openvm_sdk::StdIn;
-use openvm_stark_sdk::p3_baby_bear::BabyBear;
-use openvm_transpiler::{transpiler::Transpiler, FromElf};
+// TODO(ayush): add this back
+// use criterion::{black_box, criterion_group, criterion_main, Criterion};
+// use openvm_benchmarks_utils::{build_elf, get_programs_dir};
+// use openvm_circuit::arch::{instructions::exe::VmExe, VmExecutor};
+// use openvm_keccak256_circuit::Keccak256Rv32Config;
+// use openvm_keccak256_transpiler::Keccak256TranspilerExtension;
+// use openvm_rv32im_transpiler::{
+//     Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension,
+// };
+// use openvm_sdk::StdIn;
+// use openvm_stark_sdk::p3_baby_bear::BabyBear;
+// use openvm_transpiler::{transpiler::Transpiler, FromElf};
 
-fn benchmark_function(c: &mut Criterion) {
-    let program_dir = get_programs_dir().join("regex");
-    let elf = build_elf(&program_dir, "release").unwrap();
+// fn benchmark_function(c: &mut Criterion) {
+//     let program_dir = get_programs_dir().join("regex");
+//     let elf = build_elf(&program_dir, "release").unwrap();
 
-    let exe = VmExe::from_elf(
-        elf,
-        Transpiler::<BabyBear>::default()
-            .with_extension(Rv32ITranspilerExtension)
-            .with_extension(Rv32MTranspilerExtension)
-            .with_extension(Rv32IoTranspilerExtension)
-            .with_extension(Keccak256TranspilerExtension),
-    )
-    .unwrap();
+//     let exe = VmExe::from_elf(
+//         elf,
+//         Transpiler::<BabyBear>::default()
+//             .with_extension(Rv32ITranspilerExtension)
+//             .with_extension(Rv32MTranspilerExtension)
+//             .with_extension(Rv32IoTranspilerExtension)
+//             .with_extension(Keccak256TranspilerExtension),
+//     )
+//     .unwrap();
 
-    let mut group = c.benchmark_group("regex");
-    group.sample_size(10);
-    let config = Keccak256Rv32Config::default();
-    let executor = VmExecutor::<BabyBear, Keccak256Rv32Config>::new(config);
+//     let mut group = c.benchmark_group("regex");
+//     group.sample_size(10);
+//     let config = Keccak256Rv32Config::default();
+//     let executor = VmExecutor::<BabyBear, Keccak256Rv32Config>::new(config);
 
-    let data = include_str!("../../guest/regex/regex_email.txt");
+//     let data = include_str!("../../guest/regex/regex_email.txt");
 
-    let fe_bytes = data.to_owned().into_bytes();
-    group.bench_function("execute", |b| {
-        b.iter(|| {
-            executor
-                .execute(exe.clone(), black_box(StdIn::from_bytes(&fe_bytes)))
-                .unwrap();
-        })
-    });
+//     let fe_bytes = data.to_owned().into_bytes();
+//     group.bench_function("execute", |b| {
+//         b.iter(|| {
+//             let input = black_box(Stdin::from_bytes(&fe_bytes));
+//             executor.execute(exe.clone(), input).unwrap();
+//         })
+//     });
 
-    group.finish();
-}
+//     group.finish();
+// }
 
-criterion_group!(benches, benchmark_function);
-criterion_main!(benches);
+// criterion_group!(benches, benchmark_function);
+// criterion_main!(benches);

benchmarks/execute/benches/regex_execute.rs

@@ -26,6 +26,7 @@ where
     fn new(chip_complex: &VmChipComplex<F, VC::Executor, VC::Periphery>) -> Self;
 
     /// Determines if execution should stop
+    // TODO(ayush): rename to should_suspend
     fn should_stop(&mut self, chip_complex: &VmChipComplex<F, VC::Executor, VC::Periphery>)
         -> bool;