Revamp lean vm (#56)

* utils: faster add_multilinears

* cleanup

* utils: add add_multilinears_inplace

* chore: revamp lean vm crate

* fmt

* add memory tests

* add update_call_counters

* make some functions constants

* fmt

* more constant values

Author: tcoratger

crates/lean_vm/src/core/constants.rs

@@ -0,0 +1,28 @@
+//! VM constants and configuration
+
+/// Vector dimension for field operations
+pub const DIMENSION: usize = 5;
+
+/// Logarithm of vector length
+pub const LOG_VECTOR_LEN: usize = 3;
+
+/// Vector length (2^LOG_VECTOR_LEN)
+pub const VECTOR_LEN: usize = 1 << LOG_VECTOR_LEN;
+
+/// Convention: vectorized pointer of size 2, pointing to 16 zeros
+pub const ZERO_VEC_PTR: usize = 0;
+
+/// Convention: vectorized pointer of size 1, pointing to 10000000
+pub const ONE_VEC_PTR: usize = 2;
+
+/// Convention: vectorized pointer of size 2, = the 16 elements of poseidon_16(0)
+pub const POSEIDON_16_NULL_HASH_PTR: usize = 3;
+
+/// Convention: vectorized pointer of size 1, = the last 8 elements of poseidon_24(0)
+pub const POSEIDON_24_NULL_HASH_PTR: usize = 5;
+
+/// Normal pointer to start of public input
+pub const PUBLIC_INPUT_START: usize = 6 * 8;
+
+/// Maximum memory size for VM runner
+pub const MAX_RUNNER_MEMORY_SIZE: usize = 1 << 20;

crates/lean_vm/src/core/mod.rs

@@ -0,0 +1,7 @@
+//! Core VM abstractions and type definitions
+
+pub mod constants;
+pub mod types;
+
+pub use constants::*;
+pub use types::*;

crates/lean_vm/src/core/types.rs

@@ -0,0 +1,12 @@
+//! Core type definitions for the VM
+
+use p3_koala_bear::{KoalaBear, QuinticExtensionFieldKB};
+
+/// Base field type for VM operations
+pub type F = KoalaBear;
+
+/// Extension field type for VM operations
+pub type EF = QuinticExtensionFieldKB;
+
+/// Location in source code for debugging
+pub type LocationInSourceCode = usize;

crates/lean_vm/src/diagnostics/error.rs

@@ -0,0 +1,62 @@
+//! VM error types and execution results
+
+use crate::core::F;
+use crate::execution::Memory;
+use crate::witness::{
+    WitnessDotProduct, WitnessMultilinearEval, WitnessPoseidon16, WitnessPoseidon24,
+};
+use thiserror::Error;
+
+/// Errors that can occur during VM execution
+#[derive(Debug, Clone, Error)]
+pub enum RunnerError {
+    #[error("Out of memory")]
+    OutOfMemory,
+
+    #[error("Memory already set")]
+    MemoryAlreadySet,
+
+    #[error("Not a pointer")]
+    NotAPointer,
+
+    #[error("Division by zero")]
+    DivByZero,
+
+    #[error("Computation invalid: {0} != {1}")]
+    NotEqual(F, F),
+
+    #[error("Undefined memory access")]
+    UndefinedMemory,
+
+    #[error("Program counter out of bounds")]
+    PCOutOfBounds,
+
+    #[error("Point for multilinear eval not padded with zeros")]
+    MultilinearEvalPointNotPadded,
+}
+
+/// Result type for VM operations
+pub type VMResult<T> = Result<T, RunnerError>;
+
+/// Execution result containing outputs and execution data
+#[derive(Debug)]
+pub struct ExecutionResult {
+    pub no_vec_runtime_memory: usize,
+    pub public_memory_size: usize,
+    pub memory: Memory,
+    pub pcs: Vec<usize>,
+    pub fps: Vec<usize>,
+    pub poseidons_16: Vec<WitnessPoseidon16>,
+    pub poseidons_24: Vec<WitnessPoseidon24>,
+    pub dot_products: Vec<WitnessDotProduct>,
+    pub multilinear_evals: Vec<WitnessMultilinearEval>,
+}
+
+impl ExecutionResult {
+    /// Check if execution was successful
+    ///
+    /// TODO: placeholder for now.
+    pub fn is_success(&self) -> bool {
+        true
+    }
+}

crates/lean_vm/src/diagnostics/mod.rs

@@ -0,0 +1,10 @@
+//! Diagnostics, error handling, and debugging utilities
+#![allow(unused_imports)]
+
+pub mod error;
+pub mod profiler;
+pub mod stack_trace;
+
+pub use error::*;
+pub use profiler::*;
+pub use stack_trace::*;

crates/lean_vm/src/profiler.rs …ates/lean_vm/src/diagnostics/profiler.rscrates/lean_vm/src/profiler.rs renamed to crates/lean_vm/src/diagnostics/profiler.rs crates/lean_vm/src/profiler.rs renamed to crates/lean_vm/src/diagnostics/profiler.rs

@@ -0,0 +1,69 @@
+//! Execution context and state management
+
+use crate::core::LocationInSourceCode;
+use std::collections::BTreeMap;
+
+/// Execution history for profiling and debugging
+#[derive(Debug, Clone, Default)]
+pub struct ExecutionHistory {
+    pub lines: Vec<LocationInSourceCode>,
+    pub cycles: Vec<usize>, // for each line, how many cycles it took
+}
+
+impl ExecutionHistory {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn add_line(&mut self, location: LocationInSourceCode, cycles: usize) {
+        self.lines.push(location);
+        self.cycles.push(cycles);
+    }
+
+    pub fn total_cycles(&self) -> usize {
+        self.cycles.iter().sum()
+    }
+
+    pub const fn len(&self) -> usize {
+        self.lines.len()
+    }
+
+    pub const fn is_empty(&self) -> bool {
+        self.lines.is_empty()
+    }
+}
+
+/// VM execution context
+#[derive(Debug)]
+pub struct ExecutionContext<'a> {
+    pub source_code: &'a str,
+    pub function_locations: &'a BTreeMap<usize, String>,
+    pub profiler_enabled: bool,
+    pub std_out: String,
+    pub instruction_history: ExecutionHistory,
+}
+
+impl<'a> ExecutionContext<'a> {
+    pub fn new(
+        source_code: &'a str,
+        function_locations: &'a BTreeMap<usize, String>,
+        profiler_enabled: bool,
+    ) -> Self {
+        Self {
+            source_code,
+            function_locations,
+            profiler_enabled,
+            std_out: String::new(),
+            instruction_history: ExecutionHistory::new(),
+        }
+    }
+
+    pub fn print(&mut self, message: &str) {
+        self.std_out.push_str(message);
+    }
+
+    pub fn println(&mut self, message: &str) {
+        self.std_out.push_str(message);
+        self.std_out.push('\n');
+    }
+}