Struct Roofs 

pub struct Roofs {
    pub clock_ghz: Fact<f64>,
    pub mem: Vec<MemRoof>,
    pub compute: Vec<ComputeRoof>,
    pub sources: &'static [&'static str],
}

A chip’s roofs.

Fields

clock_ghz: Fact<f64>

The clock the per-cycle rates run at, in GHz.

mem: Vec<MemRoof>

compute: Vec<ComputeRoof>

sources: &'static [&'static str]

The documents every published or derived roof is read from; each such cite names one of them.

Implementations

impl Roofs

pub fn mem(&self, level: MemLevel, mix: StreamMix) -> Option<&MemRoof>

The bandwidth of level for mix: a roof measured for that very mix when there is one, else the peak that bounds every mix.

pub fn compute( &self, engine: Engine, precision: Precision, ) -> Option<&ComputeRoof>

The throughput of engine at precision.

pub fn per_cycle(&self, rate: &Fact<Rate>) -> Converted

rate per cycle of this chip’s clock.

pub fn per_second(&self, rate: &Fact<Rate>) -> Converted

rate per second at this chip’s clock.

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

Every fact the roofs carry, the clock first, each with the path a lock names it by.

impl Roofs

pub fn wormhole() -> Roofs

Tenstorrent Wormhole n150.

pub fn blackhole() -> Roofs

Tenstorrent Blackhole p150.

pub fn rtx3060() -> Roofs

The local RTX 3060. NVIDIA’s table gives the SM count (through the CUDA cores) and the boost clock but no tensor rate and no memory data rate, so the tensor rates are derived from the GA10x SM the Ampere whitepaper tabulates, and the DRAM rate is modeled until the box measures it.

pub fn h100_sxm() -> Roofs

NVIDIA H100 SXM. The product table gives memory bandwidth and tensor rates “With sparsity”; a dense rate is half of it, which is what a dense matrix-vector product can use. The table gives no clock, and every rate here is per second, so nothing is converted through the one recorded.

pub fn h100_nvl() -> Roofs

NVIDIA H100 NVL: the PCIe card the Qwen3.8-27B decode runs were measured on. Its product brief gives the clock and the exact memory bandwidth; the tensor rates are the product table’s, halved from sparse.

pub fn a100_sxm4_80gb() -> Roofs

NVIDIA A100 80GB SXM. Its product table states the dense rate first and the sparse rate after it.

pub fn b200() -> Roofs

One GPU of the NVIDIA DGX/HGX B200. NVIDIA tabulates the 8-GPU system, so each rate is the system’s over eight, and each tensor rate the sparse figure halved per the table’s own footnote.

pub fn catalog() -> Vec<(&'static str, Roofs)>

Every roofs preset, by name: the chips a decode is priced on and the spatial targets’ own.

pub fn sky_fabric() -> Roofs

Our own fabric. Its matrix engine is not a fixed part: each program instantiates a k x n systolic array sized by its plan’s block, and the cycle twin times that array exactly, so the fabric carries no matrix roof. What every program on it shares is the address lane, which carries one element per cycle whatever its width. The clock is the largest signed-off array’s.

pub fn xc7_fabric() -> Roofs

The fabric on a 7-series FPGA: the same element-serial lanes as sky_fabric, clocked from the board.

Trait Implementations

impl Clone for Roofs

fn clone(&self) -> Roofs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Roofs

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

Formats the value using the given formatter.

impl PartialEq for Roofs

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

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 Roofs