Struct cairo_vm::vm::vm_memory::memory_segments::MemorySegmentManager

pub struct MemorySegmentManager {
    pub num_segments: usize,
    pub num_temp_segments: usize,
    pub segment_sizes: HashMap<usize, usize>,
    pub segment_used_sizes: Option<Vec<usize>>,
    pub public_memory_offsets: HashMap<usize, Vec<(usize, usize)>>,
}

Fields

num_segments: usize

num_temp_segments: usize

segment_sizes: HashMap<usize, usize>

segment_used_sizes: Option<Vec<usize>>

public_memory_offsets: HashMap<usize, Vec<(usize, usize)>>

Implementations

impl MemorySegmentManager

pub fn add(&mut self, memory: &mut Memory) -> Relocatable

Adds a new segment and returns its starting location as a RelocatableValue.

pub fn add_temporary_segment(&mut self, memory: &mut Memory) -> Relocatable

Adds a new temporary segment and returns its starting location as a RelocatableValue. Negative segment_index indicates its refer to a temporary segment

pub fn load_data(
    &mut self,
    memory: &mut Memory,
    ptr: &MaybeRelocatable,
    data: &Vec<MaybeRelocatable>
) -> Result<MaybeRelocatable, MemoryError>

Writes data into the memory at address ptr and returns the first address after the data.

pub fn new() -> MemorySegmentManager

pub fn compute_effective_sizes(&mut self, memory: &Memory) -> &Vec<usize>

Calculates the size (number of non-none elements) of each memory segment.

pub fn get_segment_used_size(&self, index: usize) -> Option<usize>

Returns the number of used segments when they are already computed. Returns None otherwise.

pub fn get_segment_size(&self, index: usize) -> Option<usize>

pub fn relocate_segments(&self) -> Result<Vec<usize>, MemoryError>

Returns a vector that contains the first relocated address of each memory segment

pub fn gen_arg(
    &mut self,
    arg: &dyn Any,
    memory: &mut Memory
) -> Result<MaybeRelocatable, VirtualMachineError>

pub fn gen_cairo_arg(
    &mut self,
    arg: &CairoArg,
    memory: &mut Memory
) -> Result<MaybeRelocatable, VirtualMachineError>

pub fn write_arg(
    &mut self,
    memory: &mut Memory,
    ptr: &Relocatable,
    arg: &dyn Any
) -> Result<MaybeRelocatable, MemoryError>

pub fn is_valid_memory_value(
    &self,
    value: &MaybeRelocatable
) -> Result<bool, MemoryError>

pub fn get_memory_holes(
    &self,
    accessed_addresses: impl Iterator<Item = Relocatable>
) -> Result<usize, MemoryError>

Trait Implementations

impl Debug for MemorySegmentManager

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

Formats the value using the given formatter.

impl Default for MemorySegmentManager

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq<MemorySegmentManager> for MemorySegmentManager

fn eq(&self, other: &MemorySegmentManager) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for MemorySegmentManager

impl StructuralEq for MemorySegmentManager

impl StructuralPartialEq for MemorySegmentManager