Struct Stage 

pub struct Stage {
    pub layer: Option<u32>,
    pub kind: StageKind,
    pub tensors: Vec<String>,
    pub weight_bytes: f64,
    pub weight_class: HeldClass,
    pub state_read: f64,
    pub state_write: f64,
    pub ops: f64,
    pub split: Split,
    pub reduces: bool,
    pub reduce_bytes: f64,
}

One dependent stage of the decode chain.

Fields

layer: Option<u32>

The block, or None for the embedding and the head.

kind: StageKind

tensors: Vec<String>

weight_bytes: f64

Weight bytes the stage reads per token.

weight_class: HeldClass

The held bytes those weight bytes are read from, and so the tiers they stream from: the embedding table for the embedding row and for a head tied to the table, the weights for every other stage.

state_read: f64

Carried-state bytes read per token: the KV cache, a recurrent state.

state_write: f64

Carried-state bytes written per token.

ops: f64

Matrix-engine operations per token (a multiply-add counts two).

split: Split

reduces: bool

Whether the stage’s output is summed across the chips it is split over (Megatron’s row-split projections) or reduced to one answer (the head’s arg-max).

reduce_bytes: f64

Bytes that reduction carries.

Trait Implementations

impl Clone for Stage

fn clone(&self) -> Stage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Stage

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

Formats the value using the given formatter.

impl PartialEq for Stage

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Stage