Struct MemoryLayout 

pub struct MemoryLayout<A> {

    pub four_state: bool,
    pub mode: MemoryLayoutMode,
    pub offsets: FxHashMap<A, usize>,
    pub widths: FxHashMap<A, usize>,
    pub is_4states: FxHashMap<A, bool>,
    pub unpacked_arrays: FxHashMap<A, UnpackedArrayLayout>,
    pub total_size: usize,
    pub working_offsets: FxHashMap<A, usize>,
    pub working_base_offset: usize,
    pub sparse_offsets: FxHashMap<A, usize>,
    pub sparse_base_offset: usize,
    pub sparse_layouts: FxHashMap<A, SparseWorkingLayout>,
    pub sparse_active_bits_offset: usize,
    pub sparse_active_capacity: usize,
    pub merged_total_size: usize,
    pub triggered_bits_offset: usize,
    pub triggered_bits_total_size: usize,
    pub scratch_base_offset: usize,
    pub scratch_size: usize,
    pub runtime_event_capacity: usize,
    pub runtime_event_slot_size: usize,
    pub runtime_event_buffer_size: usize,
    pub runtime_event_site_layouts: Vec<RuntimeEventSiteLayout>,
}

Fields

four_state: bool

mode: MemoryLayoutMode

offsets: FxHashMap<A, usize>

Stable region offsets. Includes all declared state objects.

widths: FxHashMap<A, usize>

is_4states: FxHashMap<A, bool>

Whether each state object has a four-state source type.

unpacked_arrays: FxHashMap<A, UnpackedArrayLayout>

total_size: usize

Stable region size in bytes.

working_offsets: FxHashMap<A, usize>

Working region offsets. Includes only actually-used state objects.

working_base_offset: usize

sparse_offsets: FxHashMap<A, usize>

Copy-on-write next-state data for dynamically addressed FF targets.

sparse_base_offset: usize

sparse_layouts: FxHashMap<A, SparseWorkingLayout>

sparse_active_bits_offset: usize

sparse_active_capacity: usize

merged_total_size: usize

triggered_bits_offset: usize

triggered_bits_total_size: usize

scratch_base_offset: usize

scratch_size: usize

runtime_event_capacity: usize

runtime_event_slot_size: usize

runtime_event_buffer_size: usize

runtime_event_site_layouts: Vec<RuntimeEventSiteLayout>

Implementations

impl<A> MemoryLayout<A>

where A: Copy + Eq + Hash + Ord,

pub fn build<S>(source: &S, four_state: bool, mode: MemoryLayoutMode) -> Self

where S: LayoutSource<A>,

pub fn with_backend_scratch(self, scratch_size: usize) -> Self

Append backend-private scratch storage without changing any semantic state offset. Backend planning happens after the backend-neutral state layout has been finalized, so scratch is always the final region.

pub fn plane_size(&self, address: &A) -> usize

pub fn region_base_offset<R>(&self, address: &R) -> usize

where R: RegionedAddress<A>,

pub fn map_static_bit_offset( &self, address: &A, bit_offset: usize, ) -> (usize, usize)

pub fn regioned_static_byte_and_intra<R>( &self, address: &R, bit_offset: usize, ) -> Option<(i32, usize)>

where R: RegionedAddress<A>,

Trait Implementations

impl<A: Clone> Clone for MemoryLayout<A>

fn clone(&self) -> MemoryLayout<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for MemoryLayout<A>

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

Formats the value using the given formatter.

impl<'de, A> Deserialize<'de> for MemoryLayout<A>

where A: Deserialize<'de> + Eq + Hash,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A> Serialize for MemoryLayout<A>

where A: Serialize + Eq + Hash,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.