Struct Card 

pub struct Card {
    pub name: &'static str,
    pub memory: Tier,
    pub on_chip: Tier,
    pub streams: Streams,
    pub array: Fact<f64>,
    pub vector: Fact<f64>,
    pub scale: Fact<f64>,
    pub host: Option<HostLink>,
    pub sources: &'static [&'static str],
}

A card that streams its weights, as a pass sees it.

Fields

name: &'static str

memory: Tier

Off-chip memory: the weights, and every KV cache and recurrent state it holds.

on_chip: Tier

On-chip memory: the batch’s token-rows through a layer.

streams: Streams

The shares of memory’s bandwidth the stream engines sustain.

array: Fact<f64>

Multiply-adds per second the integer array retires: a 4-bit weight code times an 8-bit activation code.

vector: Fact<f64>

f32 multiply-adds per second the vector units retire: norms, attention, the recurrence, float matrices.

scale: Fact<f64>

Cycles per second the block-scale lanes retire, all lanes together (lane_cycles).

host: Option<HostLink>

sources: &'static [&'static str]

Implementations

impl Card

pub fn facts(&self) -> Vec<(String, Provenance, &'static str)>

Every fact the card carries, with the path a lock names it by.

Trait Implementations

impl Clone for Card

fn clone(&self) -> Card

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Card

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

Formats the value using the given formatter.

impl PartialEq for Card

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

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 Card