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) -> Node

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) -> Node

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) -> Node

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<Node>, otherwise: Vec<Node>) -> Node

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<Node>) -> Node

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<Node>, ) -> Node

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<Node>, ) -> Node

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<Node>) -> Node

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<Node>) -> Node

Sequence of statements.

Examples

use vyre::ir::Node;

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

pub const fn return_() -> Node

Early return from the entry point.

Examples

use vyre::ir::Node;

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

pub const fn barrier() -> Node

Workgroup barrier statement.

Examples

use vyre::ir::Node;

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

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

Workgroup barrier statement with explicit memory ordering.

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

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, ) -> Node

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_ext( source: impl Into<Ident>, destination: impl Into<Ident>, offset: Expr, size: Expr, tag: impl Into<Ident>, ) -> Node

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

Examples

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

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

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

Begin an asynchronous transfer stream region (legacy/host-driven).

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

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

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

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>) -> Node

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

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

Resume a previously trapped execution lane.

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

Wrap a downstream extension statement node.

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

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<(), Error>

Formats the value using the given formatter.

impl PartialEq for Node

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

Equality operator ==.

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

Inequality operator !=.