Struct Memory

pub struct Memory<F> {
    inner: Vec<MemoryValue<F>>,
}

The VM’s memory.

Memory is internally represented as a vector of values. We grow the memory when values past the end are set, extending with 0s.

Capacity Limits

The inner Vec is subject to Rust’s allocator limit of isize::MAX bytes. This means:

• On 64-bit: Practical limit is available RAM (~200 GB for full u32 range)
• On 32-bit: Hard limit of ~44 million addressable slots

Exceeding these limits will cause a panic with “capacity overflow”.

Fields

inner: Vec<MemoryValue<F>>

Implementations

impl<F: AcirField> Memory<F>

const MAX_MEMORY_SIZE: usize = 2_147_483_647usize

Maximum number of memory slots that can be allocated.

This limit is set to i32::MAX to ensure deterministic behavior across all architectures. On 32-bit systems, Rust’s allocator limits allocations to isize::MAX bytes, which would restrict us to fewer elements anyway. By using i32::MAX, we ensure the same behavior on both 32-bit and 64-bit systems.

See: https://github.com/rust-lang/rust/pull/95295 and https://doc.rust-lang.org/1.81.0/src/core/alloc/layout.rs.html

fn get_stack_pointer(&self) -> u32

Read the value from slot 0.

Panics if it’s not a U32.

fn resolve(&self, address: MemoryAddress) -> u32

Resolve an address to either:

• itself, if it’s a direct address, or
• the current stack pointer plus the offset, if it’s relative.

Returns a memory slot index.

pub fn read(&self, address: MemoryAddress) -> MemoryValue<F>

Reads the numeric value at the address.

If the address is beyond the size of memory, a default value is returned.

pub fn read_ref(&self, ptr: MemoryAddress) -> MemoryAddress

Reads the value at the address and returns it as a direct memory address, without dereferencing the pointer itself to a numeric value.

pub fn write_ref(&mut self, ptr: MemoryAddress, address: MemoryAddress)

Sets ptr to point at address.

pub fn read_slice( &self, address: MemoryAddress, len: usize, ) -> &[MemoryValue<F>]

Read a contiguous vector of memory starting at address, up to len slots.

Panics if the end index is beyond the size of the memory.

pub fn write(&mut self, address: MemoryAddress, value: MemoryValue<F>)

Sets the value at address to value

fn resize_to_fit(&mut self, size: usize)

Increase the size of memory fit size elements, or the current length, whichever is bigger.

Panics

Panics if size exceeds Self::MAX_MEMORY_SIZE.

pub fn write_slice(&mut self, address: MemoryAddress, values: &[MemoryValue<F>])

Sets the values after address to values

pub fn values(&self) -> &[MemoryValue<F>]

Returns the values of the memory

Trait Implementations

impl<F: Clone> Clone for Memory<F>

fn clone(&self) -> Memory<F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug> Debug for Memory<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Default> Default for Memory<F>

fn default() -> Memory<F>

Returns the “default value” for a type.

impl<F: PartialEq> PartialEq for Memory<F>

fn eq(&self, other: &Memory<F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F: Eq> Eq for Memory<F>

impl<F> StructuralPartialEq for Memory<F>