Struct EngineParams 

pub struct EngineParams {

    pub rows: usize,
    pub vector_rows: usize,
    pub side_rows: usize,
    pub pair_rows: usize,
    pub store_beats: usize,
    pub job_words: usize,
    pub tensors: usize,
    pub layers: usize,
    pub ropes: usize,
    pub formats: Vec<(GgmlType, usize)>,
    pub delta: Option<(usize, StateFlush)>,
    pub attend: Option<(usize, usize, usize, bool)>,
    pub function_units: usize,
    pub folds: bool,
    pub streaming: Option<Streaming>,
}

What an engine is printed for: the most token-rows a step holds, the most beats a vector register holds and the most a Hadamard or rotary operand does, the store’s beats, the words of the step’s jobs, the tables’ entries, every block format its matrices are in with the most blocks a row of that format holds, and the function units its vector unit’s sixteen lanes share.

Fields

rows: usize

vector_rows: usize

side_rows: usize

The beats the vector unit’s side holds a register to: the deepest vector job it cannot run a chunk at a time (super::super::machine::VectorJob::chunked); a deeper job runs that many rows of its vectors at a time. The reference engine’s own vector unit runs every job whole, as deep as EngineParams::vector_rows.

pair_rows: usize

The beats of the vector unit’s pair copies: a far Hadamard stage’s partner rows and a rotary block’s rows are rows of the instruction’s operand, so they are within the longest operand a Hadamard or rotary job loads.

store_beats: usize

job_words: usize

tensors: usize

layers: usize

ropes: usize

formats: Vec<(GgmlType, usize)>

delta: Option<(usize, StateFlush)>

The Gated-DeltaNet blocks’ head width and how their memories are carried (logged), or None for a model of none.

attend: Option<(usize, usize, usize, bool)>

The attention blocks’ query and value head widths, the most positions a sequence reaches, and whether the math runs on the array, or None for a model of none.

function_units: usize

The vector unit’s function units, a divisor of sixteen: a function’s row takes 16 / function_units cycles.

folds: bool

Whether a matrix job folds its sums into its output slot (super::super::machine::Fold): a step lowered with its residual adds and gated products folded (super::super::machine::fold).

streaming: Option<Streaming>

The streaming unit a hybrid engine runs its matvec jobs on, or None for the reference engine, which reads each job’s matrix a line at a time through its memory port.

Implementations

impl EngineParams

pub fn streaming_signature(&self) -> String

The name the build and its programs give its streaming unit, the step program refusing a program of another: the unit’s own (Streaming::signature), and +behind<T> when its recurrence replays logs a window of T tokens behind, its lanes built for that window; empty for an engine that streams nothing.

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

The engine jobs over layout need, the store laid out as store.

pub fn union(all: &[EngineParams]) -> Result<EngineParams, String>

One engine that runs every engine of all: the most token-rows, vector rows, store beats, job words and table entries any needs, every block format any reads at the most blocks a row of it holds in any, the most positions any attends over. Engines whose recurrence or attention units differ in shape — head widths, a log’s tokens, where the attention math runs —, whose vector units share a different number of function units, or that run their matvec jobs on different streaming units have no union.

Trait Implementations

impl Clone for EngineParams

fn clone(&self) -> EngineParams

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EngineParams

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

Formats the value using the given formatter.

impl PartialEq for EngineParams

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