Enum Node 

#[non_exhaustive]
pub enum Node {
    Let {
        name: Ident,
        value: Expr,
    },
    Assign {
        name: Ident,
        value: Expr,
    },
    Store {
        buffer: Ident,
        index: Expr,
        value: Expr,
    },
    If {
        cond: Expr,
        then: Vec<Node>,
        otherwise: Vec<Node>,
    },
    Loop {
        var: Ident,
        from: Expr,
        to: Expr,
        body: Vec<Node>,
    },
    IndirectDispatch {
        count_buffer: Ident,
        count_offset: u64,
    },
    AsyncLoad {
        source: Ident,
        destination: Ident,
        offset: Box<Expr>,
        size: Box<Expr>,
        tag: Ident,
    },
    AsyncStore {
        source: Ident,
        destination: Ident,
        offset: Box<Expr>,
        size: Box<Expr>,
        tag: Ident,
    },
    AsyncWait {
        tag: Ident,
    },
    Trap {
        address: Box<Expr>,
        tag: Ident,
    },
    Resume {
        tag: Ident,
    },
    AllReduce {
        buffer: Ident,
        op: CollectiveOp,
        group: CommGroup,
    },
    AllGather {
        input: Ident,
        output: Ident,
        group: CommGroup,
    },
    ReduceScatter {
        input: Ident,
        output: Ident,
        op: CollectiveOp,
        group: CommGroup,
    },
    Broadcast {
        buffer: Ident,
        root: u32,
        group: CommGroup,
    },
    Return,
    Barrier {
        ordering: MemoryOrdering,
    },
    Block(Vec<Node>),
    Region {
        generator: Ident,
        source_region: Option<GeneratorRef>,
        body: Arc<Vec<Node>>,
    },
    Opaque(Arc<dyn NodeExtension>),
}

Statement nodes - execute effects.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Let

Fields

name: Ident

value: Expr

Assign

Fields

name: Ident

value: Expr

Store

Fields

buffer: Ident

index: Expr

value: Expr

If

Fields

cond: Expr

then: Vec<Node>

otherwise: Vec<Node>

Loop

Fields

var: Ident

from: Expr

to: Expr

body: Vec<Node>

IndirectDispatch

Fields

count_buffer: Ident

count_offset: u64

AsyncLoad

Fields

source: Ident

destination: Ident

offset: Box<Expr>

size: Box<Expr>

tag: Ident

AsyncStore

Fields

source: Ident

destination: Ident

offset: Box<Expr>

size: Box<Expr>

tag: Ident

AsyncWait

Fields

tag: Ident

Trap

Fields

address: Box<Expr>

tag: Ident

Resume

Fields

tag: Ident

AllReduce

Fields

buffer: Ident

op: CollectiveOp

group: CommGroup

AllGather

Fields

input: Ident

output: Ident

group: CommGroup

ReduceScatter

Fields

input: Ident

output: Ident

op: CollectiveOp

group: CommGroup

Broadcast

Fields

buffer: Ident

root: u32

group: CommGroup

Return

Barrier

Fields

ordering: MemoryOrdering

Block(Vec<Node>)

Region

Fields

generator: Ident

source_region: Option<GeneratorRef>

body: Arc<Vec<Node>>

Opaque(Arc<dyn NodeExtension>)

Implementations

impl Node

pub fn let_bind(name: impl Into<Ident>, value: Expr) -> Self

let name = value;

Examples

use vyre::ir::{Expr, Node};
let _ = Node::let_bind("x", Expr::u32(1));

pub fn assign(name: impl Into<Ident>, value: Expr) -> Self

name = value;

Examples

use vyre::ir::{Expr, Node};
let _ = Node::assign("x", Expr::u32(2));

pub fn store(buffer: impl Into<Ident>, index: Expr, value: Expr) -> Self

buffer[index] = value;

Examples

use vyre::ir::{Expr, Node};
let _ = Node::store("out", Expr::u32(0), Expr::u32(1));

pub fn if_then_else(cond: Expr, then: Vec<Self>, otherwise: Vec<Self>) -> Self

if cond { then } else { otherwise }

Examples

use vyre::ir::{Expr, Node};
let _ = Node::if_then_else(Expr::bool(true), vec![Node::Return], vec![]);

pub fn if_then(cond: Expr, then: Vec<Self>) -> Self

if cond { then }

Examples

use vyre::ir::{Expr, Node};
let _ = Node::if_then(Expr::bool(true), vec![Node::Return]);

pub fn loop_for( var: impl Into<Ident>, from: Expr, to: Expr, body: Vec<Self>, ) -> Self

for var in from..to { body }

Examples

