Enum ComputeCap 

pub enum ComputeCap {
    MatmulTile {
        precisions: BTreeSet<Precision>,
        fidelity: Fidelity,
        fp32_acc: bool,
        dataflows: BTreeSet<DataflowPolicy>,
        block_api: Option<BlockApi>,
        acc_int_bits: u32,
        max_array: Option<(usize, usize)>,
        packer_accumulate: PackerAccumulate,
        wide_spill_reload: bool,
        acc_in_registers: bool,
    },
    Elementwise {
        precisions: BTreeSet<Precision>,
    },
    RowReduce {
        precisions: BTreeSet<Precision>,
    },
    Scalar(FabricTarget),
}

A compute capability a site offers.

Variants

MatmulTile

Fields

precisions: BTreeSet<Precision>

fidelity: Fidelity

fp32_acc: bool

dataflows: BTreeSet<DataflowPolicy>

block_api: Option<BlockApi>

The engine accepts a whole sub-block per call (Tensix matmul_block), by this API; None takes one tile pair per call, two loads.

acc_int_bits: u32

Accumulator width of the integer path (64 on the exact fabrics, 32 on a tensor core).

max_array: Option<(usize, usize)>

The largest PE array the engine builds, (contraction rows, output columns): a matmul’s block is cut to it and its contraction runs across several passes. None where each matmul’s block sets the array (a fabric sized per program) or the engine’s tile does (Tensix, a tensor core).

packer_accumulate: PackerAccumulate

Whether the packer can ADD into a local-memory page instead of overwriting it, and into which.

wide_spill_reload: bool

A spilled partial in the accumulator’s own width can be reloaded into the register file. On Wormhole and Blackhole under this tt-metal build the simulator refuses the Float32 unpack that reload needs (tensix_unpacr: unpack_to_dst=0 in_data_format=0 out_data_format=0) even with the buffer marked UnpackToDestFp32, so an EXACT blocked plan may not spill there — it keeps its partials in the register file (one K block) or streams.

acc_in_registers: bool

★ THE ACCUMULATOR LIVES IN THE COMPUTE ENGINE’S OWN REGISTERS and survives the WHOLE reduction, so a blocked plan never spills a partial at all.

This is the GPU: a wmma fragment is register-resident and the K loop runs inside the accumulate region, which is exactly what the CUDA lowering emits (and why it refuses an accumulator spill outright — “the fragments never leave the registers”).

Tensix is the other case: DST is a shared register file that must be DRAINED per sub-block, so a multi-block reduction spills its partial to local memory and reloads it. Conflating the two made every blocked GPU plan illegal under exact numerics — the spill it was refused for is one it would never perform — leaving only the streaming family, which computes ONE output tile per item and measured 214 GOPS against the knob lattice’s 16,591 at 2048³.

Elementwise

Fields

precisions: BTreeSet<Precision>

RowReduce

Fields

precisions: BTreeSet<Precision>

Scalar(FabricTarget)

A per-site scalar datapath — the CGRA descriptor, embedded.

Trait Implementations

impl Clone for ComputeCap

fn clone(&self) -> ComputeCap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComputeCap

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

Formats the value using the given formatter.

impl PartialEq for ComputeCap

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

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 ComputeCap