Enum Operation 

pub enum Operation {
    Copy(Value),
    ConstructAggregate(Vec<Value>),
    ExtractAggregateField(AggregateExtractOperands),
    DeclareVariable {
        value_ty: Type,
        addr_space: AddressSpace,
        alignment: usize,
    },
    Memory(Memory),
    Arithmetic(Arithmetic),
    Comparison(Comparison),
    Bitwise(Bitwise),
    Operator(Operator),
    Atomic(AtomicOp),
    Metadata(Metadata),
    Branch(Branch),
    Synchronization(Synchronization),
    WorkgroupUniformLoad(Value),
    Plane(Plane),
    CoopMma(CoopMma),
    Barrier(BarrierOps),
    Tma(TmaOps),
    TensorIndexing(TensorIndexingOps),
    NonSemantic(NonSemantic),
    Marker(Marker),
}

All operations that can be used in a GPU compute shader.

Notes:

Operator can be vectorized, but other operations can’t. Therefore, during tracing, only operators can be registered.

Variants

Copy(Value)

ConstructAggregate(Vec<Value>)

Construct an aggregate (i.e. fat pointer) that’s later disaggregated into normal values supported by codegen. Not allowed to exist after the disaggregation pass.

ExtractAggregateField(AggregateExtractOperands)

Extract a specific field from an aggregate (i.e. read the length from a slice ptr). Not allowed to exist after the disaggregation pass.

DeclareVariable

Fields

value_ty: Type

addr_space: AddressSpace

alignment: usize

Memory(Memory)

Arithmetic(Arithmetic)

Comparison(Comparison)

Bitwise(Bitwise)

Operator(Operator)

Atomic(AtomicOp)

Metadata(Metadata)

Branch(Branch)

Synchronization(Synchronization)

WorkgroupUniformLoad(Value)

Barrier followed by a load whose result is workgroup-uniform.

Mirrors WGSL’s workgroupUniformLoad: the input is a reference into workgroup-shared memory (&list[i], produced by Memory::Index), and both the non-atomic and atomic WGSL overloads map here. Other backends lower this to a sync_cube followed by a regular (or atomic) load — uniformity is implicit there.

Plane(Plane)

CoopMma(CoopMma)

Barrier(BarrierOps)

Tma(TmaOps)

TensorIndexing(TensorIndexingOps)

NonSemantic(NonSemantic)

Non-semantic instructions (i.e. comments, debug info)

Marker(Marker)

Trait Implementations

impl Clone for Operation

fn clone(&self) -> Operation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Operation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Operation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Operation

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

Formats the value using the given formatter.

impl Eq for Operation

impl From<(Type, AddressSpace, usize)> for Operation

fn from(value: (Type, AddressSpace, usize)) -> Self

Converts to this type from the input type.

impl From<AggregateExtractOperands> for Operation

fn from(value: AggregateExtractOperands) -> Self

Converts to this type from the input type.

impl From<Arithmetic> for Operation

fn from(value: Arithmetic) -> Self

Converts to this type from the input type.

impl From<AtomicOp> for Operation

fn from(value: AtomicOp) -> Self

Converts to this type from the input type.

impl From<BarrierOps> for Operation

fn from(value: BarrierOps) -> Self

Converts to this type from the input type.

impl From<Bitwise> for Operation

fn from(value: Bitwise) -> Self

Converts to this type from the input type.

impl From<Branch> for Operation

fn from(value: Branch) -> Self

Converts to this type from the input type.

impl From<Comparison> for Operation

fn from(value: Comparison) -> Self

Converts to this type from the input type.

impl From<CoopMma> for Operation

fn from(value: CoopMma) -> Self

Converts to this type from the input type.

impl From<Marker> for Operation

fn from(value: Marker) -> Self

Converts to this type from the input type.

impl From<Memory> for Operation

fn from(value: Memory) -> Self

Converts to this type from the input type.

impl From<Metadata> for Operation

fn from(value: Metadata) -> Self

Converts to this type from the input type.

impl From<NonSemantic> for Operation

fn from(value: NonSemantic) -> Self

Converts to this type from the input type.

impl From<Operator> for Operation

fn from(value: Operator) -> Self

Converts to this type from the input type.

impl From<Plane> for Operation

fn from(value: Plane) -> Self

Converts to this type from the input type.

impl From<Synchronization> for Operation

fn from(value: Synchronization) -> Self

Converts to this type from the input type.

impl From<TensorIndexingOps> for Operation

fn from(value: TensorIndexingOps) -> Self

Converts to this type from the input type.

impl From<TmaOps> for Operation

fn from(value: TmaOps) -> Self

Converts to this type from the input type.

impl From<Vec<Value>> for Operation

fn from(value: Vec<Value>) -> Self

Converts to this type from the input type.

impl Hash for Operation

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 OperationReflect for Operation

type OpCode = OpCode

Type of the op codes for this operation

fn op_code(&self) -> Self::OpCode

Get the opcode for this operation

fn args(&self) -> Option<Vec<Value>>

Get the list of arguments for this operation. If not all arguments are Value, returns None instead.

fn args_mut(&mut self) -> Option<Vec<&mut Value>>

fn from_code_and_args(op_code: Self::OpCode, args: &[Value]) -> Option<Self>

Create typed operation from an opcode and a list of arguments. Returns None if not all arguments are Value.

fn sanitize_args(&mut self, scope: &Scope)

Sanitize args, i.e. loading inputs from pointers for ops that take values

fn read_pointers(&self) -> Vec<Value>

fn write_pointers(&self) -> Vec<Value>

fn is_commutative(&self) -> bool

Whether this operation is commutative (arguments can be freely reordered). Ignored for single argument operations.

fn is_pure(&self) -> bool

Whether this operation is pure (has no side effects). Things like uniform/plane operations are considered impure, because they affect other units.

impl PartialEq for Operation

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Operation

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 Operation

impl TypeHash for Operation

fn write_hash(hasher: &mut impl Hasher)

Write the structure of the type to the hasher

fn type_hash() -> u64

Generate a stable hash of the type structure.