Struct SizeClass 

pub struct SizeClass(pub u32);

Dispatch size bucket. One u32 field carries two representations, disambiguated by the OpKind that always sits beside it in the dispatch key (a matmul key is only ever compared to matmul keys):

• Total-elements key (every non-matmul op — elementwise, reduce, cast, …): the value is log2(total_elements). A 256×256 elementwise tensor (65,536 elements) → 16; a 1024×1024 (1,048,576) → 20. Built by SizeClass::from_elem_count. Two shapes that round to the same bucket share a profile entry.

• MatMul aspect key: matmul cost is aspect-dependent — a [1,K]×[K,N] GEMV is bandwidth-bound, a square [S,S]×[S,S] GEMM of the same output size is compute-bound — so log2(total_elements) alone can’t tell them apart. A matmul packs all three dims: (log2(m·n) << 16) | (log2(m) << 8) | log2(k), read from lhs=[…,m,k] / rhs=[…,k,n]. log2(m·n) occupies the high byte so DispatchTable::pick_nearest’s magnitude ordering still tracks output size, while the low bytes distinguish aspect (a GEMV and a same-output-size square never collide, because their log2(m) bytes differ). Built by SizeClass::matmul.

Producer/consumer single-sourcing. The fuel-core Judge (producer) and every consumer (the fuel-dispatch ranker at realize time) derive the key through the SAME helpers — SizeClass::matmul from native (m,n,k) on the producer side, SizeClass::for_op from the operand shapes on the consumer side. A given matmul shape therefore maps to one identical key on both sides, so a cell the Judge profiles is found by the ranker at dispatch time (the bug this repr fixes: the old scalar key had the producer on m·n and the consumer on m·k, so non-square matmul lookups always missed).

Tuple Fields

0: u32

Implementations

impl SizeClass

pub fn from_elem_count(n: usize) -> SizeClass

Bucket a raw element count as log2(n) — the total-elements key used by every non-matmul op. n == 0 clamps to 1 (→ 0).

pub fn matmul(m: usize, n: usize, k: usize) -> SizeClass

Aspect-carrying dispatch key for a matmul [m,k] × [k,n].

THE single source of matmul-key derivation: both the Judge (producer, from its native (m,n,k)) and the ranker (consumer, via SizeClass::for_op from operand shapes) call this, so both sides agree for every shape. Packs (log2(m·n) << 16) | (log2(m) << 8) | log2(k); each log2 fits a byte (≤ 63 for any usize). A [1,K]×[K,N] GEMV (m = 1) never collides with a square GEMM of equal output size — the log2(m) byte differs.

pub fn attention(hq: usize, k_len: usize, d: usize) -> SizeClass

Aspect-carrying dispatch key for a decode attention op (OpKind::FlashAttn): q = [B, Hq, Sq, D], K/V attended length k_len, head dim d.

THE single source of attention-key derivation, mirroring SizeClass::matmul: both the Judge (producer, from its native OpSize::Attention (hq, k_len, d)) and the flash-vs-decomposed bake (consumer, via SizeClass::for_op from the flash node’s operand shapes) call this, so both sides agree for every shape. Packs (log2(hq·k_len·d) << 16) | (log2(k_len) << 8) | log2(d): the high 16 bits track total attention work (O(Hq·k_len·D) for the QKᵀ + PV matmuls at seq_q=1), so DispatchTable::pick_nearest’s magnitude ordering still follows problem size, while the low bytes carry the k_len (context-length / bandwidth regime) and head-dim aspects — so two decode shapes that differ only in k_len (short vs capacity context) never collide onto one cell. Each log2 fits a byte (≤ 63 for any usize).

pub fn for_op(op: OpKind, input_shapes: &[Shape]) -> SizeClass

Derive the dispatch key for op from its input operand shapes — the single entry point every consumer uses. A OpKind::MatMul reads (m,n,k) from lhs=[…,m,k] / rhs=[…,k,n] (trailing two dims; leading batch dims don’t affect the key) and keys via SizeClass::matmul; every other op keys on the first operand’s total element count via SizeClass::from_elem_count. Empty shapes (nullary op) → SizeClass(0).

Trait Implementations

impl Clone for SizeClass

fn clone(&self) -> SizeClass

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SizeClass

impl Debug for SizeClass

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SizeClass

fn deserialize<__D>( __deserializer: __D, ) -> Result<SizeClass, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SizeClass

impl Hash for SizeClass

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for SizeClass

fn cmp(&self, other: &SizeClass) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for SizeClass

fn eq(&self, other: &SizeClass) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for SizeClass

fn partial_cmp(&self, other: &SizeClass) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for SizeClass

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SizeClass