fix: add memcpy executer to tests + lint

Author: pjabbarzade

Cargo.lock

@@ -193,7 +193,11 @@ where
             &config.keccak,
             inventory,
         )?;
-        VmProverExtension::<E, _, _>::extend_prover(&MemcpyCpuProverExt, &config.memcpy, inventory)?;
+        VmProverExtension::<E, _, _>::extend_prover(
+            &MemcpyCpuProverExt,
+            &config.memcpy,
+            inventory,
+        )?;
         VmProverExtension::<E, _, _>::extend_prover(&Sha2CpuProverExt, &config.sha256, inventory)?;
         VmProverExtension::<E, _, _>::extend_prover(
             &AlgebraCpuProverExt,

benchmarks/execute/benches/execute.rs

@@ -18,6 +18,8 @@ use openvm_ecc_circuit::{
 use openvm_ecc_transpiler::EccTranspilerExtension;
 use openvm_keccak256_circuit::{Keccak256, Keccak256CpuProverExt, Keccak256Executor};
 use openvm_keccak256_transpiler::Keccak256TranspilerExtension;
+use openvm_memcpy_circuit::{Memcpy, MemcpyCpuProverExt, MemcpyExecutor};
+use openvm_memcpy_transpiler::MemcpyTranspilerExtension;
 use openvm_native_circuit::{
     CastFExtension, CastFExtensionExecutor, Native, NativeCpuProverExt, NativeExecutor,
 };
@@ -33,8 +35,6 @@ use openvm_rv32im_circuit::{
 use openvm_rv32im_transpiler::{
     Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension,
 };
-use openvm_memcpy_circuit::{Memcpy, MemcpyCpuProverExt, MemcpyExecutor};
-use openvm_memcpy_transpiler::MemcpyTranspilerExtension;
 use openvm_sha256_circuit::{Sha256, Sha256Executor, Sha2CpuProverExt};
 use openvm_sha256_transpiler::Sha256TranspilerExtension;
 use openvm_stark_backend::{

crates/sdk/src/config/global.rs

@@ -17,6 +17,7 @@ openvm-stark-backend = { workspace = true }
 openvm-mod-circuit-builder = { workspace = true }
 openvm-stark-sdk = { workspace = true }
 openvm-rv32im-circuit = { workspace = true }
+openvm-memcpy-circuit = { workspace = true }
 openvm-rv32-adapters = { workspace = true }
 openvm-algebra-transpiler = { workspace = true }
 openvm-cuda-backend = { workspace = true, optional = true }

extensions/algebra/circuit/Cargo.toml

@@ -9,6 +9,7 @@ use openvm_circuit::{
     system::{SystemChipInventory, SystemCpuBuilder, SystemExecutor},
 };
 use openvm_circuit_derive::VmConfig;
+use openvm_memcpy_circuit::{Memcpy, MemcpyCpuProverExt, MemcpyExecutor};
 use openvm_rv32im_circuit::{
     Rv32I, Rv32IExecutor, Rv32ImCpuProverExt, Rv32Io, Rv32IoExecutor, Rv32M, Rv32MExecutor,
 };
@@ -57,6 +58,8 @@ pub struct Rv32ModularConfig {
     pub io: Rv32Io,
     #[extension]
     pub modular: ModularExtension,
+    #[extension]
+    pub memcpy: Memcpy,
 }
 
 impl InitFileGenerator for Rv32ModularConfig {
@@ -76,6 +79,7 @@ impl Rv32ModularConfig {
             mul: Default::default(),
             io: Default::default(),
             modular: ModularExtension::new(moduli),
+            memcpy: Memcpy,
         }
     }
 }
@@ -143,6 +147,11 @@ where
             &config.modular,
             inventory,
         )?;
+        VmProverExtension::<E, _, _>::extend_prover(
+            &MemcpyCpuProverExt,
+            &config.memcpy,
+            inventory,
+        )?;
         Ok(chip_complex)
     }
 }

extensions/algebra/circuit/src/extension/mod.rs

@@ -12,6 +12,7 @@ use openvm_circuit::{
 };
 use openvm_circuit_derive::{AnyEnum, Executor, MeteredExecutor, PreflightExecutor};
 use openvm_instructions::*;
