feat: Refine benchmark runner API

crates/benchmark-runner/src/lib.rs

@@ -39,7 +39,13 @@ where
     });
 }
 
-pub fn run_benchmark_ere<V>(host_name: &str, zkvm_instance: V) -> Result<()>
+/// Action specifies whether we should prove or execute
+pub enum Action {
+    Prove,
+    Execute,
+}
+
+pub fn run_benchmark_ere<V>(host_name: &str, zkvm_instance: V, action: Action) -> Result<()>
 where
     // C: Compiler + Send + Sync,
     // C::Error: std::error::Error + Send + Sync + 'static,
@@ -65,15 +71,30 @@ where
             stdin.write(ci);
             stdin.write(bw.network);
 
-            let report = zkvm_ref.execute(&stdin)?;
-            let region_cycles: HashMap<_, _> = report.region_cycles.into_iter().collect();
-
-            reports.push(WorkloadMetrics {
-                name: format!("{}-{}", bw.name, block_number),
-                total_num_cycles: report.total_num_cycles,
-                region_cycles,
-                proving_time_ms: 0,
-            });
+            let workload_metrics = match action {
+                Action::Execute => {
+                    let report = zkvm_ref.execute(&stdin)?;
+                    let region_cycles: HashMap<_, _> = report.region_cycles.into_iter().collect();
+                    WorkloadMetrics {
+                        name: format!("{}-{}", bw.name, block_number),
+                        total_num_cycles: report.total_num_cycles,
+                        region_cycles,
+                        proving_time_ms: 0,
+                    }
+                }
+                Action::Prove => {
+                    let (proof, report) = zkvm_ref.prove(&stdin)?;
+
+                    WorkloadMetrics {
+                        name: format!("{}-{}", bw.name, block_number),
+                        total_num_cycles: 0,
+                        region_cycles: Default::default(),
+                        proving_time_ms: report.proving_time.as_millis(),
+                    }
+                }
+            };
+
+            reports.push(workload_metrics);
         }
 
         let out_path = format!(

crates/ere-hosts/src/main.rs

@@ -2,31 +2,35 @@
 
 use std::path::PathBuf;
 
-use benchmark_runner::run_benchmark_ere;
+use benchmark_runner::{Action, run_benchmark_ere};
 use ere_risczero::{EreRisc0, RV32_IM_RISCZERO_ZKVM_ELF};
 use ere_sp1::{EreSP1, RV32_IM_SUCCINCT_ZKVM_ELF};
 use zkvm_interface::{Compiler, ProverResourceType};
 
 /// Main entry point for the host benchmarker
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let sp1_zkvm = new_sp1_zkvm()?;
-    run_benchmark_ere("sp1", sp1_zkvm)?;
+    let resource = ProverResourceType::Cpu;
+    let sp1_zkvm = new_sp1_zkvm(resource)?;
+    let action = Action::Execute;
+    run_benchmark_ere("sp1", sp1_zkvm, action)?;
 
-    let risc0_zkvm = new_risczero_zkvm()?;
-    run_benchmark_ere("risc0", risc0_zkvm)?;
+    let resource = ProverResourceType::Cpu;
+    let risc0_zkvm = new_risczero_zkvm(resource)?;
+    let action = Action::Execute;
+    run_benchmark_ere("risc0", risc0_zkvm, action)?;
 
     // TODO: Add more backends
     Ok(())
 }
 
-fn new_sp1_zkvm() -> Result<EreSP1, Box<dyn std::error::Error>> {
-    let prover_resource = ProverResourceType::Cpu;
+fn new_sp1_zkvm(prover_resource: ProverResourceType) -> Result<EreSP1, Box<dyn std::error::Error>> {
     let guest_dir = concat!(env!("CARGO_WORKSPACE_DIR"), "ere-guests/sp1");
     let program = RV32_IM_SUCCINCT_ZKVM_ELF::compile(&PathBuf::from(guest_dir))?;
     Ok(EreSP1::new(program, prover_resource))
 }
-fn new_risczero_zkvm() -> Result<EreRisc0, Box<dyn std::error::Error>> {
-    let prover_resource = ProverResourceType::Cpu;
+fn new_risczero_zkvm(
+    prover_resource: ProverResourceType,
+) -> Result<EreRisc0, Box<dyn std::error::Error>> {
     let guest_dir = concat!(env!("CARGO_WORKSPACE_DIR"), "ere-guests/risc0");
     let program = RV32_IM_RISCZERO_ZKVM_ELF::compile(&PathBuf::from(guest_dir))?;
     Ok(EreRisc0::new(program, prover_resource))

crates/metrics/src/lib.rs

@@ -16,7 +16,7 @@ pub struct WorkloadMetrics {
     /// Region-specific cycles, mapping region names (e.g., "setup", "compute") to their cycle counts.
     pub region_cycles: HashMap<String, u64>,
     /// Proving time in milliseconds
-    pub proving_time_ms: u64,
+    pub proving_time_ms: u128,
 }
 
 /// Errors that can occur during metrics processing.