Struct EngineProgram 

pub struct EngineProgram {

    pub knobs: u8,
    pub space: u64,
    pub base: u64,
    pub granule_log2: u32,
    pub job_words: usize,
    pub residual: (u32, u32),
    pub logits: (u32, u32),
    pub greedy: bool,
    pub store_beats: u32,
    pub tokens: usize,
    pub hidden: usize,
    pub vocab: usize,
    pub ring_rows: usize,
    pub regions: u64,
    pub region: u64,
    pub sequences: usize,
    pub ctx: usize,
    pub channel_lines: Vec<u64>,
    pub streaming: String,
    pub contexts: usize,
    pub fp_unit: FpUnit,
}

What a host program runs a model on the engine build with, one token-row a step: written by write_engine_program as engine.txt, beside the engine’s tables, the memory image and the embedding table.

Fields

knobs: u8

ENGINE_CONFIG’s knobs, {per_block, two_words, cache_int8, state_f16}.

space: u64

The card port’s map: the space’s first logical line, the channel line it starts at, log2 of a granule’s lines.

base: u64

granule_log2: u32

job_words: usize

Words of the step’s jobs after the host’s embedding, table 0’s entries.

residual: (u32, u32)

The store’s first beat and beats a row of a row’s embedding and of its logits.

logits: (u32, u32)

greedy: bool

Whether a row’s logits slot holds their arg-max and that logit (super::machine::StoreLayout::greedy) in place of the logits.

store_beats: u32

The store’s beats over the program’s rows: a build whose store is smaller cannot run it.

tokens: usize

Tokens the embedding table holds, its row’s elements, and the logits a step reads back.

hidden: usize

vocab: usize

ring_rows: usize

A row’s ring index is its position modulo this.

regions: u64

The first logical line of sequence 0’s region, a region’s lines, the regions, the positions a sequence reaches.

region: u64

sequences: usize

ctx: usize

channel_lines: Vec<u64>

Lines of each channel’s image.

streaming: String

The streaming unit the program’s stream entries are written for, as its build names it (LOGOS_D5005_STREAMING): empty for the reference engine.

contexts: usize

The engine’s sequencer contexts the program is written for: sequence s runs in context s mod the contexts, as its row s / the contexts, the store laid for a context’s rows.

fp_unit: FpUnit

The multiplier the program’s numerics take (super::numerics::FpUnit): its build’s products must be the same (LOGOS_D5005_FP_HARD).

Trait Implementations

impl Clone for EngineProgram

fn clone(&self) -> EngineProgram

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EngineProgram

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

Formats the value using the given formatter.

impl PartialEq for EngineProgram

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

impl StructuralPartialEq for EngineProgram