+use openvm_memcpy_transpiler::Rv32MemcpyOpcode;
 use openvm_stark_backend::{
     config::{StarkGenericConfig, Val},
     engine::StarkEngine,
@@ -23,8 +24,6 @@ use strum::IntoEnumIterator;
 
 use crate::*;
 
-use openvm_memcpy_transpiler::Rv32MemcpyOpcode;
-
 // =================================== VM Extension Implementation =================================
 #[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
 pub struct Memcpy;

extensions/memcpy/circuit/src/extension.rs

@@ -48,7 +48,6 @@ use crate::{
     bus::MemcpyBus, MemcpyLoopChip, A1_REGISTER_PTR, A2_REGISTER_PTR, A3_REGISTER_PTR,
     A4_REGISTER_PTR,
 };
-
 // Import constants from lib.rs
 use crate::{MEMCPY_LOOP_LIMB_BITS, MEMCPY_LOOP_NUM_LIMBS};
 
@@ -177,7 +176,8 @@ impl<AB: InteractionBuilder> Air<AB> for MemcpyIterAir {
         is_not_valid_when.assert_zero(local.is_boundary);
         is_not_valid_when.assert_zero(shift.clone());
 
-        // if is_valid_not_start = 1, then len = prev_len - 16, source = prev_source + 16, dest = prev_dest + 16
+        // if is_valid_not_start = 1, then len = prev_len - 16, source = prev_source + 16,
+        // and dest = prev_dest + 16
         let mut is_valid_not_start_when = builder.when(local.is_valid_not_start);
         is_valid_not_start_when
             .assert_eq(local.len[0], prev.len[0] - AB::Expr::from_canonical_u32(16));
@@ -190,7 +190,7 @@ impl<AB: InteractionBuilder> Air<AB> for MemcpyIterAir {
         builder
             .when(not::<AB::Expr>(prev.is_valid_not_start) - not::<AB::Expr>(prev.is_valid))
             .assert_eq(local.timestamp, prev.timestamp + is_shift_non_zero.clone());
-        // if prev.is_valid_not_start and local.is_valid_not_start, then timestamp = prev_timestamp + 8
+        // if prev.is_valid_not_start and local.is_valid_not_start, then timestamp=prev_timestamp+8
         // prev.is_valid_not_start is the opposite of previous condition
         builder
             .when(
@@ -602,8 +602,8 @@ impl<F: PrimeField32> TraceFiller<F> for MemcpyIterFiller {
                     .for_each(|(row, (idx, var))| {
                         let cols: &mut MemcpyIterCols<F> = row.borrow_mut();
 
-                        let is_end = (idx == 0);
-                        let is_start = (idx == num_rows - 1);
+                        let is_end = idx == 0;
+                        let is_start = idx == num_rows - 1;
 
                         // Range check len
                         let len_u16_limbs = [len & 0xffff, len >> 16];

extensions/memcpy/circuit/src/iteration.rs

@@ -1,11 +1,11 @@
 mod bus;
-mod core;
 mod extension;
 mod iteration;
+mod loops;
 
-pub use core::*;
 pub use extension::*;
 pub use iteration::*;
+pub use loops::*;
 
 // ==== Do not change these constants! ====
 pub const MEMCPY_LOOP_NUM_LIMBS: usize = 4;

extensions/memcpy/circuit/src/lib.rs

@@ -1,45 +1,42 @@
 use std::{
-    array,
     borrow::{Borrow, BorrowMut},
-    mem::{align_of, size_of},
+    mem::size_of,
     sync::{Arc, Mutex},
 };
 
 use openvm_circuit::{
-    arch::*,
-    system::{memory::{
-        offline_checker::{
-            MemoryBaseAuxCols, MemoryBaseAuxRecord, MemoryBridge, MemoryExtendedAuxRecord, MemoryReadAuxRecord, MemoryWriteAuxCols, MemoryWriteBytesAuxRecord
+    arch::{ExecutionBridge, ExecutionState},
+    system::{
+        memory::{
+            offline_checker::{
+                MemoryBaseAuxCols, MemoryBaseAuxRecord, MemoryBridge, MemoryExtendedAuxRecord,
+                MemoryWriteAuxCols,
+            },
+            MemoryAddress, MemoryAuxColsFactory,
         },
-        online::{GuestMemory, TracingMemory},
-        MemoryAddress, MemoryAuxColsFactory,
-    }, SystemPort},
+        SystemPort,
+    },
 };
 use openvm_circuit_primitives::{
     utils::{not, or, select},
     var_range::{SharedVariableRangeCheckerChip, VariableRangeCheckerBus},
     AlignedBytesBorrow,
 };
 use openvm_circuit_primitives_derive::AlignedBorrow;
-use openvm_instructions::{
-    instruction::Instruction,
-    program::DEFAULT_PC_STEP,
-    riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS},
-    LocalOpcode,
-};
-use openvm_rv32im_circuit::adapters::{read_rv32_register, tracing_read, tracing_write};
+use openvm_instructions::riscv::RV32_MEMORY_AS;
+use openvm_memcpy_transpiler::Rv32MemcpyOpcode;
 use openvm_stark_backend::{
-    config::{StarkGenericConfig, Val}, interaction::InteractionBuilder, p3_air::{Air, AirBuilder, BaseAir}, p3_field::{Field, FieldAlgebra, PrimeField32}, p3_matrix::{dense::RowMajorMatrix, Matrix}, prover::{cpu::CpuBackend, types::AirProvingContext}, rap::{get_air_name, BaseAirWithPublicValues, PartitionedBaseAir}, Chip, ChipUsageGetter
+    config::{StarkGenericConfig, Val},
+    interaction::InteractionBuilder,
+    p3_air::{Air, AirBuilder, BaseAir},
+    p3_field::{Field, FieldAlgebra, PrimeField32},
+    p3_matrix::{dense::RowMajorMatrix, Matrix},
+    prover::{cpu::CpuBackend, types::AirProvingContext},
+    rap::{get_air_name, BaseAirWithPublicValues, PartitionedBaseAir},
+    Chip, ChipUsageGetter,
 };
 
-use crate::{bus::MemcpyBus, MemcpyIterChip};
-use openvm_circuit::arch::{
-    execution_mode::{ExecutionCtxTrait, MeteredExecutionCtxTrait},
-    get_record_from_slice, ExecuteFunc, ExecutionError, Executor, MeteredExecutor, RecordArena,
-    StaticProgramError, TraceFiller, VmExecState,
-};
-use openvm_memcpy_transpiler::Rv32MemcpyOpcode;
-
+use crate::bus::MemcpyBus;
 // Import constants from lib.rs
 use crate::{
     A1_REGISTER_PTR, A2_REGISTER_PTR, A3_REGISTER_PTR, A4_REGISTER_PTR, MEMCPY_LOOP_LIMB_BITS,
@@ -94,7 +91,8 @@ impl<AB: InteractionBuilder> Air<AB> for MemcpyLoopAir {
         let mut timestamp_delta: u32 = 0;
         let mut timestamp_pp = || {
             timestamp_delta += 1;
-            local.to_timestamp - AB::Expr::from_canonical_u32(MEMCPY_LOOP_NUM_WRITES + timestamp_delta - 1)
+            local.to_timestamp
+                - AB::Expr::from_canonical_u32(MEMCPY_LOOP_NUM_WRITES + timestamp_delta - 1)
         };
 
         let from_le_bytes = |data: [AB::Var; 4]| {
@@ -257,7 +255,8 @@ impl<AB: InteractionBuilder> Air<AB> for MemcpyLoopAir {
 
         // Make sure the request and response match
         builder.assert_eq(
-            local.to_timestamp - (local.from_state.timestamp + AB::Expr::from_canonical_u32(timestamp_delta)),
+            local.to_timestamp
+                - (local.from_state.timestamp + AB::Expr::from_canonical_u32(timestamp_delta)),
             AB::Expr::TWO * (len.clone() - to_len) + is_shift_non_zero.clone(),
         );
 
@@ -301,7 +300,13 @@ impl MemcpyLoopChip {
         range_checker_chip: SharedVariableRangeCheckerChip,
     ) -> Self {
         Self {
-            air: MemcpyLoopAir::new(system_port.memory_bridge, ExecutionBridge::new(system_port.execution_bus, system_port.program_bus), range_bus, memcpy_bus, pointer_max_bits),
+            air: MemcpyLoopAir::new(
+                system_port.memory_bridge,
+                ExecutionBridge::new(system_port.execution_bus, system_port.program_bus),
+                range_bus,
+                memcpy_bus,
+                pointer_max_bits,
+            ),
             records: Arc::new(Mutex::new(Vec::new())),
             pointer_max_bits,
             range_checker_chip,
@@ -327,18 +332,24 @@ impl MemcpyLoopChip {
         shift: u8,
         register_aux: [MemoryBaseAuxRecord; 3],
     ) {
-        let mut timestamp = from_timestamp + (((len - shift as u32) & !0x0f) >> 1) + (shift != 0) as u32;
-        let write_aux = register_aux.iter().map(|aux_record| {
-            let mut aux_col = MemoryBaseAuxCols::default();
-            mem_helper.fill(aux_record.prev_timestamp, timestamp, &mut aux_col);
-            timestamp += 1;
-            MemoryExtendedAuxRecord::from_aux_cols(aux_col)
-        }).collect::<Vec<_>>().try_into().unwrap();
+        let mut timestamp =
+            from_timestamp + (((len - shift as u32) & !0x0f) >> 1) + (shift != 0) as u32;
+        let write_aux = register_aux
+            .iter()
+            .map(|aux_record| {
+                let mut aux_col = MemoryBaseAuxCols::default();
+                mem_helper.fill(aux_record.prev_timestamp, timestamp, &mut aux_col);
+                timestamp += 1;
+                MemoryExtendedAuxRecord::from_aux_cols(aux_col)
+            })
+            .collect::<Vec<_>>()
+            .try_into()
+            .unwrap();
 
         let num_copies = (len - shift as u32) & !0x0f;
         let to_dest = dest + num_copies;
         let to_source = source + num_copies;
-        
+
         let word_to_u16 = |data: u32| [data & 0xffff, data >> 16];
         let range_check_data = [
             (word_to_u16(len), false),
@@ -379,7 +390,7 @@ impl MemcpyLoopChip {
 
     /// Generates trace
     pub fn generate_trace<F: PrimeField32>(&self) -> RowMajorMatrix<F> {
-        let mut rows = F::zero_vec((self.records.lock().unwrap().len() as usize) * NUM_MEMCPY_LOOP_COLS);
+        let mut rows = F::zero_vec(self.records.lock().unwrap().len() * NUM_MEMCPY_LOOP_COLS);
 
         for (i, record) in self.records.lock().unwrap().iter().enumerate() {
             let row = &mut rows[i * NUM_MEMCPY_LOOP_COLS..(i + 1) * NUM_MEMCPY_LOOP_COLS];
@@ -394,11 +405,22 @@ impl MemcpyLoopChip {
             cols.dest = record.dest.to_le_bytes().map(F::from_canonical_u8);
             cols.source = record.source.to_le_bytes().map(F::from_canonical_u8);
             cols.len = record.len.to_le_bytes().map(F::from_canonical_u8);
-            cols.shift = [F::from_canonical_u8(shift % 2), F::from_canonical_u8(shift / 2)];
+            cols.shift = [
+                F::from_canonical_u8(shift % 2),
+                F::from_canonical_u8(shift / 2),
+            ];
             cols.is_valid = F::ONE;
-            // We have MEMCPY_LOOP_NUM_WRITES writes in the loop, (num_copies / 4 + shift != 0) reads and (num_copies / 4) writes in iterations
-            cols.to_timestamp = F::from_canonical_u32(record.from_timestamp + MEMCPY_LOOP_NUM_WRITES + (num_copies >> 1) + (shift != 0) as u32);
-            cols.to_dest = (record.dest + num_copies).to_le_bytes().map(F::from_canonical_u8);
+            // We have MEMCPY_LOOP_NUM_WRITES writes in the loop, (num_copies / 4) writes
+            // and (num_copies / 4 + shift != 0) reads in iterations
+            cols.to_timestamp = F::from_canonical_u32(
+                record.from_timestamp
+                    + MEMCPY_LOOP_NUM_WRITES
+                    + (num_copies >> 1)
+                    + (shift != 0) as u32,
+            );
+            cols.to_dest = (record.dest + num_copies)
+                .to_le_bytes()
+                .map(F::from_canonical_u8);
             cols.to_source = to_source.to_le_bytes().map(F::from_canonical_u8);
             cols.to_len = F::from_canonical_u32(record.len - num_copies);
             cols.write_aux = record.write_aux.clone().map(|aux| aux.to_aux_cols());
@@ -426,10 +448,10 @@ impl ChipUsageGetter for MemcpyLoopChip {
         get_air_name(&self.air)
     }
     fn constant_trace_height(&self) -> Option<usize> {
-        Some(self.records.lock().unwrap().len() as usize)
+        Some(self.records.lock().unwrap().len())
     }
     fn current_trace_height(&self) -> usize {
-        self.records.lock().unwrap().len() as usize
+        self.records.lock().unwrap().len()
     }
     fn trace_width(&self) -> usize {
         NUM_MEMCPY_LOOP_COLS

extensions/memcpy/circuit/src/core.rs renamed to extensions/memcpy/circuit/src/loops.rs

@@ -23,6 +23,7 @@ openvm-stark-backend = { workspace = true }
 openvm-rv32im-circuit = { workspace = true }
 openvm-algebra-circuit = { workspace = true }
 openvm-ecc-circuit = { workspace = true }
+openvm-memcpy-circuit = { workspace = true }
 openvm-pairing-transpiler = { workspace = true }
 openvm-cuda-backend = { workspace = true, optional = true }
 openvm-stark-sdk = { workspace = true, optional = true }