Struct PhysicalMap 

pub struct PhysicalMap {
    pub image: Image,
    pub tensors_end: u64,
    pub lines: u64,
    pub granule: u64,
    pub base: u64,
    pub channel_lines: Vec<u64>,
}

A machine layout on the card’s channels.

Fields

image: Image

tensors_end: u64

The layout’s first byte past its tensors: where the space after the weights starts.

lines: u64

Logical lines of the space after the weights.

granule: u64

base: u64

The first channel line past the weight image, the same on every channel.

channel_lines: Vec<u64>

Channel lines each channel holds in all.

Implementations

impl PhysicalMap

pub fn d5005( machine: &MachineLayout, beat: Beat, ) -> Result<PhysicalMap, ImageError>

machine on the D5005’s channels at beat, its granule the standard engine plan’s state chunk.

pub fn of( machine: &MachineLayout, layout: &ImageLayout, granule: u64, ) -> Result<PhysicalMap, ImageError>

machine on the channels of layout, the space after the weights dealt in granules of granule lines.

pub fn flat( machine: &MachineLayout, layout: &ImageLayout, granule: u64, ) -> Result<PhysicalMap, ImageError>

machine on the channels of layout with no weight image: every byte, the tensors’ with the rest, dealt in granules of granule lines from the channels’ first line — the memory as an engine that reads its weights a line at a time by address finds it (card_port_verilog).

pub fn hybrid( machine: &MachineLayout, layout: &ImageLayout, granule: u64, ) -> Result<(PhysicalMap, Vec<usize>, Compaction), ImageError>

The hybrid engine’s memory: the matrices machine‘s matvec jobs stream in their image under layout (in stripes when it has one), and the rest of the memory compacted (Compaction) with the streamed tensors’ stream entries after it, as one logical space from logical byte 0 dealt in granules of granule lines past the image, the space the reference engine’s card port reads; with the image’s tensors’ indices in the machine’s and the compaction.

pub fn locate(&self, at: u64) -> (u32, u64)

The channel and the channel byte logical byte at of the space after the weights lives at.

pub fn runs(&self, at: u64, bytes: u64) -> Vec<Run>

The channel runs that hold logical bytes [at, at + bytes) of the space after the weights, one on each channel the bytes touch, in channel order.

pub fn ring_row( &self, machine: &MachineLayout, s: usize, layer: usize, p: usize, ) -> Vec<Run>

Sequence s’s conv-ring row for position p in Gated-DeltaNet layer layer.

pub fn memory( &self, machine: &MachineLayout, s: usize, layer: usize, head: usize, ) -> Vec<Run>

Value head head’s memory of sequence s in Gated-DeltaNet layer layer.

pub fn log( &self, machine: &MachineLayout, s: usize, layer: usize, entries: Range<usize>, ) -> Vec<Run>

Sequence s’s log in Gated-DeltaNet layer layer: its count line and entries entries.

pub fn cache( &self, machine: &MachineLayout, s: usize, layer: usize, p: usize, ) -> Vec<Run>

Sequence s’s cache rows of positions 0..=p in attention layer layer: every cached head’s key rows, value rows and, for an int8 cache, their scales.

pub fn channel_bytes(&self, memory: &[u8], weights: &[Vec<u8>]) -> Vec<Vec<u8>>

The channels’ bytes of memory, the machine’s whole memory: the weight image’s from weights (its channels’ bytes, Image::fill) and every byte after the weights where PhysicalMap::locate puts it.

Trait Implementations

impl Clone for PhysicalMap

fn clone(&self) -> PhysicalMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PhysicalMap

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

Formats the value using the given formatter.

impl PartialEq for PhysicalMap

fn eq(&self, other: &PhysicalMap) -> 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 Eq for PhysicalMap

impl StructuralPartialEq for PhysicalMap