fix: debugging

Author: Maillew

benchmarks/guest/fibonacci/src/main.rs

@@ -2,58 +2,46 @@ use core::ptr;
 
 openvm::entry!(main);
 
-// Explicitly use the C memcpy function to ensure we're using custom memcpy
-extern "C" {
-    // in rust, u8 is 1 byte of memory
-    fn memcpy(dst: *mut u8, src: *const u8, n: usize) -> *mut u8;
-}
-
-/// Test function that explicitly calls memcpy to verify custom implementation
-pub fn test_custom_memcpy(dst: &mut [u8], src: &[u8], shift: usize) {
+#[no_mangle]
+pub fn append<T>(dst: &mut [T], src: &mut [T], shift: usize) {
     let src_len = src.len();
     let dst_len = dst.len();
 
-    // Bounds checking
-    if shift + src_len > dst_len {
-        return; // Just return on bounds error
-    }
-
     unsafe {
-        let dst_ptr = dst.as_mut_ptr().add(shift);
+        // The call to add is always safe because `Vec` will never
+        // allocate more than `isize::MAX` bytes.
+        let dst_ptr = dst.as_mut_ptr().wrapping_add(shift);
         let src_ptr = src.as_ptr();
+        println!("dst_ptr: {}", dst_ptr as usize); // these have the same pointer destination (basically), in between runs
+        println!("src_ptr: {}", src_ptr as usize);
+        println!("src_len: {}", src_len);
 
-        // This will definitely use our custom memcpy implementation
-        memcpy(dst_ptr, src_ptr, src_len);
+        ptr::copy_nonoverlapping(src_ptr, dst_ptr, src_len);
     }
 }
 
 pub fn main() {
-    let mut a: [u8; 1000] = [1; 1000];
-    for i in 0..1000 {
-        a[i] = 1 as u8;
-    }
-    let mut b: [u8; 500] = [2; 500];
-    for i in 0..500 {
-        b[i] = 2 as u8;
-    }
-
-    let shift: usize = 3;
+    const n: usize = 32;
 
-    // Test the custom memcpy
-    test_custom_memcpy(&mut a, &b, shift);
+    let mut a: [u8; 2 * n] = [0; 2 * n];
+    let mut b: [u8; n] = [2; n];
 
-    for i in 0..1000 {
+    let shift: usize = 1;
+    for i in 0..n {
+        b[i] = i as u8 + 1 as u8;
+    }
+    println!("b: {:?}", b);
+    append(&mut a, &mut b, shift);
+    let mut idx = 0;
+    for i in 0..2 * n {
         if i < shift || i >= shift + b.len() {
-            assert_eq!(a[i], 1);
+            assert_eq!(a[i], 0);
         } else {
-            assert_eq!(a[i], 2);
+            assert_eq!(a[i], b[idx]);
+            idx += 1;
         }
     }
 
     println!("a: {:?}", a);
     println!("b: {:?}", b);
 }
-/*
-ok what lolll
-memcpy works (??)
-*/

crates/vm/src/arch/execution_mode/metered/ctx.rs

@@ -225,6 +225,14 @@ impl<const PAGE_BITS: usize> ExecutionCtxTrait for MeteredCtx<PAGE_BITS> {
 impl<const PAGE_BITS: usize> MeteredExecutionCtxTrait for MeteredCtx<PAGE_BITS> {
     #[inline(always)]
     fn on_height_change(&mut self, chip_idx: usize, height_delta: u32) {
+        if chip_idx == 10 {
+            eprintln!(
+                "crates/vm/src/arch/execution_mode/metered/ctx.rs::on_height_change: AIR[10] height change: {} -> {} (delta: {})",
+                self.trace_heights[10],
+                self.trace_heights[10].wrapping_add(height_delta),
+                height_delta
+            );
+        }
         debug_assert!(
             chip_idx < self.trace_heights.len(),
             "chip_idx out of bounds"

crates/vm/src/arch/interpreter.rs

@@ -760,12 +760,16 @@ where
             let pre_inst = if let Some((inst, _)) = inst_opt {
                 tracing::trace!("get_metered_pre_compute_instruction {inst:?}");
                 let pc = program.pc_base + i as u32 * DEFAULT_PC_STEP;
+                println!("crates/vm/src/arch/interpreter.rs::get_metered_pre_compute_instructions: inst: opcode {:?}", inst.opcode.as_usize());
                 if let Some(handler) = get_system_opcode_handler(inst, buf) {
                     PreComputeInstruction {
                         handler,
                         pre_compute: buf,
                     }
                 } else if let Some(&executor_idx) = inventory.instruction_lookup.get(&inst.opcode) {
+                    if inst.opcode.as_usize() == 595 {  // MULHU opcode
+                        println!("crates/vm/src/arch/interpreter.rs::get_metered_pre_compute_instructions: MULHU instruction (opcode 595) being routed to metered execution, executor_idx: {}", executor_idx);  
+                    } 
                     let executor_idx = executor_idx as usize;
                     let executor = inventory
                         .executors

crates/vm/src/arch/record_arena.rs

@@ -90,8 +90,18 @@ impl<F: Field> MatrixRecordArena<F> {
     }
 
     pub fn alloc_buffer(&mut self, num_rows: usize) -> &mut [u8] {
-        let start = self.trace_offset;
+        let start: usize = self.trace_offset;
+
         self.trace_offset += num_rows * self.width;
+        if start >= self.trace_buffer.len() {
+            eprintln!("crates/vm/src/arch/record_arena.rs::alloc_buffer: start >= self.trace_buffer.len()");
+            eprintln!("start = {:?}", start);
+            eprintln!("self.trace_offset = {:?}", self.trace_offset);
+            eprintln!("self.trace_buffer.len() = {:?}", self.trace_buffer.len());
+            eprintln!("self.width = {:?}", self.width);
+            eprintln!("num_rows = {:?}", num_rows);
+        }
+
         let row_slice = &mut self.trace_buffer[start..self.trace_offset];
         let size = size_of_val(row_slice);
         let ptr = row_slice as *mut [F] as *mut u8;
@@ -111,6 +121,15 @@ impl<F: Field> Arena for MatrixRecordArena<F> {
     fn with_capacity(height: usize, width: usize) -> Self {
         let height = next_power_of_two_or_zero(height);
         let trace_buffer = F::zero_vec(height * width);
+        eprintln!(
+            "crates/vm/src/arch/record_arena.rs::with_capacity: with capacity called, height = {:?}, width = {:?}",
+            height, width
+        );
+        // height * width is wrong?
+        // i think bug is here? on constructor the trace buffer
+        // isn't allocated to be the correct size
+        // eprintln!("height, width = {:?}, {:?}", height, width);
+        // eprintln!("trace_buffer.len() = {:?}", trace_buffer.len());
         Self {
             trace_buffer,
             width,
@@ -133,6 +152,10 @@ impl<F: Field> RowMajorMatrixArena<F> for MatrixRecordArena<F> {
     fn set_capacity(&mut self, trace_height: usize) {
         let size = trace_height * self.width;
         // PERF: use memset
+        // eprintln!("set_capacity called");
+        // eprintln!("size = {:?}", size);
+        // eprintln!("trace_height = {:?}", trace_height);
+        // eprintln!("self.width = {:?}", self.width);
         self.trace_buffer.resize(size, F::ZERO);
     }
 
@@ -145,6 +168,7 @@ impl<F: Field> RowMajorMatrixArena<F> for MatrixRecordArena<F> {
     }
 
     fn into_matrix(mut self) -> RowMajorMatrix<F> {
+        // eprintln!("into_matrix called");
         let width = self.width();
         assert_eq!(self.trace_offset() % width, 0);
         let rows_used = self.trace_offset() / width;
@@ -158,6 +182,7 @@ impl<F: Field> RowMajorMatrixArena<F> for MatrixRecordArena<F> {
             let height = self.trace_buffer.len() / width;
             assert!(height.is_power_of_two() || height == 0);
         }
+        // eprintln!("into_matrix done");
         RowMajorMatrix::new(self.trace_buffer, self.width)
     }
 }
@@ -534,7 +559,12 @@ where
     [u8]: CustomBorrow<'a, R, MultiRowLayout<M>>,
 {
     fn alloc(&'a mut self, layout: MultiRowLayout<M>) -> R {
-        let buffer = self.alloc_buffer(layout.metadata.get_num_rows());
+        // alloc override of the alloc function in the trait
+        // eprintln!(
+        //     "layout.metadata.get_num_rows() in alloc override = {:?}",
+        //     layout.metadata.get_num_rows()
+        // );
+        let buffer = self.alloc_buffer(layout.metadata.get_num_rows()); //allocating 2 rows
         let record: R = buffer.custom_borrow(layout);
         record
     }

crates/vm/src/arch/vm.rs

@@ -457,6 +457,11 @@ where
         <VB::VmConfig as VmExecutionConfig<Val<E::SC>>>::Executor:
             PreflightExecutor<Val<E::SC>, VB::RecordArena>,
     {
+        eprintln!("crates/vm/src/arch/vm.rs::execute_preflight");
+        eprintln!("=== TRACE HEIGHTS PASSED TO EXECUTE_PREFLIGHT ===");
+        for (air_idx, &height) in trace_heights.iter().enumerate() {
+            eprintln!("AIR[{}]: trace_height={}", air_idx, height);
+        }
         debug_assert!(interpreter
             .executor_idx_to_air_idx
             .iter()
@@ -473,6 +478,34 @@ where
         let capacities = zip_eq(trace_heights, main_widths)
             .map(|(&h, w)| (h as usize, w))
             .collect::<Vec<_>>();
+
+        let executor_idx_to_air_idx = self.executor_idx_to_air_idx();
+
+        // Debug logging for capacities and AIR mapping
+        eprintln!("=== CAPACITY DEBUG INFO ===");
+        for (air_idx, &(height, width)) in capacities.iter().enumerate() {
+            eprintln!(
+                "AIR[{}]: height={}, width={}, total_elements={}",
+                air_idx,
+                height,
+                width,
+                height * width
+            );
+        }
+
+        eprintln!("=== EXECUTOR TO AIR MAPPING ===");
+        for (executor_idx, &air_idx) in executor_idx_to_air_idx.iter().enumerate() {
+            eprintln!("Executor[{}] -> AIR[{}]", executor_idx, air_idx);
+        }
+        let executor_inventory = &self.executor().inventory;
+
+        // Find all opcodes that map to executor index 14
+        eprintln!("=== OPCODES FOR EXECUTOR[14] ===");
+        for (opcode, &executor_idx) in &executor_inventory.instruction_lookup {
+            if executor_idx == 14 {
+                eprintln!("Opcode {} -> Executor[{}]", opcode, executor_idx);
+            }
+        }
         let ctx = PreflightCtx::new_with_capacity(&capacities, instret_end);
 
         let system_config: &SystemConfig = self.config().as_ref();
@@ -1003,7 +1036,6 @@ where
                 &trace_heights,
             )?;
             state = Some(to_state);
-
             let mut ctx = vm.generate_proving_ctx(system_records, record_arenas)?;
             modify_ctx(seg_idx, &mut ctx);
             let proof = vm.engine.prove(vm.pk(), ctx);