Struct rsim::processor::elements::memory::AggregateMemory

pub struct AggregateMemory {
    mappings: Vec<Box<dyn Memory>>,
    full_range: Range<usize>,
}

Struct that combines a set of array-backed memory mappings. The mapped address ranges may not overlap.

Fields

mappings: Vec<Box<dyn Memory>>

full_range: Range<usize>

Implementations

impl AggregateMemory

pub fn from_mappings(mappings: Vec<Box<dyn Memory>>) -> Self

Take a set of mappings, verify they do not overlap, and turn them into an AggregateMemory. Panics if any mappings overlap.

pub fn get_io_values(&self) -> Vec<Option<u64>>

Returns a vector of all stored I/O values

Trait Implementations

impl From<MemoryBacking> for AggregateMemory

For convenience, allow a single MemoryBacking to be converted directly to an AggregateMemory

fn from(backing: MemoryBacking) -> Self

Performs the conversion.

impl Memory<u64> for AggregateMemory

fn range(&self) -> Range<usize>

The mapped address range for this Memory. All addresses passed to read,write must be within this range. Guaranteed to be at least 4 bytes in size, both ends will be 4-byte aligned.

fn as_any(&self) -> &dyn Any

fn load_u8(&mut self, addr: TAddr) -> MemoryResult<u8>

fn load_u16(&mut self, addr: TAddr) -> MemoryResult<u16>

fn load_u32(&mut self, addr: TAddr) -> MemoryResult<u32>

fn load_u64(&mut self, addr: TAddr) -> MemoryResult<u64>

fn store_u8(&mut self, addr: TAddr, val: u8) -> MemoryResult<()>

fn store_u16(&mut self, addr: TAddr, val: u16) -> MemoryResult<()>

fn store_u32(&mut self, addr: TAddr, val: u32) -> MemoryResult<()>

fn store_u64(&mut self, addr: TAddr, val: u64) -> MemoryResult<()>

impl<TData> MemoryOf<TData, u64> for AggregateMemory where
    dyn Memory: MemoryOf<TData>, 

Foreach TData, where Memory implements MemoryOf, re-implement it for AggregateMemory TData = u8,u16,u32,u64

fn read(&mut self, addr: u64) -> MemoryResult<TData>

fn write(&mut self, addr: u64, val: TData) -> MemoryResult<()>

impl<'a, uXLEN: PossibleXlen> VecMemInterface<uXLEN, u128> for AggregateMemory

fn load_from_memory(
    &mut self,
    eew: Sew,
    addr_provenance: (u64, Provenance)
) -> Result<u128>

Use an address, provenance pair to read a vector element from memory

fn store_to_memory(
    &mut self,
    eew: Sew,
    val: u128,
    addr_provenance: (u64, Provenance)
) -> Result<()>

Use an address, provenance pair to write a vector element to memory