use vyre::ir::{Expr, Node};
let _ = Node::loop_for("i", Expr::u32(0), Expr::u32(4), vec![]);

pub fn loop_( var: impl Into<Ident>, from: Expr, to: Expr, body: Vec<Self>, ) -> Self

for var in from..to { body }

Examples

use vyre::ir::{Expr, Node};

let node = Node::loop_("i", Expr::u32(0), Expr::u32(4), vec![Node::Return]);
assert!(matches!(node, Node::Loop { .. }));

pub fn forever(body: Vec<Self>) -> Self

Effectively-infinite loop used by persistent kernels (megakernel, event loops, streaming). Lowers to Node::Loop with from: 0, to: u32::MAX. At 1 µs per iteration u32::MAX is ~68 years - for all practical purposes infinite. The inner body drives termination via Node::Return or by observing an atomic shutdown flag the host sets.

Linus principle: one enum variant (Node::Loop) handles both bounded and persistent cases. No cascade of match arms through every pass; no new wire-format tag. An optimizer pass that wants to distinguish “truly unbounded” from “large bound” inspects the to expression.

Examples

use vyre::ir::Node;

let persistent = Node::forever(vec![Node::Return]);
assert!(matches!(persistent, Node::Loop { .. }));

pub fn block(nodes: Vec<Self>) -> Self

Sequence of statements.

Examples

use vyre::ir::Node;

assert!(matches!(Node::block(vec![Node::Return]), Node::Block(_)));

pub const fn return_() -> Self

Early return from the entry point.

Examples

use vyre::ir::Node;

assert!(matches!(Node::return_(), Node::Return));

pub const fn barrier() -> Self

Workgroup barrier statement.

Examples

use vyre::ir::Node;

assert!(matches!(Node::barrier(), Node::Barrier { .. }));

pub const fn barrier_with_ordering(ordering: MemoryOrdering) -> Self

Workgroup barrier statement with explicit memory ordering.

pub fn call(op_id: impl Into<Ident>, args: Vec<Expr>) -> Self

Statement-level invocation of another registered op by stable op id.

Represented as a named Node::Region whose generator is the callee’s op id and whose body is an internal sequence of Node::Let { name: "arg{i}", value: <arg_expr> } bindings. Every backend already handles Node::Region - the op-registry inliner walks the arg binds, substitutes them into the callee’s fragment, and splices the result in place. No new IR variant is introduced, and the arg values remain fully visible to CSE, DCE, and constant folding through the let-chain.

pub fn indirect_dispatch( count_buffer: impl Into<Ident>, count_offset: u64, ) -> Self

Command-level indirect dispatch metadata.

Examples

use vyre::ir::Node;

let node = Node::indirect_dispatch("counts", 0);
assert!(matches!(node, Node::IndirectDispatch { .. }));

pub fn async_load_gpu_driven( source: impl Into<Ident>, destination: impl Into<Ident>, offset: Expr, size: Expr, tag: impl Into<Ident>, ) -> Self

Begin an asynchronous transfer stream region that names its own operands, so the GPU drives the transfer.

Examples

use vyre::ir::{Node, Expr};

let node = Node::async_load_gpu_driven("ssd", "vram", Expr::u32(0), Expr::u32(1024), "tag-0");
assert!(matches!(node, Node::AsyncLoad { .. }));

pub fn async_load(tag: impl Into<Ident>) -> Self

Begin an asynchronous transfer stream region carrying only a tag.

The host drives the transfer and knows the buffers out of band, so the node records placeholder operands. Emit Node::async_load_gpu_driven when the source, destination, offset, and size are known in the IR.

pub fn async_store( source: impl Into<Ident>, destination: impl Into<Ident>, offset: Expr, size: Expr, tag: impl Into<Ident>, ) -> Self

Begin an asynchronous store transfer stream region (GPU-driven).

pub fn async_wait(tag: impl Into<Ident>) -> Self

Wait for an asynchronous transfer stream region.

Examples

use vyre::ir::Node;

let node = Node::async_wait("stage-a");
assert!(matches!(node, Node::AsyncWait { .. }));

pub fn trap(address: Expr, tag: impl Into<Ident>) -> Self

Trap the current execution lane (GPU-initiated page fault).

pub fn resume(tag: impl Into<Ident>) -> Self

Resume a previously trapped execution lane.

pub fn opaque(node: impl NodeExtension) -> Self

Wrap a downstream extension statement node.

pub fn opaque_arc(node: Arc<dyn NodeExtension>) -> Self

Wrap a shared downstream extension statement node.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl PartialEq for Node

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

Equality operator ==.

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

Inequality operator !=.