Struct IntGraph 

pub struct IntGraph { /* private fields */ }

Integer expression graph with structural interning.

Implementations

impl IntGraph

pub fn to_wgsl_body( &self, outputs: &[IId], params: &[&str], dests: &[&str], depth: usize, ) -> String

WGSL statements computing outputs: param i reads the expression params[i], output k is assigned to dests[k]. Needs WGSL_PRELUDE in the module when the graph uses MulHi; buffers are referenced by their declared names.

pub fn to_wgsl_body_guarded( &self, outputs: &[IId], params: &[&str], dests: &[&str], depth: usize, ) -> String

Self::to_wgsl_body with every load bounds-checked against arrayLength (out of bounds reads 0, as in Program). For untrusted graphs; buffers must be runtime-sized storage arrays.

pub fn to_wgsl_fn(&self, name: &str, outputs: &[IId]) -> String

A WGSL function fn name(p0: T0, …) -> name_out returning a struct of the outputs (o0, o1, …).

pub fn to_rust(&self, name: &str, outputs: &[IId]) -> String

A Rust function fn name(p0: T0, …, buf: &[u32], …) -> [T; N] (or a tuple when the output types differ); buffers take u32 words (8-bit elements packed little endian).

impl IntGraph

pub fn eval(&self, outputs: &[IId], params: &[u32], bufs: &[&[u32]]) -> Vec<u32>

Evaluate outputs once (compiles a Program; reuse one for speed).

impl IntGraph

pub fn to_bytes(&self, outputs: &[IId]) -> Vec<u8>

Serialize the whole graph with outputs (see the module docs). Buffers are not named on the wire; the reader supplies the ABI.

pub fn from_bytes( bytes: &[u8], params: &[IType], bufs: &[(&str, Elem)], outs: &[IType], lim: &Limits, ) -> Result<(IntGraph, Vec<IId>), WireError>

Read and verify an untrusted graph (see the module docs). params gives the type of each parameter, bufs the name and element type of each buffer, outs the output types. Returns the graph and its outputs.

pub fn from_bytes_rw( bytes: &[u8], params: &[IType], bufs: &[(&str, Elem)], rw: &[(&str, Elem, u32, &str)], outs: &[IType], lim: &Limits, ) -> Result<(IntGraph, Vec<IId>), WireError>

Self::from_bytes with scratch buffers after the read-only ones: (name, elem, length, WGSL base expression) each, all from the caller.

impl IntGraph

pub fn new() -> Self

Empty graph.

pub fn len(&self) -> usize

Number of nodes.

pub fn is_empty(&self) -> bool

Whether the graph has no nodes.

pub fn node(&self, id: IId) -> INode

Node of id.

pub fn ty(&self, id: IId) -> IType

Type of id.

pub fn loop_(&self, l: u32) -> &Loop

Loop l.

pub fn buffers(&self) -> &[Buffer]

Declared buffers.

pub fn i32(&mut self, v: i32) -> IId

i32 constant.

pub fn u32(&mut self, v: u32) -> IId

u32 constant.

pub fn bool(&mut self, v: bool) -> IId

bool constant.

pub fn param(&mut self, i: u16, t: IType) -> IId

Function input i of type t.

pub fn buffer(&mut self, name: &str, elem: Elem) -> u16

Declare a read-only buffer; returns its index for load.

pub fn buffer_rw(&mut self, name: &str, elem: Elem, len: u32, base: &str) -> u16

Declare a scratch buffer of len 32-bit elements (elem is I32 or U32), at name[base + i] in WGSL.

pub fn token(&mut self) -> IId

The initial effect token.

pub fn load_rw(&mut self, buf: u16, index: IId, tok: IId) -> IId

buf[index] of a scratch buffer as of effect token tok.

pub fn store(&mut self, buf: u16, index: IId, value: IId, tok: IId) -> IId

buf[index] = value after tok; returns the next token.

pub fn load(&mut self, buf: u16, index: IId) -> IId

buf[index], widened per Elem.

pub fn bin(&mut self, op: BinOp, a: IId, b: IId) -> IId

Binary op.

pub fn add(&mut self, a: IId, b: IId) -> IId

Wrapping a + b.

pub fn sub(&mut self, a: IId, b: IId) -> IId

Wrapping a − b.

pub fn mul(&mut self, a: IId, b: IId) -> IId

Wrapping a × b.

pub fn mul_wide(&mut self, a: IId, b: IId) -> (IId, IId)

Exact 64-bit product as (lo, hi).

pub fn and(&mut self, a: IId, b: IId) -> IId

a & b.

pub fn or(&mut self, a: IId, b: IId) -> IId

a | b.

pub fn xor(&mut self, a: IId, b: IId) -> IId

a ^ b.

pub fn shl(&mut self, a: IId, b: IId) -> IId

a << (b mod 32).

pub fn shr(&mut self, a: IId, b: IId) -> IId

a >> (b mod 32), arithmetic for i32.

pub fn min(&mut self, a: IId, b: IId) -> IId

min(a, b).

pub fn max(&mut self, a: IId, b: IId) -> IId

max(a, b).

pub fn clamp(&mut self, x: IId, lo: IId, hi: IId) -> IId

min(max(x, lo), hi).

pub fn neg(&mut self, a: IId) -> IId

Wrapping −a.

pub fn not(&mut self, a: IId) -> IId

!a (bitwise on integers).

pub fn clz(&mut self, a: IId) -> IId

Leading zero bits of a (firstLeadingBit(a) = 31 − clz(a) for a > 0).

pub fn cmp(&mut self, op: CmpOp, a: IId, b: IId) -> IId

Comparison.

pub fn eq(&mut self, a: IId, b: IId) -> IId

a == b.

pub fn lt(&mut self, a: IId, b: IId) -> IId

a < b.

pub fn le(&mut self, a: IId, b: IId) -> IId

a <= b.

pub fn select(&mut self, c: IId, a: IId, b: IId) -> IId

if c { a } else { b }.

pub fn bitcast(&mut self, t: IType, a: IId) -> IId

Reinterpret as t.

pub fn while_loop( &mut self, init: &[IId], body: impl FnOnce(&mut Self, &[IId]) -> (IId, Vec<IId>), ) -> Vec<IId>

s = init; while cond(s) { s = next(s) }; returns the final states.

body gets the state nodes and returns (cond, next).

pub fn cap_loop(&mut self, out: IId, cap: u32)

Cap the trip count of the loop that produced out (a loop result).

pub fn div(&mut self, a: IId, b: IId) -> IId

Unsigned / signed division (WGSL semantics, see BinOp::Div).

pub fn rem(&mut self, a: IId, b: IId) -> IId

Remainder (WGSL semantics, see BinOp::Rem).

pub fn for_range( &mut self, n: IId, init: &[IId], body: impl FnOnce(&mut Self, IId, &[IId]) -> Vec<IId>, ) -> Vec<IId>

for i in 0..n (n: u32) over states; body(g, i, s) returns next states.

Trait Implementations

impl Clone for IntGraph

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for IntGraph

fn default() -> Self

Returns the “default value” for a type.