Struct StoreLayout 

pub struct StoreLayout {
    pub rows: usize,
    pub slots: Vec<(u32, u32)>,
    pub beats: u32,
    pub greedy: bool,
}

The token-row store as the engine holds it: beats of LANES f32 elements, slot s’s row r from beat base + r·beats of its entry, every slot wide enough for the widest vector the step’s jobs write to it, and two slots over the same beats only when no point of the step holds both. A greedy store (StoreLayout::greedy) keeps each row’s logits as their arg-max.

Fields

rows: usize

slots: Vec<(u32, u32)>

Per slot code: the slot’s first beat and its beats a row.

beats: u32

greedy: bool

Whether the logits slot holds each row’s arg-max in place of its logits.

Implementations

impl StoreLayout

pub fn of(jobs: &[Job], layout: &Layout, rows: usize) -> StoreLayout

The store jobs write over rows rows, each slot’s width the widest any job writes to it, each slot at the lowest beat no slot live beside it holds (StoreLayout::live_together), the widest first — or, where that leaves a row longer than the most beats a point of the step holds together (StoreLayout::widest), in the first order of a fixed sequence of them that lays the row that short, the shortest of them all if none does.

pub fn greedy(jobs: &[Job], layout: &Layout, rows: usize) -> StoreLayout

StoreLayout::of with the head’s read-out never in the store: the logits slot is a beat a row, its first lane the index numerics::argmax picks of the row’s logits and its second that logit’s bits, so the store holds what a greedy step reads back however wide the vocabulary.

pub fn widest(&self, jobs: &[Job]) -> u32

The most beats a row of the store holds at any point of the step jobs, the store laid for: the widest set of its slots a job reads, writes or holds live across it (StoreLayout::live_together) — no layout’s row is shorter.

pub fn live_together(jobs: &[Job]) -> Vec<u32>

For each slot code, the slots some point of the step jobs holds beside it, as a mask of slot codes: those a job reads or writes, and those live across it (StoreLayout::live_out).

pub fn live_out(jobs: &[Job]) -> Vec<u32>

For each job of the step jobs, the slots live out of it, as a mask of slot codes. A slot is live from a job that makes it afresh to the last job that reads it before it is made again, the step taken round (the next step follows it, and the host reads the logits after its last job); a job that writes a slot in part leaves it live.

pub fn beat(&self, slot: Slot, row: usize) -> u32

Where slot slot’s row row starts.

pub fn image(&self, store: &Store) -> Vec<[u32; 16]>

The store’s beats, each element its f32 bits, an element no vector holds zero; a greedy store’s logits slot each row’s arg-max and that logit.

Trait Implementations

impl Clone for StoreLayout

fn clone(&self) -> StoreLayout

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StoreLayout

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

Formats the value using the given formatter.

impl PartialEq for StoreLayout

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