Enum ComputeOp 

pub enum ComputeOp {
    MatmulTiles {
        block: BlockShape,
        sub_blocks: (usize, usize),
        num_blocks: usize,
        operand: Precision,
        acc: AccPolicy,
        dataflow: DataflowPolicy,
        interm: Option<BufferId>,
        granularity: Granularity,
    },
    Requant {
        m: i64,
        s: u32,
    },
    Bias {
        bias: BufferId,
    },
    Relu,
    Generic {
        iters: Vec<IterSpec>,
        ins: Vec<ElemAccess>,
        out: ElemAccess,
        body: TensorBody,
    },
    Scalar(ScalarBody),
}

Variants

MatmulTiles

Fields

block: BlockShape

sub_blocks: (usize, usize)

Sub-blocks per site block: (per_site_m / osh, per_site_n / osw).

num_blocks: usize

operand: Precision

acc: AccPolicy

dataflow: DataflowPolicy

interm: Option<BufferId>

granularity: Granularity

Requant

Fields

m: i64

s: u32

Bias

Fields

bias: BufferId

Relu

Generic

★ THE GENERAL FORM — an iteration space, an affine access map per operand, and a scalar body.

Everything the vector/SFPU path does is one of these. The two facts that make it general:

A reduction is not an operator, it is an ITERATOR. An axis marked IterKind::Reduce is folded away and does not appear in out.

A broadcast is not an operator, it is an ABSENT TERM. An operand whose map omits an axis is CONSTANT along it. A per-row scalar omits the column axis; a per-column weight omits the row axis. Two operators (RowRescale, RowBroadcast) become one map read two ways, and the printer recovers mul_tiles_bcast_cols vs mul_tiles_bcast_rows from which axis is missing — which is the compiler doing the work instead of a human naming the case.

The iteration space is at ELEMENT granularity (a row axis over the tile’s 32 rows, a column axis over col_tiles * 32), because that is the only granularity at which a row reduction and a column broadcast are expressible at all; tile-level indices cannot say “constant along the columns inside a tile”.

Fields

iters: Vec<IterSpec>

ins: Vec<ElemAccess>

One map per operand, positionally matching the stage’s ins.

out: ElemAccess

body: TensorBody

Scalar(ScalarBody)

A scalar dataflow body applied element-wise over the input tiles (the choreography form of a StageKind::Scalar stage).

Implementations

impl ComputeOp

pub fn shape(&self) -> Result<ComputeShape<'_>, &'static str>

The op’s ComputeShape. A requant’s multiplier enters its body as a constant, which holds it exactly while it is within ±2⁵³.

Trait Implementations

impl Clone for ComputeOp

fn clone(&self) -> ComputeOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComputeOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ComputeOp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for ComputeOp

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

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 PartialEq for ComputeOp

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ComputeOp

impl StructuralPartialEq for ComputeOp