working but needs a redo to respect changes made in the main branch

Author: weijiekoh

Cargo.lock

@@ -57,7 +57,7 @@ pub fn is_undef(mem: &Memory, pos: usize) -> bool {
 }
 
 pub fn compile_range_checks(
-    first_exec: &lean_runner::ExecutionResult,
+    first_exec: &ExecutionResult,
     bytecode: &Bytecode,
 ) -> Result<Bytecode, RunnerError> {
     // Early return if no range checks exist

crates/lean_compiler/src/d_compile_range_checks.rs

@@ -1,6 +1,7 @@
 use std::collections::BTreeMap;
 
-use lean_runner::{ExecutionHistory, execute_bytecode, execute_bytecode_helper};
+use lean_runner::{execute_bytecode, execute_bytecode_helper};
+use lean_vm::ExecutionHistory;
 use lean_vm::*;
 
 pub use crate::{
@@ -23,15 +24,14 @@ mod parser;
 mod precompiles;
 pub use precompiles::PRECOMPILES;
 
-pub fn compile_program(program: &str) -> (Bytecode, BTreeMap<usize, String>) {
+/// Compile a program and return the bytecode. The public and private inputs are necessary as their
+/// contents may affect the memory layout required for the range-check compilation to work
+/// correctly.
+pub fn compile_program(program: &str, public_input: &[F], private_input: &[F]) -> (Bytecode, BTreeMap<usize, String>) {
     let (parsed_program, function_locations) = parse_program(program).unwrap();
-    // println!("Parsed program: {}", parsed_program.to_string());
     let simple_program = simplify_program(parsed_program);
-    // println!("Simplified program: {}", simple_program.to_string());
     let intermediate_bytecode = compile_to_intermediate_bytecode(simple_program).unwrap();
-    // println!("Intermediate Bytecode:\n\n{}", intermediate_bytecode.to_string());
     let mut compiled = compile_to_low_level_bytecode(intermediate_bytecode).unwrap();
-    //println!("Compiled Program:\n\n{}", compiled.to_string());
 
     // Check if range checks exist - if so, compile them
     if compiled
@@ -44,10 +44,9 @@ pub fn compile_program(program: &str) -> (Bytecode, BTreeMap<usize, String>) {
         let mut instruction_history = ExecutionHistory::default();
         let first_exec = execute_bytecode_helper(
             &compiled,
-            &[], // No public input for range check compilation
-            &[], // No private input for range check compilation
+            public_input,
+            private_input,
             MAX_RUNNER_MEMORY_SIZE / 2,
-            false,
             &mut std_out,
             &mut instruction_history,
             false,
@@ -63,13 +62,14 @@ pub fn compile_program(program: &str) -> (Bytecode, BTreeMap<usize, String>) {
 }
 
 pub fn compile_and_run(program: &str, public_input: &[F], private_input: &[F], profiler: bool) {
-    let (mut bytecode, function_locations) = compile_program(program);
+    let (bytecode, function_locations) = compile_program(program, public_input, private_input);
     let _r = execute_bytecode(
-        &mut bytecode,
+        &bytecode,
         public_input,
         private_input,
         program,
         &function_locations,
+        10000, // no_vec_runtime_memory
         profiler,
     );
 }

crates/lean_compiler/src/lib.rs

@@ -3,7 +3,8 @@ use lean_compiler::{
     compile_to_low_level_bytecode, simplify_program,
 };
 use lean_compiler::{compile_program, parse_program};
-use lean_runner::{ExecutionHistory, execute_bytecode, execute_bytecode_helper};
+use lean_runner::{execute_bytecode, execute_bytecode_helper};
+use lean_vm::{ExecutionHistory, ExecutionResult};
 use lean_vm::core::Label;
 use lean_vm::*;
 use p3_field::PrimeCharacteristicRing;
@@ -99,7 +100,7 @@ fn do_test_range_check(v: usize, t: usize, verbose: bool) {
     let max_runner_memory_size: usize = 1 << 24;
 
     let program = range_check_program(v, t);
-    let (bytecode, function_locations) = compile_program(&program); // Range checks are automatically compiled now
+    let (bytecode, function_locations) = compile_program(&program, &[], &[]);
 
     if verbose {
         println!("Range Check Test: v: {}, t: {} ==============", v, t);
@@ -115,7 +116,6 @@ fn do_test_range_check(v: usize, t: usize, verbose: bool) {
         &[],
         &[],
         max_runner_memory_size / 2,
-        false,
         &mut std_out,
         &mut instruction_history,
         false,
@@ -144,6 +144,12 @@ fn do_test_range_check(v: usize, t: usize, verbose: bool) {
     }
 }
 
+#[test]
+fn test_range_check_execution() {
+    do_test_range_check(0, 1, false);
+}
+
+
 /// Test that the range check keyword is parsed and compiled (steps a to c only).
 #[test]
 fn test_range_check_parsing_and_compilation() {
@@ -268,7 +274,6 @@ fn do_test_invalid_range_check(v: usize, t: usize) {
         println!("Execution complete but the range check failed to OOM");
         assert!(false, "range check failed to catch OOM");
     }
-    println!("result: {}", result.as_ref().unwrap_err());
     assert!(matches!(&result, Err(RunnerError::OutOfMemory)));
 }
 
@@ -445,20 +450,21 @@ fn test_deref() {
     };
     println!("bytecode:\n{}", bytecode.to_string());
     let execution_result = execute_bytecode(
-        &mut bytecode,
+        &bytecode,
         &[],                                // public input
         &[],                                // private input
         "",                                 // no source code for debug
         &std::collections::BTreeMap::new(), // no function locations
+        1 << 23,                            // no_vec_runtime_memory
         false,                              // no profiler
     );
 
-    assert!(execution_result.is_ok());
+    // execution_result is now ExecutionResult struct, not a Result
+    assert!(execution_result.pcs.len() > 0); // Basic check that execution completed
 }
 
-fn range_check(v: usize, t: usize) -> Result<lean_runner::ExecutionResult, RunnerError> {
+fn range_check(v: usize, t: usize) -> Result<ExecutionResult, RunnerError> {
     let starting_frame_memory = 5;
-    println!("v: {}; t: {}", v, t);
     let val = F::from_usize(v);
 
     // In the final version, these values will have to be set after a first execution pass
@@ -571,13 +577,16 @@ fn range_check(v: usize, t: usize) -> Result<lean_runner::ExecutionResult, Runne
     };
 
     // Execute the bytecode
-    let execution_result = execute_bytecode(
-        &mut bytecode,
-        &[],                                // public input
-        &[],                                // private input
-        "",                                 // no source code for debug
-        &std::collections::BTreeMap::new(), // no function locations
-        false,                              // no profiler
-    );
-    execution_result
+    let execution_result = execute_bytecode_helper(
+        &bytecode,
+        &[],
+        &[],
+        1 << 23,
+        &mut String::new(),
+        &mut ExecutionHistory::new(),
+        false,
+        &BTreeMap::new(),
+    )?;
+
+    Ok(execution_result)
 }

crates/lean_compiler/tests/test_range_check.rs

@@ -48,14 +48,14 @@ pub fn prove_execution(
         memory, // padded with zeros to next power of two
     } = info_span!("Witness generation").in_scope(|| {
         let execution_result = execute_bytecode(
-            &mut bytecode.clone(),
+            bytecode,
             public_input,
             private_input,
             source_code,
             function_locations,
+            _no_vec_runtime_memory,
             vm_profiler,
-        )
-        .unwrap();
+        );
         get_execution_trace(bytecode, execution_result)
     });
 

crates/lean_prover/src/prove_execution.rs

@@ -1,5 +1,6 @@
 use crate::common::*;
 use crate::*;
+use lean_runner::build_public_memory;
 use ::air::table::AirTable;
 use lean_vm::*;
 use lookup::verify_gkr_product;

crates/lean_prover/src/verify_execution.rs

@@ -80,7 +80,7 @@ fn test_zk_vm() {
         .collect::<Vec<_>>();
 
     // utils::init_tracing();
-    let (bytecode, function_locations) = compile_program(&program_str);
+    let (bytecode, function_locations) = compile_program(&program_str, &public_input, &private_input);
     let proof_data = prove_execution(
         &bytecode,
         &program_str,

crates/lean_prover/tests/test_zkvm.rs

@@ -4,7 +4,7 @@ use crate::{
     COL_INDEX_MEM_VALUE_A, COL_INDEX_MEM_VALUE_B, COL_INDEX_MEM_VALUE_C, COL_INDEX_PC,
     N_EXEC_COLUMNS, N_INSTRUCTION_COLUMNS,
 };
-use lean_runner::ExecutionResult;
+use crate::execution_trace::ExecutionResult;
 use lean_vm::*;
 use p3_field::Field;
 use p3_field::PrimeCharacteristicRing;

crates/lean_prover/witness_generation/src/execution_trace.rs

@@ -1,8 +1,5 @@
-mod profiler;
+//! VM execution engine and memory management
+
 pub mod runner;
-pub mod stack_trace;
 
-pub use runner::{
-    ExecutionHistory, ExecutionResult, build_public_memory, execute_bytecode,
-    execute_bytecode_helper,
-};
+pub use runner::*;