memory: add get_array method

Author: tcoratger

crates/leanVm/src/context/run_context.rs

@@ -154,10 +154,7 @@ mod tests {
 
         // Insert a value at that address manually.
         let expected_val = MemoryValue::Int(F::from_u64(99));
-        memory
-            .memory
-            .insert(addr_to_read, expected_val.clone())
-            .unwrap();
+        memory.memory.insert(addr_to_read, expected_val).unwrap();
 
         // Create a RunContext with that fp.
         let ctx = RunContext::new(
@@ -240,10 +237,7 @@ mod tests {
         let fp = memory.add();
         let addr_to_read = fp.add_usize::<F>(7).unwrap();
         let expected_val = MemoryValue::<F>::Address(MemoryAddress::new(5, 5));
-        memory
-            .memory
-            .insert(addr_to_read, expected_val.clone())
-            .unwrap();
+        memory.memory.insert(addr_to_read, expected_val).unwrap();
 
         let ctx = RunContext::new(MemoryAddress::new(0, 0), fp);
         let operand = MemOrFpOrConstant::MemoryAfterFp { shift: 7 };

crates/leanVm/src/core.rs

@@ -378,7 +378,7 @@ mod tests {
                 vm.memory_manager.add();
             }
             // Insert the value at the specified address, panicking on failure for test simplicity.
-            vm.memory_manager.memory.insert(*addr, val.clone()).unwrap();
+            vm.memory_manager.memory.insert(*addr, *val).unwrap();
         }
         // Return the fully configured VM.
         vm

crates/leanVm/src/memory/cell.rs

@@ -206,15 +206,15 @@ mod tests {
 
         // Test on a valid integer cell.
         let int_val = MemoryValue::Int(F::from_u64(123));
-        let int_cell = MemoryCell::from(int_val.clone());
+        let int_cell = MemoryCell::from(int_val);
         assert_eq!(int_cell.value(), Some(int_val));
 
         // Test on a valid address cell.
         let addr_val = MemoryValue::<F>::Address(MemoryAddress {
             segment_index: 5,
             offset: 10,
         });
-        let addr_cell = MemoryCell::from(addr_val.clone());
+        let addr_cell = MemoryCell::from(addr_val);
         assert_eq!(addr_cell.value(), Some(addr_val));
     }
 
@@ -272,7 +272,7 @@ mod tests {
             val in any::<MemoryValue<F>>()
         ) {
             // Convert the generated MemoryValue to a MemoryCell.
-            let cell = MemoryCell::from(val.clone());
+            let cell = MemoryCell::from(val);
 
             // Convert the MemoryCell back to a MemoryValue.
             let roundtrip_val = MemoryValue::<F>::from(cell);

crates/leanVm/src/memory/manager.rs

@@ -77,7 +77,7 @@ impl MemoryManager {
         // This reverse order allows any required memory segment resizing
         // (e.g., length extension or capacity reservation) to occur *once*
         // at the highest offset instead of repeatedly during writes.
-        for (num, value) in data.iter().enumerate().rev() {
+        for (num, &value) in data.iter().enumerate().rev() {
             // Compute the target address: ptr + num.
             //
             // This operation may fail if it causes overflow.
@@ -87,7 +87,7 @@ impl MemoryManager {
             //
             // This enforces the write-once rule — it will fail if the cell is already
             // initialized with a different value.
-            self.memory.insert(addr, value.clone())?;
+            self.memory.insert(addr, value)?;
         }
 
         // After writing all values, compute and return the address after the last item.
@@ -168,12 +168,12 @@ mod tests {
         assert_eq!(end_addr.offset, base_addr.offset + values.len());
 
         // Verify that each value was inserted correctly at its expected offset.
-        for (i, expected) in values.iter().enumerate() {
+        for (i, &expected) in values.iter().enumerate() {
             let addr = MemoryAddress {
                 segment_index: base_addr.segment_index,
                 offset: base_addr.offset + i,
             };
-            assert_eq!(manager.memory.get(addr), Some(expected.clone()));
+            assert_eq!(manager.memory.get(addr), Some(expected));
         }
     }
 

crates/leanVm/src/memory/mem.rs

@@ -127,6 +127,43 @@ impl Memory {
             .and_then(|segment| segment.get(offset))
             .and_then(|mem_cell| mem_cell.value())
     }
+
+    /// Retrieves a fixed-size array of field elements starting from a given address.
+    ///
+    /// This function reads `DIM` consecutive memory cells starting from `start_address`,
+    /// expecting each cell to contain an integer (`MemoryValue::Int`). It's a generic
+    /// way to perform the "vectorized memory access". We need to check further if it is better
+    /// to use vectorized memory cells directly.
+    ///
+    /// # Arguments
+    /// * `start_address`: The `MemoryAddress` of the first element of the vector.
+    pub(crate) fn get_array<F, const DIM: usize>(
+        &self,
+        start_address: MemoryAddress,
+    ) -> Result<[MemoryValue<F>; DIM], MemoryError<F>>
+    where
+        F: PrimeField64,
+    {
+        // Initialize an array to store the result.
+        let mut result = [MemoryValue::default(); DIM];
+
+        // Iterate from 0 to DIM-1 to read each element of the vector.
+        for (i, res) in result.iter_mut().enumerate().take(DIM) {
+            // Calculate the address of the current element by adding the index `i` to the start offset.
+            let current_addr = start_address.add_usize(i).map_err(MemoryError::Math)?;
+
+            // Retrieve the value from the calculated address.
+            let mem_val = self
+                .get(current_addr)
+                .ok_or(MemoryError::UninitializedMemory(current_addr))?;
+
+            // Assign the validated field element to the result array.
+            *res = mem_val;
+        }
+
+        // Return the completed array.
+        Ok(result)
+    }
 }
 
 #[cfg(test)]
@@ -156,7 +193,7 @@ mod tests {
         };
         let val = MemoryValue::<F>::Int(F::from_u64(100));
 
-        assert!(memory.insert(addr, val.clone()).is_ok());
+        assert!(memory.insert(addr, val).is_ok());
         assert_eq!(memory.get(addr), Some(val));
     }
 
@@ -169,7 +206,7 @@ mod tests {
         };
         let val = MemoryValue::<F>::Int(F::from_u64(200));
 
-        assert!(memory.insert(addr, val.clone()).is_ok());
+        assert!(memory.insert(addr, val).is_ok());
 
         // Verify the segment was resized and padded with NONE.
         assert_eq!(memory.data[0].len(), 6);
@@ -197,9 +234,9 @@ mod tests {
         let val = MemoryValue::<F>::Int(F::from_u64(300));
 
         // First insert should succeed.
-        assert!(memory.insert(addr, val.clone()).is_ok());
+        assert!(memory.insert(addr, val).is_ok());
         // Inserting the exact same value again should also succeed.
-        assert!(memory.insert(addr, val.clone()).is_ok());
+        assert!(memory.insert(addr, val).is_ok());
 
         assert_eq!(memory.get(addr), Some(val));
     }
@@ -228,10 +265,10 @@ mod tests {
         let val2 = MemoryValue::<F>::Int(F::from_u64(600));
 
         // First write is OK.
-        memory.insert(addr, val1.clone()).unwrap();
+        memory.insert(addr, val1).unwrap();
 
         // Second write with a different value should fail.
-        let err = memory.insert(addr, val2.clone()).unwrap_err();
+        let err = memory.insert(addr, val2).unwrap_err();
         assert_eq!(
             err,
             MemoryError::InconsistentMemory(Box::new((addr, val1, val2)))
@@ -251,7 +288,7 @@ mod tests {
         };
         let val = MemoryValue::<F>::Address(address_value);
 
-        assert!(memory.insert(addr_to_insert_at, val.clone()).is_ok());
+        assert!(memory.insert(addr_to_insert_at, val).is_ok());
         assert_eq!(memory.get(addr_to_insert_at), Some(val));
     }
 
@@ -263,7 +300,7 @@ mod tests {
             offset: 0,
         };
         let val = MemoryValue::<F>::Int(F::from_u64(123));
-        memory.insert(addr, val.clone()).unwrap();
+        memory.insert(addr, val).unwrap();
 
         assert_eq!(memory.get(addr), Some(val));
     }
@@ -310,4 +347,62 @@ mod tests {
         };
         assert_eq!(memory.get::<F>(gap_addr), None);
     }
+
+    #[test]
+    fn test_get_array_successful() {
+        // Setup: Create a memory instance with one segment.
+        let mut memory = create_memory_with_segments(1);
+        // Define the starting address for the array read.
+        let start_addr = MemoryAddress {
+            segment_index: 0,
+            offset: 2,
+        };
+        // Define the array of mixed `MemoryValue` types to insert.
+        let values_to_insert = [
+            MemoryValue::Int(F::from_u64(100)),
+            MemoryValue::Address(MemoryAddress::new(0, 99)),
+            MemoryValue::Int(F::from_u64(300)),
+        ];
+
+        // Loop through the data and insert each value at a consecutive address.
+        for (i, &val) in values_to_insert.iter().enumerate() {
+            memory
+                // Calculate the address for the current item: `start_addr + i`.
+                .insert(start_addr.add_usize::<F>(i).unwrap(), val)
+                .unwrap();
+        }
+
+        // Execute: Call `get_array` to retrieve the data.
+        let result: Result<[MemoryValue<F>; 3], _> = memory.get_array(start_addr);
+        // Verify: The retrieved array should be identical to the one we inserted.
+        assert_eq!(result.unwrap(), values_to_insert);
+    }
+
+    #[test]
+    fn test_get_array_fails_on_uninitialized() {
+        // Setup: Create a memory instance with one segment.
+        let mut memory = create_memory_with_segments(1);
+        // Define the starting address.
+        let start_addr = MemoryAddress {
+            segment_index: 0,
+            offset: 0,
+        };
+        // Insert only the *first* value of the array we intend to read.
+        memory
+            .insert(start_addr, MemoryValue::Int(F::from_u64(100)))
+            .unwrap();
+
+        // Execute: Attempt to read a 2-element array. This should fail on the second element.
+        let result: Result<[MemoryValue<F>; 2], _> = memory.get_array(start_addr);
+        // Verify: The operation should fail.
+        assert!(result.is_err());
+        // Verify: The error must be `UninitializedMemory` at the exact address of the missing element.
+        assert_eq!(
+            result.unwrap_err(),
+            MemoryError::UninitializedMemory(MemoryAddress {
+                segment_index: 0,
+                offset: 1
+            })
+        );
+    }
 }

crates/leanVm/src/memory/val.rs

@@ -7,12 +7,21 @@ use proptest::prelude::*;
 use super::address::MemoryAddress;
 use crate::errors::memory::MemoryError;
 
-#[derive(Eq, Ord, Hash, PartialEq, PartialOrd, Clone, Debug)]
+#[derive(Eq, Ord, Hash, PartialEq, PartialOrd, Clone, Copy, Debug)]
 pub enum MemoryValue<F> {
     Address(MemoryAddress),
     Int(F),
 }
 
+impl<F> Default for MemoryValue<F>
+where
+    F: PrimeField64,
+{
+    fn default() -> Self {
+        Self::Int(F::default())
+    }
+}
+
 impl<F> MemoryValue<F>
 where
     F: PrimeField64,
@@ -58,7 +67,7 @@ where
     type Output = Result<Self, MemoryError<F>>;
 
     fn mul(self, rhs: Self) -> Self::Output {
-        match (self.clone(), rhs.clone()) {
+        match (self, rhs) {
             // Case 1 (Success): Multiply two integers.
             (Self::Int(a), Self::Int(b)) => Ok(Self::Int(a * b)),
 
@@ -266,7 +275,7 @@ mod tests {
         let val2 = MemoryValue::Int(F::from_u64(5));
 
         // Action: Attempt to multiply them.
-        let err = (val1.clone() * val2.clone()).unwrap_err();
+        let err = (val1 * val2).unwrap_err();
 
         // Verify: The operation should fail with the specific `InvalidMul` error,
         // containing the values that caused the failure.
@@ -280,7 +289,7 @@ mod tests {
         let val2 = MemoryValue::<F>::Address(MemoryAddress::new(2, 20));
 
         // Action: Attempt to multiply them.
-        let err = (val1.clone() * val2.clone()).unwrap_err();
+        let err = (val1 * val2).unwrap_err();
 
         // Verify: The operation should fail with the `InvalidMul` error.
         assert!(matches!(err, MemoryError::InvalidMul(boxed) if *boxed == (val1, val2)));