Enum TensorBody 

pub enum TensorBody {
    Operand(usize),
    Const(u64),
    Add(Box<TensorBody>, Box<TensorBody>),
    Sub(Box<TensorBody>, Box<TensorBody>),
    Mul(Box<TensorBody>, Box<TensorBody>),
    Min(Box<TensorBody>, Box<TensorBody>),
    Max(Box<TensorBody>, Box<TensorBody>),
    FloorDiv(Box<TensorBody>, Box<TensorBody>),
    Shr {
        arg: Box<TensorBody>,
        by: u32,
    },
    Unary {
        kind: SfpuKind,
        arg: Box<TensorBody>,
    },
    Select {
        cond: Pred,
        then: Box<TensorBody>,
        otherwise: Box<TensorBody>,
    },
}

The scalar expression a ComputeOp::Generic applies at each point of its iteration space.

Deliberately NOT ScalarBody: that is the CGRA’s integer LoopCell datapath, which has no home for a float transcendental. Where a body happens to be integer-expressible the fabric lowering can convert it; otherwise it refuses by name, which is what it already does today.

Variants

Operand(usize)

Operand i, indexed through ins[i].

Const(u64)

A literal, as f64 bits so the op stays Hash + Eq.

Add(Box<TensorBody>, Box<TensorBody>)

Sub(Box<TensorBody>, Box<TensorBody>)

Mul(Box<TensorBody>, Box<TensorBody>)

Min(Box<TensorBody>, Box<TensorBody>)

The smaller and the larger of two values: a clamp is one of each, a ReLU a Max with 0.

Max(Box<TensorBody>, Box<TensorBody>)

FloorDiv(Box<TensorBody>, Box<TensorBody>)

⌊a / b⌋, rounding toward −∞ — the VM’s //. A zero divisor faults.

Shr

a >> by, an arithmetic shift (⌊a / 2^by⌋): an int8 model’s requant divides by its power of two this way.

Fields

arg: Box<TensorBody>

by: u32

Unary

Fields

kind: SfpuKind

arg: Box<TensorBody>

Select

cond ? then : otherwise on an AXIS predicate — piecewise along the iteration space, decided by POSITION rather than by value, which no arithmetic on values can do. Both branches are evaluated (branch-free), so an unselected branch may read outside its page and yield 0.0. A rope window, a conv ring shift and the j < pos attention mask are each one of these.

Fields

cond: Pred

then: Box<TensorBody>

otherwise: Box<TensorBody>

Implementations

impl TensorBody

pub fn post_order(&self) -> Vec<&TensorBody>

Every node of the body, each after its operands and the left operand first — the order whose position names a node wherever a body’s nodes are counted: its proven intervals, a run’s observations, a datapath’s wires.

pub fn max_operand(&self) -> Option<usize>

The largest operand index the body names anywhere — in a leaf or in a predicate’s bound — so a validator can refuse a body that would index past the stage’s operands before an evaluator does.

pub fn pred_names_operand(&self, i: usize) -> bool

Whether a predicate anywhere in the body reads its bound from operand i.

pub fn integral(&self) -> bool

Whether the body is integer arithmetic throughout: no transcendental, and every literal a whole number an f64 holds exactly (below 2⁵³). Over integer operands such a body is evaluated in i64, exactly.

Trait Implementations

impl Clone for TensorBody

fn clone(&self) -> TensorBody

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TensorBody

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TensorBody

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for TensorBody

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 TensorBody

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

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 TensorBody

impl StructuralPartialEq for TensorBody