Struct Machine 

pub struct Machine {
    pub spec: ModelSpec,
    pub identity: Identity,
    pub layout: Layout,
    pub jobs: Vec<Job>,
    /* private fields */
}

A checkpoint on the machine: its layout, its jobs, and the card’s memory they run over.

Fields

spec: ModelSpec

identity: Identity

The cut of the model’s one program the machine’s step was read off.

layout: Layout

jobs: Vec<Job>

Implementations

impl Machine

pub fn new( spec: ModelSpec, source: impl WeightSource, numerics: EngineNumerics, sequences: usize, ctx: usize, ) -> Result<Machine, EngineError>

spec at numerics with room for sequences sequences of ctx positions each, its weight image and rotary tables written from source.

pub fn folded(self) -> Machine

The machine with its step’s residual adds and gated products folded into the matrix jobs that alone feed them (fold): every value the step computes as it was, in fewer jobs over fewer slots.

pub fn delta_normed(self) -> Machine

The machine with each recurrence job’s gated norm folded into it (fold_delta_norms): every value the step computes as it was, the norm made where the read-outs are.

pub fn memory(&self) -> &[u8]

The card’s memory.

pub fn sequence(&mut self) -> Result<usize, EngineError>

A fresh sequence at position 0 in the first region no sequence holds, the region cleared; its handle, the region’s index.

pub fn release(&mut self, sequence: usize)

The sequence sequence ends: its region is free for the next.

pub fn position(&self, sequence: usize) -> usize

pub fn step( &mut self, entries: &[(usize, Vec<u32>)], ) -> Result<Vec<Vec<Vec<f32>>>, EngineError>

Run each listed sequence’s tokens at its next positions; returns, per entry, the logits after each token, as super::model::EngineModel::step does.

pub fn step_traced( &mut self, entries: &[(usize, Vec<u32>)], trace: &mut dyn FnMut(Trace<'_>), ) -> Result<Vec<Vec<Vec<f32>>>, EngineError>

step, with trace shown the machine before each job and after the last.