refactor sdk cycle counting

crates/integration/src/lib.rs

@@ -1,7 +1,7 @@
 use crate::axiom::AxiomProver;
 use cargo_metadata::MetadataCommand;
 use once_cell::sync::OnceCell;
-use openvm_sdk::StdIn;
+use openvm_sdk::{Sdk, StdIn};
 use scroll_zkvm_prover::{
     Prover,
     setup::{read_app_config, read_app_exe},
@@ -364,8 +364,8 @@ pub fn tester_execute<T: ProverTester>(
             .map(|p| p.as_stark_proof().expect("must be stark proof")),
     )?;
 
-    let ret =
-        scroll_zkvm_prover::utils::vm::execute_guest(app_config.app_vm_config, &app_exe, &stdin)?;
+    let sdk = Sdk::new(app_config)?;
+    let ret = scroll_zkvm_prover::utils::vm::execute_guest(&sdk, app_exe, &stdin)?;
     Ok(ret)
 }
 

crates/prover/src/prover/mod.rs

@@ -173,10 +173,8 @@ impl Prover {
         stdin: &StdIn,
     ) -> Result<crate::utils::vm::ExecutionResult, Error> {
         let sdk = self.get_sdk()?;
-        let config = sdk.app_config();
         let t = std::time::Instant::now();
-        let exec_result =
-            crate::utils::vm::execute_guest(config.app_vm_config.clone(), &self.app_exe, stdin)?;
+        let exec_result = crate::utils::vm::execute_guest(sdk, self.app_exe.clone(), stdin)?;
         let execution_time_mills = t.elapsed().as_millis() as u64;
         let execution_time_s = execution_time_mills as f32 / 1000.0f32;
         let exec_speed = (exec_result.total_cycle as f32 / 1_000_000.0f32) / execution_time_s; // MHz

crates/prover/src/utils/vm.rs

@@ -1,12 +1,4 @@
-use std::sync::Arc;
-
-use openvm_circuit::{
-    arch::{VmExecutor, instructions::exe::VmExe},
-    system::{
-        memory::merkle::public_values::extract_public_values, program::trace::VmCommittedExe,
-    },
-};
-use openvm_sdk::{F, SC, StdIn, config::SdkVmConfig};
+use openvm_sdk::{Sdk, StdIn, types::ExecutableFormat};
 
 use crate::Error;
 
@@ -16,28 +8,15 @@ pub struct ExecutionResult {
     pub public_values: Vec<u8>,
 }
 
-#[derive(Default)]
-pub struct DebugInput {
-    pub mock_prove: bool,
-    pub commited_exe: Option<Arc<VmCommittedExe<SC>>>,
-}
-
 pub fn execute_guest(
-    vm_config: SdkVmConfig,
-    exe: &VmExe<F>,
+    sdk: &Sdk,
+    exe: impl Into<ExecutableFormat>,
     stdin: &StdIn,
 ) -> Result<ExecutionResult, Error> {
-    let executor = VmExecutor::new(vm_config.clone()).expect("invalid config");
-    let instance = executor.instance(exe).expect("invalid exe");
-
-    let state = instance
-        .execute(stdin.clone(), None)
+    let (public_values, (_cost, total_cycle)) = sdk
+        .execute_metered_cost(exe, stdin.clone())
         .map_err(|e| Error::GenProof(e.to_string()))?;
-    let total_cycle = state.instret();
-    let final_memory = state.memory;
 
-    let public_values: Vec<u8> =
-        extract_public_values(vm_config.as_ref().num_public_values, &final_memory.memory);
     tracing::debug!(name: "public_values after guest execution", ?public_values);
     if public_values.iter().all(|x| *x == 0) {
         return Err(Error::GenProof("public_values are all 0s".to_string()));