Struct Requirement 

pub struct Requirement {

    pub node: &'static str,
    pub die_mm2: f64,
    pub network: OnChipNetwork,
    pub chips: u32,
    pub sram_per_chip_bytes: f64,
    pub target_tok_s: f64,
    pub floor_tok_s: f64,
    pub stages: usize,
    pub collectives: usize,
    pub stage_budget_s: Option<f64>,
    pub design_stage_s: f64,
    pub hop_budget_s: Option<f64>,
    pub by_hop_latency: Vec<(f64, f64)>,
}

What a LOGOS system must achieve to beat a GPU deployment’s floor by a speedup on one checkpoint.

Fields

node: &'static str

die_mm2: f64

network: OnChipNetwork

chips: u32

The fewest chips whose SRAM holds the deployment.

sram_per_chip_bytes: f64

target_tok_s: f64

Tokens per second the system must reach: the GPU floor times the speedup.

floor_tok_s: f64

The system’s own floor at those chips: its memory roofline.

stages: usize

Dependent stages per token, and those that reduce across chips.

collectives: usize

stage_budget_s: Option<f64>

The most one dependent stage may take on chip with chip-to-chip hops free, or None if even free stages miss the target.

design_stage_s: f64

The design’s own on-chip stage latency.

hop_budget_s: Option<f64>

The most one chip-to-chip hop may take with the design’s own stage latency, or None if the design’s stage latency alone misses the target.

by_hop_latency: Vec<(f64, f64)>

Predicted tokens per second at the design’s stage latency, by chip-to-chip hop latency.

Trait Implementations

impl Clone for Requirement

fn clone(&self) -> Requirement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Requirement

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

Formats the value using the given formatter.

impl PartialEq for Requirement

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

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 Requirement