Enum KernelInstruction 

pub enum KernelInstruction {
    Cached(usize),
    RealConstant(f64),
    ComplexConstant(Complex64),
    Parameter(ParamId),
    Unary {
        op: UnaryOp,
        input: KernelValueId,
    },
    Binary {
        op: BinaryOp,
        lhs: KernelValueId,
        rhs: KernelValueId,
    },
    Add(Vec<KernelValueId>),
    Mul(Vec<KernelValueId>),
    Complex {
        re: KernelValueId,
        im: KernelValueId,
    },
    Vector(Vec<KernelValueId>),
    Matrix {
        rows: usize,
        cols: usize,
        elements: Vec<KernelValueId>,
    },
    Component {
        input: KernelValueId,
        index: usize,
    },
    MatrixElement {
        input: KernelValueId,
        row: usize,
        col: usize,
    },
    MatMul {
        lhs: KernelValueId,
        rhs: KernelValueId,
    },
    MatVec {
        matrix: KernelValueId,
        vector: KernelValueId,
    },
    Dot {
        lhs: KernelValueId,
        rhs: KernelValueId,
    },
    Solve {
        matrix: KernelValueId,
        rhs: KernelValueId,
    },
    SolveRow {
        row_slot: usize,
        rhs: Vec<KernelValueId>,
    },
    SolveRowAdjointElement {
        row_slot: usize,
        index: usize,
        len: usize,
        adjoint: KernelValueId,
    },
}

Operation that produces one value in kernel IR.

Variants

Cached(usize)

Reads a precomputed cache slot.

RealConstant(f64)

Emits a real constant.

ComplexConstant(Complex64)

Emits a complex constant.

Parameter(ParamId)

Reads a scalar parameter.

Unary

Applies a unary scalar operation.

Fields

op: UnaryOp

Operation to apply.

input: KernelValueId

Input value.

Binary

Applies a binary scalar operation.

Fields

op: BinaryOp

Operation to apply.

lhs: KernelValueId

Left operand.

rhs: KernelValueId

Right operand.

Add(Vec<KernelValueId>)

Adds scalar operands.

Mul(Vec<KernelValueId>)

Multiplies scalar operands.

Complex

Constructs a complex scalar from real components.

Fields

re: KernelValueId

Real component.

im: KernelValueId

Imaginary component.

Vector(Vec<KernelValueId>)

Constructs a vector from scalar elements.

Matrix

Constructs a row-major matrix.

Fields

rows: usize

Number of rows.

cols: usize

Number of columns.

elements: Vec<KernelValueId>

Row-major scalar elements.

Component

Selects a vector component.

Fields

input: KernelValueId

Vector input.

index: usize

Zero-based component index.

MatrixElement

Selects a matrix element.

Fields

input: KernelValueId

Matrix input.

row: usize

Zero-based row index.

col: usize

Zero-based column index.

MatMul

Multiplies two matrices.

Fields

lhs: KernelValueId

Left matrix.

rhs: KernelValueId

Right matrix.

MatVec

Multiplies a matrix by a vector.

Fields

matrix: KernelValueId

Matrix operand.

vector: KernelValueId

Vector operand.

Dot

Computes a vector dot product.

Fields

lhs: KernelValueId

Left vector.

rhs: KernelValueId

Right vector.

Solve

Solves a linear system.

Fields

matrix: KernelValueId

Coefficient matrix.

rhs: KernelValueId

Right-hand-side vector.

SolveRow

Evaluates one row of a specialized cached solve.

Fields

row_slot: usize

Cache slot containing the decomposed matrix row data.

rhs: Vec<KernelValueId>

Right-hand-side scalar values.

SolveRowAdjointElement

Evaluates one adjoint element for a specialized solve row.

Fields

row_slot: usize

Cache slot containing the decomposed matrix row data.

index: usize

Element index within the row.

len: usize

Row length.

adjoint: KernelValueId

Incoming scalar adjoint.

Implementations

impl KernelInstruction

pub fn diagnostic_name(&self) -> &'static str

Returns the stable instruction name used in diagnostics and support reporting.

pub fn event_dependence(&self) -> KernelEventDependence

Returns the backend-independent event-dependence rule for this instruction.

pub fn operands(&self) -> Vec<KernelValueId>

Returns the direct input value identifiers.

pub fn for_each_operand(&self, visit: impl FnMut(KernelValueId))

Visits direct operands in their instruction order without allocating.

The owned Self::operands method remains available for callers that need a collected list. Backend dependency and liveness analysis should prefer this callback when it only needs to traverse the operands.

Trait Implementations

impl Clone for KernelInstruction

fn clone(&self) -> KernelInstruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KernelInstruction

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

Formats the value using the given formatter.