From ee7433c47d1b6de00d6a59a5940fab5721287a32 Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 10:14:57 -0400 Subject: [PATCH 01/25] EIR: one value layout, and ownership modes that survive into the IR MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Groundwork for treating placement as an effect. Two things the compiler already knew but threw away are now carried through to the backends, and the encoding every backend depends on is written down once. `eir/layout.rs` holds the NaN-boxing constants that `value64.rs`, `wasm.rs`, and `native.rs` each used to redeclare under a comment asking the next person to keep them in sync. It also defines `DType` and `BufferHeader` for the dense buffers kernels will exchange. A new `abi_conformance` test compiles the same literals on all three backends and compares raw bits. That test immediately found three real divergences: - `loon run --native` silently returned `()` for any program with a `main` function. The entry point reaches `main` through Close + Invoke, both unimplemented, and both emitted a unit placeholder instead of failing. Operations that *use* an unrepresentable value now error, as `End::TailInvoke` already did; ones that merely construct one stay inert, since lowering emits a dead Close for every named function. - The WASM backend heap-allocated the nullary `None` instead of using the immediate singleton. `value64.rs` documents that bit equality is `None` equality and truthiness is a pure bit test, so a heap `None` would have tested truthy there and falsy on the VM. - The native backend encoded `None` as `()`, making the two indistinguishable. Ownership modes (Borrow/MutBorrow/Move) were inferred and then dropped with the checker. They now ride on `Checker::fn_param_modes` and land on `Func::param_modes` as In/InOut/Owned — the same directional information Rust makes you write as `&T`/`&mut T`, inferred instead of annotated. Mode inference also iterates to a fixed point: a single source-order pass guessed `Move` for callees it had not reached yet, so the answer depended on the order two functions happened to be written in. Co-Authored-By: Claude Fable 5 --- crates/loon-cli/tests/abi_conformance.rs | 224 +++++++++++++++ crates/loon-lang/src/check/mod.rs | 10 + crates/loon-lang/src/check/ownership.rs | 138 ++++++++- crates/loon-lang/src/eir/layout.rs | 348 +++++++++++++++++++++++ crates/loon-lang/src/eir/lower.rs | 24 ++ crates/loon-lang/src/eir/mod.rs | 34 +++ crates/loon-lang/src/eir/native.rs | 171 +++++++++-- crates/loon-lang/src/eir/tailcall.rs | 1 + crates/loon-lang/src/eir/value64.rs | 24 +- crates/loon-lang/src/eir/vm.rs | 8 + crates/loon-lang/src/eir/wasm.rs | 66 +++-- crates/loon-lang/tests/param_modes.rs | 165 +++++++++++ 12 files changed, 1145 insertions(+), 68 deletions(-) create mode 100644 crates/loon-cli/tests/abi_conformance.rs create mode 100644 crates/loon-lang/src/eir/layout.rs create mode 100644 crates/loon-lang/tests/param_modes.rs diff --git a/crates/loon-cli/tests/abi_conformance.rs b/crates/loon-cli/tests/abi_conformance.rs new file mode 100644 index 0000000..50737b1 --- /dev/null +++ b/crates/loon-cli/tests/abi_conformance.rs @@ -0,0 +1,224 @@ +//! Every backend must encode a value the same way, bit for bit. +//! +//! Loon has three code generators — the register VM, the Cranelift JIT, and +//! the WASM emitter — and until recently each carried its own copy of the +//! NaN-boxing constants under a comment asking the next person to keep them in +//! sync. That is the same setup that produced a real bug in a recent Rust +//! GPU-offload compiler, where a slice lowered as `(ptr, len)` on two targets +//! and `[i64; 2]` on a third; the authors found it by hand and wrote that +//! automated cross-target validation was still missing. +//! +//! This is that validation. `eir::layout` now holds the encoding once, and the +//! tests below compile the same source on every available backend and compare +//! the raw 64-bit results. A divergence fails here rather than surfacing later +//! as a wrong answer on one target. + +use loon_lang::eir::layout::{ + nanbox, BufferHeader, DType, BUF_HDR_SIZE, BUF_OFF_DATA, BUF_OFF_DTYPE, BUF_OFF_LEN, + GOLDEN_IMMEDIATES, +}; + +/// A program whose value is the literal. +/// +/// Deliberately a bare top-level expression rather than a `main` function: +/// reaching `main` requires closures, which the native backend does not +/// implement, and a program every backend refuses would make the comparison +/// below vacuous. +fn program_for(literal: &str) -> String { + literal.to_string() +} + +/// Evaluate on the register VM, returning the raw encoded word. +fn vm_bits(literal: &str) -> u64 { + let src = program_for(literal); + let result = loon_lang::eir::vm::eval_eir(&src) + .unwrap_or_else(|e| panic!("VM failed on `{literal}`: {e:?}")); + result.value.bits() +} + +/// Evaluate through the Cranelift JIT, returning the raw encoded word. +/// +/// The native backend does not implement every operation; a literal it cannot +/// compile yields `None` and is skipped rather than reported as a mismatch. +fn native_bits(literal: &str) -> Option { + let src = program_for(literal); + match loon_lang::eir::native::eval_native(&src) { + Ok(v) => Some(v.bits()), + Err(_) => None, + } +} + +/// Compile with the EIR WASM backend and run under wasmtime, returning the +/// raw encoded word. Returns `None` if the backend cannot compile the program. +fn wasm_bits(literal: &str) -> Option { + use loon_lang::eir::backend::Backend; + + let src = program_for(literal); + let exprs = loon_lang::parser::parse(&src).expect("parses"); + let mut checker = loon_lang::check::Checker::new(); + let errors = checker.check_program(&exprs); + assert!(errors.is_empty(), "type errors on `{literal}`: {errors:?}"); + let module = loon_lang::eir::lower::lower(&checker); + + let mut backend = loon_lang::eir::wasm::WasmBackend; + let bytes = backend.compile(&module).ok()?; + + let engine = wasmtime::Engine::default(); + let wasm_module = wasmtime::Module::new(&engine, &bytes).ok()?; + let mut store = wasmtime::Store::new(&engine, ()); + let mut linker = wasmtime::Linker::new(&engine); + // The emitter imports its two IO hooks unconditionally; a literal program + // never calls them, but they must resolve for instantiation to succeed. + linker + .func_wrap("host", "println", |_: i64| {}) + .expect("bind println"); + linker + .func_wrap("host", "print", |_: i64| {}) + .expect("bind print"); + let instance = linker.instantiate(&mut store, &wasm_module).ok()?; + let start = instance + .get_typed_func::<(), i64>(&mut store, "_start") + .ok()?; + start.call(&mut store, ()).ok().map(|v| v as u64) +} + +#[test] +fn the_vm_encodes_immediates_exactly_as_the_layout_says() { + for (name, literal, expected) in GOLDEN_IMMEDIATES { + assert_eq!( + vm_bits(literal), + *expected, + "`{name}` ({literal}): the VM disagrees with eir::layout" + ); + } +} + +#[test] +fn every_backend_agrees_on_every_immediate() { + let mut checked_native = 0usize; + let mut checked_wasm = 0usize; + + for (name, literal, expected) in GOLDEN_IMMEDIATES { + let vm = vm_bits(literal); + assert_eq!(vm, *expected, "`{name}`: VM vs layout"); + + if let Some(bits) = native_bits(literal) { + checked_native += 1; + assert_eq!( + bits, vm, + "`{name}` ({literal}): native backend encodes {bits:#018x}, VM encodes {vm:#018x}" + ); + } + if let Some(bits) = wasm_bits(literal) { + checked_wasm += 1; + assert_eq!( + bits, vm, + "`{name}` ({literal}): wasm backend encodes {bits:#018x}, VM encodes {vm:#018x}" + ); + } + } + + // A backend silently compiling nothing would make this test vacuous. + assert!( + checked_native > 0, + "the native backend compiled none of the golden immediates" + ); + assert!( + checked_wasm > 0, + "the wasm backend compiled none of the golden immediates" + ); +} + +#[test] +fn immediates_are_distinguishable_from_one_another() { + // Encoding two different values identically is the failure mode that would + // make the cross-backend comparison above pass while everything is broken. + let mut seen: Vec<(&str, u64)> = Vec::new(); + for (name, literal, _) in GOLDEN_IMMEDIATES { + let bits = vm_bits(literal); + if let Some((other, _)) = seen.iter().find(|(_, b)| *b == bits) { + panic!("`{name}` and `{other}` encode to the same word {bits:#018x}"); + } + seen.push((name, bits)); + } +} + +#[test] +fn the_buffer_header_layout_is_pinned() { + // Field order and offsets are exactly what diverged across targets in the + // Rust offload work. Pin them explicitly: a reordering of the struct is a + // silent ABI break, and this is the test that refuses to let it be silent. + assert_eq!(std::mem::size_of::(), BUF_HDR_SIZE); + assert_eq!(BUF_OFF_DTYPE, 0); + assert_eq!(BUF_OFF_LEN, 8); + assert_eq!(BUF_OFF_DATA, 16); + + let header = BufferHeader::new(DType::F32, 4096, 0x1234_5678_9ABC_DEF0); + let bytes = header.to_bytes(); + assert_eq!(bytes.len(), BUF_HDR_SIZE); + assert_eq!( + u32::from_le_bytes(bytes[BUF_OFF_DTYPE..BUF_OFF_DTYPE + 4].try_into().unwrap()), + DType::F32 as u32 + ); + assert_eq!( + u64::from_le_bytes(bytes[BUF_OFF_LEN..BUF_OFF_LEN + 8].try_into().unwrap()), + 4096 + ); + assert_eq!( + u64::from_le_bytes(bytes[BUF_OFF_DATA..BUF_OFF_DATA + 8].try_into().unwrap()), + 0x1234_5678_9ABC_DEF0 + ); + assert_eq!(BufferHeader::from_bytes(&bytes), Some(header)); +} + +#[test] +fn a_reordered_header_does_not_round_trip() { + // The mutation test: swap the two 64-bit fields, as a target with a + // different struct layout effectively would, and confirm the bytes no + // longer decode to the original. If this ever passes, the conformance + // check above has stopped checking anything. + let header = BufferHeader::new(DType::I32, 7, 99); + let mut mutated = header.to_bytes(); + let (len_half, data_half): ([u8; 8], [u8; 8]) = ( + mutated[BUF_OFF_LEN..BUF_OFF_LEN + 8].try_into().unwrap(), + mutated[BUF_OFF_DATA..BUF_OFF_DATA + 8].try_into().unwrap(), + ); + mutated[BUF_OFF_LEN..BUF_OFF_LEN + 8].copy_from_slice(&data_half); + mutated[BUF_OFF_DATA..BUF_OFF_DATA + 8].copy_from_slice(&len_half); + + let decoded = BufferHeader::from_bytes(&mutated).expect("still a well-formed header"); + assert_ne!( + decoded, header, + "swapping len and data went unnoticed — the layout check is vacuous" + ); + assert_eq!(decoded.len, 99); + assert_eq!(decoded.data, 7); +} + +#[test] +fn gpu_placement_rejects_64_bit_element_types() { + // WGSL core has no f64 and no 64-bit integers. Placement must refuse those + // buffers outright rather than quietly narrowing a program's precision. + assert!(DType::F32.gpu_ok() && DType::I32.gpu_ok()); + assert!(!DType::F64.gpu_ok() && !DType::I64.gpu_ok()); + for dtype in [DType::F32, DType::F64, DType::I32, DType::I64] { + assert_eq!(DType::from_name(dtype.name()), Some(dtype)); + } +} + +#[test] +fn int_payloads_survive_the_full_48_bit_range() { + // The int tag carries a 48-bit signed payload. The extremes are where a + // backend that sign-extends differently would part ways from the others. + for n in [0i64, 1, -1, (1i64 << 47) - 1, -(1i64 << 47)] { + let literal = n.to_string(); + let expected = nanbox::encode_int(n); + assert_eq!(vm_bits(&literal), expected, "VM on {n}"); + if let Some(bits) = native_bits(&literal) { + assert_eq!(bits, expected, "native on {n}"); + } + if let Some(bits) = wasm_bits(&literal) { + assert_eq!(bits, expected, "wasm on {n}"); + } + } +} diff --git a/crates/loon-lang/src/check/mod.rs b/crates/loon-lang/src/check/mod.rs index aa1181b..fec5aaf 100644 --- a/crates/loon-lang/src/check/mod.rs +++ b/crates/loon-lang/src/check/mod.rs @@ -120,6 +120,11 @@ pub struct Checker { recur_params: Vec>, /// Expanded program after macro expansion (available after check_program) pub expanded_program: Vec, + /// Per-parameter ownership modes for each named function, inferred during + /// `check_program`. Rust makes you write these down as `&T` / `&mut T`; + /// Loon infers them, and lowering carries them into the IR so backends can + /// tell a read-only argument from one that is written through. + pub fn_param_modes: HashMap>, } /// Split a param list at a `&` marker: returns the fixed params and the @@ -145,6 +150,7 @@ impl Checker { subst: Subst::new(), env: TypeEnv::new(), errors: Vec::new(), + fn_param_modes: HashMap::new(), constructors: HashMap::new(), type_constructors: HashMap::new(), type_of: HashMap::new(), @@ -5746,6 +5752,10 @@ impl Checker { self.expanded_program = final_exprs; self.check_trait_constraints(); + // Ownership modes ride along with the checker so lowering can see them. + // This is a syntactic pass over the expanded program; its diagnostics + // are the dedicated ownership pass's job, not ours. + self.fn_param_modes = ownership::infer_param_modes(&self.expanded_program); std::mem::take(&mut self.errors) } diff --git a/crates/loon-lang/src/check/ownership.rs b/crates/loon-lang/src/check/ownership.rs index e654e3a..6da70f2 100644 --- a/crates/loon-lang/src/check/ownership.rs +++ b/crates/loon-lang/src/check/ownership.rs @@ -31,8 +31,14 @@ enum BindingState { } /// How a function uses a particular parameter. -#[derive(Debug, Clone, Copy, PartialEq)] -enum ParamMode { +/// +/// This is Loon's answer to what other languages make you write down. Rust +/// spells it `&T` / `&mut T` / `T` at every signature; here it is inferred +/// from the body and then used the same way — to decide what a call site may +/// do with a binding, and (for kernels) which direction data has to move +/// across a placement boundary. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum ParamMode { /// Parameter is only read — immutable borrow at call site. Borrow, /// Parameter is mutated (push!, set!) — mutable borrow at call site. @@ -120,6 +126,11 @@ impl<'a> OwnershipChecker<'a> { // lets the escaping/answer-passing style (e.g. `[[resume s] s]`) // reuse a value across the resume without a false move error. "resume", + // Kernel element read. `[at buf i]` observes one element and never + // consumes the buffer, so a kernel parameter that is only read + // stays a borrow — which is what makes it an `:in` (host-to-device + // only) argument at a placement boundary. + "at", ] { borrow_fns.insert(name.to_string()); } @@ -409,8 +420,11 @@ impl<'a> OwnershipChecker<'a> { ); } } - "push!" | "set!" => { - // First arg is mutably borrowed + "push!" | "set!" | "put" => { + // First arg is mutably borrowed. `put` is the + // kernel element write; treating it exactly like + // `set!` is what makes a written-to kernel buffer + // infer as `:inout` with no annotation. if items.len() > 1 { if let ExprKind::Symbol(name) = &items[1].kind { if let Some(idx) = param_names.iter().position(|p| p == name) { @@ -733,6 +747,122 @@ impl<'a> OwnershipChecker<'a> { } std::mem::take(&mut self.errors) } + + /// Per-parameter modes for every named function seen so far. + pub fn param_modes(&self) -> &HashMap> { + &self.fn_param_modes + } + + /// Re-run mode analysis over every named function until the answers stop + /// changing. + /// + /// The first pass sees definitions in source order, so a call to a + /// not-yet-analyzed function falls back to the conservative `Move`. Once + /// every function has an entry, re-analyzing resolves those calls for + /// real. Repeating until stable makes the result independent of the order + /// the definitions were written in, which matters because a spuriously + /// `Move` parameter reads as "the callee consumed this" — a claim that + /// costs optimizations downstream and is simply untrue. + /// + /// Bounded to a small number of rounds: each round can only replace a + /// guess with a real answer, so a program that has not settled by then has + /// a cycle whose conservative reading is the correct one to keep. + pub fn refine_param_modes(&mut self, exprs: &[Expr]) { + const MAX_ROUNDS: usize = 8; + let defns = Self::collect_fn_defns(exprs); + for _ in 0..MAX_ROUNDS { + let mut changed = false; + for (name, param_names, body) in &defns { + let modes = self.analyze_param_modes(param_names, body); + match self.fn_param_modes.get(name) { + Some(prev) if *prev == modes => {} + _ => { + self.fn_param_modes.insert(name.clone(), modes); + changed = true; + } + } + } + if !changed { + return; + } + } + } + + /// Every `[fn name [params] body...]` in the program, including those + /// nested inside module-level forms, as (name, param names, body). + fn collect_fn_defns(exprs: &[Expr]) -> Vec<(String, Vec, Vec)> { + let mut out = Vec::new(); + for expr in exprs { + Self::collect_fn_defns_into(expr, &mut out); + } + out + } + + fn collect_fn_defns_into(expr: &Expr, out: &mut Vec<(String, Vec, Vec)>) { + let ExprKind::List(items) = &expr.kind else { + return; + }; + let Some(head) = items.first() else { + return; + }; + if let ExprKind::Symbol(h) = &head.kind { + if h == "fn" && items.len() >= 3 { + if let (ExprKind::Symbol(name), ExprKind::List(params)) = + (&items[1].kind, &items[2].kind) + { + let param_names: Vec = params + .iter() + .filter_map(|p| match &p.kind { + ExprKind::Symbol(n) => Some(n.clone()), + _ => None, + }) + .collect(); + // Skip an effect-row annotation between params and body, + // exactly as `check_defn` does. + let mut body_start = 3; + if body_start < items.len() + && matches!( + &items[body_start].kind, + ExprKind::Set(_) | ExprKind::Map(_) + ) + { + body_start += 1; + } + out.push(( + name.clone(), + param_names, + items[body_start..].to_vec(), + )); + return; + } + } + } + // Not a function definition — look inside for nested ones. + for item in items { + Self::collect_fn_defns_into(item, out); + } + } +} + +/// Infer parameter modes for a program without reporting ownership errors. +/// +/// The full ownership check runs as a separate frontend pass and its results +/// are thrown away with the checker. The *modes* it computes along the way are +/// useful to the compiler proper — they say, for each parameter, whether a +/// caller's value is read, mutated, or consumed — so this entry point runs the +/// same analysis for its modes alone. Diagnostics are discarded here; the +/// dedicated pass is still what reports them. +/// +/// Unlike the diagnostic pass, this one iterates to a fixed point. A single +/// pass in source order has to guess at callees it has not reached yet, and it +/// guesses `Move`; that makes the answer depend on the order two functions +/// happen to be written in, which is not a property anything downstream should +/// inherit. Re-running until nothing changes removes the guess. +pub fn infer_param_modes(exprs: &[Expr]) -> HashMap> { + let mut checker = OwnershipChecker::new(); + let _ = checker.check_program(exprs); + checker.refine_param_modes(exprs); + checker.fn_param_modes } impl Default for OwnershipChecker<'_> { diff --git a/crates/loon-lang/src/eir/layout.rs b/crates/loon-lang/src/eir/layout.rs new file mode 100644 index 0000000..76d8118 --- /dev/null +++ b/crates/loon-lang/src/eir/layout.rs @@ -0,0 +1,348 @@ +//! The one description of how a Loon value looks in memory. +//! +//! Every backend — the register VM, the WASM emitter, the Cranelift JIT, and +//! (later) the WGSL kernel emitter — agrees on the bits described here. Before +//! this module the NaN-boxing constants were copy-pasted into three files with +//! a "must match value64.rs" comment on top; a divergence between two backends +//! was a runtime parity failure at best and a silent wrong answer at worst. +//! That is exactly the bug class the Rust GPU-offload work hit when a slice +//! lowered as `(ptr, len)` on one target and `[i64; 2]` on another, and found +//! it by hand. Here it is one `const`, and `tests/abi_conformance.rs` proves +//! every backend still round-trips the same bytes. +//! +//! Two things live here: +//! - [`nanbox`]: the 64-bit immediate encoding shared by all backends. +//! - [`DType`] / [`BufferHeader`]: the dense-buffer layout that kernels and +//! devices exchange, where "device" may be another thread, another +//! backend, or a GPU queue. + +/// NaN-boxing bit layout. See `value64.rs` for the prose version. +pub mod nanbox { + /// Quiet-NaN base. + pub const QNAN: u64 = 0x7FF8_0000_0000_0000; + /// Sign bit. + pub const SIGN: u64 = 0x8000_0000_0000_0000; + /// Every tagged (non-float) value carries this prefix. + pub const BASE: u64 = SIGN | QNAN; + /// Tag bits 48-50. + pub const TAG_MASK: u64 = 0x0007_0000_0000_0000; + /// Payload bits 0-47. + pub const PAYLOAD: u64 = 0x0000_FFFF_FFFF_FFFF; + + /// Heap pointer (string, closure, ADT, collection, buffer — type in header). + pub const TAG_PTR: u64 = 0x0000_0000_0000_0000; + /// Inline 48-bit signed integer. + pub const TAG_INT: u64 = 0x0001_0000_0000_0000; + /// Interned symbol/keyword (32-bit intern index). + pub const TAG_SYM: u64 = 0x0006_0000_0000_0000; + /// Immediate singleton (Unit, True, False, None). + pub const TAG_IMM: u64 = 0x0007_0000_0000_0000; + + /// Immediate sub-tags, in the low bits. + pub const IMM_UNIT: u64 = 0; + pub const IMM_TRUE: u64 = 1; + pub const IMM_FALSE: u64 = 2; + pub const IMM_NONE: u64 = 3; + + /// Fully-assembled immediates. Backends that emit literals use these + /// directly rather than re-deriving `BASE | TAG_IMM | n`. + pub const VAL_UNIT: u64 = BASE | TAG_IMM | IMM_UNIT; + pub const VAL_TRUE: u64 = BASE | TAG_IMM | IMM_TRUE; + pub const VAL_FALSE: u64 = BASE | TAG_IMM | IMM_FALSE; + pub const VAL_NONE: u64 = BASE | TAG_IMM | IMM_NONE; + + /// Encode a 48-bit signed integer the way every backend must. + #[inline(always)] + pub const fn encode_int(n: i64) -> u64 { + BASE | TAG_INT | ((n as u64) & PAYLOAD) + } + + /// Encode a float (identity — floats pass through as raw IEEE 754). + #[inline(always)] + pub fn encode_float(f: f64) -> u64 { + f.to_bits() + } +} + +// ─── Dense buffers ───────────────────────────────────────────────────────── + +/// Element type of a dense [`BufferHeader`]. +/// +/// Deliberately small. `F64`/`I64` exist because Loon's own numbers are 64-bit +/// and the CPU backends can honour them exactly; they are rejected for GPU +/// placement because WGSL core has neither (see [`DType::gpu_ok`]). A kernel +/// that wants to run on a GPU says so by using f32/i32 buffers — we never +/// silently demote precision behind the programmer's back. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +#[repr(u32)] +pub enum DType { + F32 = 0, + F64 = 1, + I32 = 2, + I64 = 3, +} + +impl DType { + /// Size of one element in bytes. + pub const fn size(self) -> usize { + match self { + DType::F32 | DType::I32 => 4, + DType::F64 | DType::I64 => 8, + } + } + + /// The WGSL scalar type name, for the kernel emitter. + pub const fn wgsl(self) -> &'static str { + match self { + DType::F32 => "f32", + DType::F64 => "f64", // not valid in WGSL core; guarded by `gpu_ok` + DType::I32 => "i32", + DType::I64 => "i64", // ditto + } + } + + /// Whether a buffer of this type can be placed on a GPU. WGSL core has no + /// 64-bit scalars, so `F64`/`I64` are a hard error at placement time + /// rather than a silent conversion. + pub const fn gpu_ok(self) -> bool { + matches!(self, DType::F32 | DType::I32) + } + + /// Short name used in traces, diagnostics, and the record/replay tape. + pub const fn name(self) -> &'static str { + match self { + DType::F32 => "f32", + DType::F64 => "f64", + DType::I32 => "i32", + DType::I64 => "i64", + } + } + + /// Parse the name written by [`DType::name`]. Used when reading a tape. + pub fn from_name(s: &str) -> Option { + match s { + "f32" => Some(DType::F32), + "f64" => Some(DType::F64), + "i32" => Some(DType::I32), + "i64" => Some(DType::I64), + _ => None, + } + } + + /// Reconstruct from the `#[repr(u32)]` discriminant stored in a header. + pub fn from_u32(n: u32) -> Option { + match n { + 0 => Some(DType::F32), + 1 => Some(DType::F64), + 2 => Some(DType::I32), + 3 => Some(DType::I64), + _ => None, + } + } +} + +/// How a dense buffer is described to any backend that is not the VM itself. +/// +/// `data` is deliberately a `u64` rather than a pointer: on the native backend +/// it is a host address, in WASM it is a linear-memory offset, and on a device +/// it is an allocation handle. The *header* is identical in all three, which is +/// what lets one conformance test cover them all. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[repr(C)] +pub struct BufferHeader { + /// [`DType`] discriminant. + pub dtype: u32, + /// Padding so `len` is 8-byte aligned in every ABI. + pub _pad: u32, + /// Element count (not bytes). + pub len: u64, + /// Pointer, offset, or device handle — target-dependent. + pub data: u64, +} + +/// Size of [`BufferHeader`] in bytes. Asserted against `size_of` in tests. +pub const BUF_HDR_SIZE: usize = 24; +/// Byte offset of `dtype` within [`BufferHeader`]. +pub const BUF_OFF_DTYPE: usize = 0; +/// Byte offset of `len`. +pub const BUF_OFF_LEN: usize = 8; +/// Byte offset of `data`. +pub const BUF_OFF_DATA: usize = 16; + +impl BufferHeader { + pub fn new(dtype: DType, len: u64, data: u64) -> Self { + BufferHeader { + dtype: dtype as u32, + _pad: 0, + len, + data, + } + } + + pub fn dtype(&self) -> Option { + DType::from_u32(self.dtype) + } + + /// Total size of the element payload in bytes. + pub fn byte_len(&self) -> Option { + Some(self.len as usize * self.dtype()?.size()) + } + + /// Serialize to the canonical 24-byte little-endian form. Backends that + /// cannot share Rust structs (WASM linear memory, a device staging + /// buffer) use this. + pub fn to_bytes(&self) -> [u8; BUF_HDR_SIZE] { + let mut out = [0u8; BUF_HDR_SIZE]; + out[BUF_OFF_DTYPE..BUF_OFF_DTYPE + 4].copy_from_slice(&self.dtype.to_le_bytes()); + out[BUF_OFF_LEN..BUF_OFF_LEN + 8].copy_from_slice(&self.len.to_le_bytes()); + out[BUF_OFF_DATA..BUF_OFF_DATA + 8].copy_from_slice(&self.data.to_le_bytes()); + out + } + + /// Inverse of [`BufferHeader::to_bytes`]. + pub fn from_bytes(b: &[u8]) -> Option { + if b.len() < BUF_HDR_SIZE { + return None; + } + let dtype = u32::from_le_bytes(b[BUF_OFF_DTYPE..BUF_OFF_DTYPE + 4].try_into().ok()?); + let len = u64::from_le_bytes(b[BUF_OFF_LEN..BUF_OFF_LEN + 8].try_into().ok()?); + let data = u64::from_le_bytes(b[BUF_OFF_DATA..BUF_OFF_DATA + 8].try_into().ok()?); + DType::from_u32(dtype)?; + Some(BufferHeader { + dtype, + _pad: 0, + len, + data, + }) + } +} + +// ─── Conformance fixtures ────────────────────────────────────────────────── + +/// Values whose encoding every backend must agree on, bit for bit. +/// +/// `tests/abi_conformance.rs` compiles each `source` on every available +/// backend and asserts the resulting 64-bit word equals `bits`. Add a case +/// here whenever a new immediate encoding appears. +pub const GOLDEN_IMMEDIATES: &[(&str, &str, u64)] = &[ + ("unit", "[]", nanbox::VAL_UNIT), + ("true", "true", nanbox::VAL_TRUE), + ("false", "false", nanbox::VAL_FALSE), + ("none", "None", nanbox::VAL_NONE), + ("int-zero", "0", nanbox::encode_int(0)), + ("int-42", "42", nanbox::encode_int(42)), + ("int-neg", "-7", nanbox::encode_int(-7)), + ("int-max48", "140737488355327", nanbox::encode_int((1i64 << 47) - 1)), + ("int-min48", "-140737488355328", nanbox::encode_int(-(1i64 << 47))), +]; + +/// A byte pattern chosen to break sloppy marshalling: negative zero, a NaN +/// with a payload, a denormal, and the integer extremes. Any backend that +/// round-trips this unchanged is not quietly normalizing floats or truncating +/// through a narrower type. +pub fn golden_buffer_f32() -> (DType, Vec) { + ( + DType::F32, + vec![ + 0.0, + -0.0, + 1.0, + -1.5, + f32::MIN_POSITIVE / 2.0, // denormal + f32::MAX, + f32::MIN, + f32::INFINITY, + f32::NEG_INFINITY, + f32::from_bits(0x7FC0_0001), // NaN with payload + 3.14159265, + -2.71828, + ], + ) +} + +/// Integer counterpart to [`golden_buffer_f32`]. +pub fn golden_buffer_i32() -> (DType, Vec) { + (DType::I32, vec![0, -1, 1, i32::MIN, i32::MAX, 42, -42]) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn header_size_matches_the_published_constant() { + assert_eq!(std::mem::size_of::(), BUF_HDR_SIZE); + assert_eq!(std::mem::align_of::(), 8); + } + + #[test] + fn header_round_trips_through_bytes() { + for dtype in [DType::F32, DType::F64, DType::I32, DType::I64] { + let h = BufferHeader::new(dtype, 1024, 0xDEAD_BEEF); + let back = BufferHeader::from_bytes(&h.to_bytes()).expect("valid header"); + assert_eq!(h, back, "{} header round-trip", dtype.name()); + assert_eq!(back.dtype(), Some(dtype)); + assert_eq!(back.byte_len(), Some(1024 * dtype.size())); + } + } + + #[test] + fn header_field_offsets_are_stable() { + // A reordering of the struct would change these, which is precisely + // the cross-target divergence this module exists to prevent. + let h = BufferHeader::new(DType::I32, 7, 9); + let b = h.to_bytes(); + assert_eq!(u32::from_le_bytes(b[0..4].try_into().unwrap()), 2); + assert_eq!(u64::from_le_bytes(b[8..16].try_into().unwrap()), 7); + assert_eq!(u64::from_le_bytes(b[16..24].try_into().unwrap()), 9); + } + + #[test] + fn rejects_an_unknown_dtype_discriminant() { + let mut b = BufferHeader::new(DType::F32, 1, 0).to_bytes(); + b[0] = 99; + assert!(BufferHeader::from_bytes(&b).is_none()); + } + + #[test] + fn dtype_names_round_trip() { + for dtype in [DType::F32, DType::F64, DType::I32, DType::I64] { + assert_eq!(DType::from_name(dtype.name()), Some(dtype)); + assert_eq!(DType::from_u32(dtype as u32), Some(dtype)); + } + } + + #[test] + fn only_32_bit_types_are_gpu_placeable() { + assert!(DType::F32.gpu_ok()); + assert!(DType::I32.gpu_ok()); + assert!(!DType::F64.gpu_ok()); + assert!(!DType::I64.gpu_ok()); + } + + #[test] + fn immediates_are_distinct_and_tagged() { + use nanbox::*; + let all = [VAL_UNIT, VAL_TRUE, VAL_FALSE, VAL_NONE]; + for (i, a) in all.iter().enumerate() { + assert_eq!(a & BASE, BASE, "immediate {i} carries the tagged prefix"); + assert_eq!(a & TAG_MASK, TAG_IMM, "immediate {i} carries TAG_IMM"); + for b in all.iter().skip(i + 1) { + assert_ne!(a, b, "immediates must be distinct"); + } + } + } + + #[test] + fn int_encoding_covers_the_48_bit_range() { + use nanbox::*; + for n in [0i64, 1, -1, 42, -42, (1i64 << 47) - 1, -(1i64 << 47)] { + let bits = encode_int(n); + assert_eq!(bits & TAG_MASK, TAG_INT, "{n} is tagged as an int"); + // Sign-extend the 48-bit payload back to i64. + let payload = bits & PAYLOAD; + let back = ((payload << 16) as i64) >> 16; + assert_eq!(back, n, "{n} round-trips through the payload"); + } + } +} diff --git a/crates/loon-lang/src/eir/lower.rs b/crates/loon-lang/src/eir/lower.rs index 19f8ba4..61d5423 100644 --- a/crates/loon-lang/src/eir/lower.rs +++ b/crates/loon-lang/src/eir/lower.rs @@ -11,6 +11,7 @@ //! - Tail calls → End::Tail / End::Recur use crate::ast::{Expr, ExprKind}; +use crate::check::ownership::ParamMode; use crate::check::Checker; use crate::eir::*; use crate::syntax::Span; @@ -486,12 +487,33 @@ impl<'a> Lower<'a> { // ── Function creation ────────────────────────────────────────────── + /// Ownership modes for a named function's parameters, as inferred by the + /// ownership pass and carried on the checker. + /// + /// Falls back to [`Mode::Owned`] when the analysis has nothing to say: the + /// conservative answer is "assume the callee consumes it", which is always + /// sound and merely gives up an optimization. + fn param_modes_for(&self, name: &str, arity: usize) -> Vec { + match self.checker.fn_param_modes.get(name) { + Some(modes) if modes.len() == arity => modes + .iter() + .map(|m| match m { + ParamMode::Borrow => Mode::In, + ParamMode::MutBorrow => Mode::InOut, + ParamMode::Move => Mode::Owned, + }) + .collect(), + _ => vec![Mode::Owned; arity], + } + } + fn begin_func(&mut self, name: Option<&str>, span: Span) -> FuncId { let id = FuncId(self.module.funcs.len() as u32); self.module.funcs.push(Func { id, name: name.map(|s| s.to_string()), params: Vec::new(), + param_modes: Vec::new(), ret: Ty::Any, evidence: Vec::new(), captures: Vec::new(), @@ -904,6 +926,8 @@ impl<'a> Lower<'a> { self.bind(pname, r); } self.module.funcs[func_id.0 as usize].params = vec![Ty::Any; param_names.len()]; + let modes = self.param_modes_for(&name, param_names.len()); + self.module.funcs[func_id.0 as usize].param_modes = modes; // Set block0 params for fn/recur support let param_regs: Vec = (0..param_names.len()).map(|i| Reg(i as u32)).collect(); diff --git a/crates/loon-lang/src/eir/mod.rs b/crates/loon-lang/src/eir/mod.rs index 62955c6..12fb93d 100644 --- a/crates/loon-lang/src/eir/mod.rs +++ b/crates/loon-lang/src/eir/mod.rs @@ -4,6 +4,7 @@ //! Every backend (Register VM, WASM, Cranelift) lowers from this IR. pub mod backend; +pub mod layout; pub mod lower; #[cfg(feature = "native")] pub mod native; @@ -61,6 +62,14 @@ pub struct Func { pub id: FuncId, pub name: Option, pub params: Vec, + /// How each parameter is used: read, written through, or consumed. + /// + /// Inferred by the ownership pass rather than written by the programmer. + /// Empty for functions the analysis did not name (closures, handler + /// clauses); otherwise one entry per parameter. Backends use it the way a + /// C API would use `const`: an [`Mode::In`] argument never has to be + /// copied back from wherever it was sent. + pub param_modes: Vec, pub ret: Ty, /// Implicit handler function-pointer parameters (evidence-passing). pub evidence: Vec, @@ -72,6 +81,31 @@ pub struct Func { pub is_closure: bool, } +/// Direction of a parameter across a call — or across a placement boundary. +/// +/// This is the whole of what `&T` / `&mut T` / `T` tell a Rust offload +/// compiler about which way bytes move, except nobody had to write it down. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Mode { + /// Read only. Travels toward the callee and never comes back. + In, + /// Written through. Must be visible to the caller afterwards. + InOut, + /// Consumed. The caller may not use it again. + Owned, +} + +impl Mode { + /// The keyword a Loon-level handler sees for this mode. + pub fn keyword(self) -> &'static str { + match self { + Mode::In => "in", + Mode::InOut => "inout", + Mode::Owned => "owned", + } + } +} + /// Evidence parameter — a handler function pointer threaded through calls. #[derive(Debug, Clone)] pub struct Evidence { diff --git a/crates/loon-lang/src/eir/native.rs b/crates/loon-lang/src/eir/native.rs index 263a73b..8bd246c 100644 --- a/crates/loon-lang/src/eir/native.rs +++ b/crates/loon-lang/src/eir/native.rs @@ -13,13 +13,19 @@ //! - Function calls (direct), including tail calls (`return_call`) //! - Builtin println (via extern) //! -//! Not yet implemented (fall back to VM): +//! Not yet implemented (fall back to VM). Using one of these is a compile +//! error, never a silently wrong value — see `compile_op`: //! - Closures / upvalues / indirect calls //! - Collection construction (Vec, Map, Set, Tuple, ADT) //! - Field access, tag extraction //! - Effect operations (perform, push/pop handler) //! - String operations //! +//! Because a program with a `main` function reaches it through a closure, that +//! whole shape is currently rejected here rather than executed. `loon run +//! --native` therefore serves bare top-level expressions today and says so +//! plainly otherwise. +//! //! Loon functions are compiled with Cranelift's `tail` calling convention so //! that `End::Tail` can lower to a real `return_call` (constant stack for //! mutual tail recursion). That convention is not the platform C ABI, so the @@ -42,19 +48,14 @@ use super::{BinOp, End, Lit, Op, Reg, UnOp}; use std::collections::HashMap; -// ─── NaN-boxing constants (must match value64.rs) ─────────────────────────── - -const QNAN: u64 = 0x7FF8_0000_0000_0000; -const SIGN: u64 = 0x8000_0000_0000_0000; -const BASE: u64 = SIGN | QNAN; -const TAG_INT: u64 = 0x0001_0000_0000_0000; -const TAG_IMM: u64 = 0x0007_0000_0000_0000; -const PAYLOAD: u64 = 0x0000_FFFF_FFFF_FFFF; +// ─── NaN-boxing constants ─────────────────────────────────────────────────── +// +// Imported from `eir::layout`, the one place the encoding is defined. -const VAL_UNIT: u64 = BASE | TAG_IMM; -const VAL_TRUE: u64 = BASE | TAG_IMM | 1; -const VAL_FALSE: u64 = BASE | TAG_IMM | 2; -const VAL_NONE: u64 = BASE | TAG_IMM | 3; +#[allow(unused_imports)] +use super::layout::nanbox::{ + BASE, PAYLOAD, QNAN, SIGN, TAG_IMM, TAG_INT, VAL_FALSE, VAL_NONE, VAL_TRUE, VAL_UNIT, +}; /// Symbol name of the C-ABI shim that calls the module's entry function. const ENTRY_TRAMPOLINE: &str = "loon_entry_trampoline"; @@ -526,6 +527,27 @@ fn compile_function( // ─── Op compilation ───────────────────────────────────────────────────────── +/// A human-readable name for an operation, used in "not supported yet" +/// diagnostics so the message names the feature rather than an opcode. +fn op_description(op: &Op) -> &'static str { + match op { + Op::Upval(..) => "reading a closure upvalue", + Op::Invoke(..) => "calling a closure", + Op::Close(..) => "creating a closure", + Op::Vec(..) => "building a vector", + Op::Map(..) => "building a map", + Op::Set(..) => "building a set", + Op::Tup(..) => "building a tuple", + Op::Adt(..) => "constructing an ADT value", + Op::Field(..) => "field access", + Op::Tag(..) => "reading a constructor tag", + Op::Perform(..) => "performing an effect", + Op::PushHandler(..) => "installing an effect handler", + _ => "this operation", + } +} + + #[allow(clippy::too_many_arguments)] fn compile_op( builder: &mut FunctionBuilder, @@ -614,24 +636,66 @@ fn compile_op( builder.def_var(vars[dst.0 as usize], result); } - // Operations that need heap/runtime support — emit unit placeholder. - Op::Upval(dst, _, _) - | Op::Invoke(dst, _, _, _) - | Op::Close(dst, _, _, _) + // Operations that *use* a value this backend cannot represent. They + // fail loudly, exactly as `End::TailInvoke` below does and for the + // same reason. + // + // These used to emit a unit placeholder, which made every program with + // a `main` function silently evaluate to `()`: the synthetic entry + // point reaches `main` through `Close` + `Invoke`, so `loon run + // --native` printed nothing and exited 0 while the VM ran the program + // correctly. A missing feature that announces itself is a far smaller + // problem than a wrong answer that does not. + Op::Upval(_, _, _) + | Op::Invoke(_, _, _, _) + | Op::Field(_, _, _, _) + | Op::Tag(_, _, _) + | Op::Perform(_, _, _, _, _, _) + | Op::PushHandler(_, _, _, _) => { + return Err(Error { + message: format!( + "{} is not supported by the native backend yet", + op_description(op) + ), + phase: "native:compile", + }); + } + + // Operations that merely *construct* a value the backend cannot + // represent. Lowering emits these freely — every named function gets a + // `Close` for its value form, whether or not anything calls it + // indirectly — so rejecting them outright would refuse programs that + // compile and run correctly today. The placeholder is inert: the only + // ways to observe one are the operations above, which do fail. + Op::Close(dst, _, _, _) | Op::Vec(dst, _, _) | Op::Map(dst, _, _) | Op::Set(dst, _, _) - | Op::Tup(dst, _, _) - | Op::Adt(dst, _, _, _) - | Op::Field(dst, _, _, _) - | Op::Tag(dst, _, _) - | Op::Perform(dst, _, _, _, _, _) - | Op::PushHandler(dst, _, _, _) => { - // TODO: implement via runtime helper calls. + | Op::Tup(dst, _, _) => { let unit = builder.ins().iconst(I64, VAL_UNIT as i64); builder.def_var(vars[dst.0 as usize], unit); } + Op::Adt(dst, tag, fields, _) => { + // The nullary `None` is an immediate singleton on every backend, + // never a heap value: bit equality is `None` equality and the + // falsy test is a bit test. Emitting the placeholder here instead + // would make `None` indistinguishable from `()`. + let none_tag = _eir_module + .ctors + .iter() + .rev() + .find(|c| c.name == "None") + .map(|c| c.tag); + let val = if fields.is_empty() && none_tag == Some(*tag) { + VAL_NONE + } else { + VAL_UNIT + }; + let v = builder.ins().iconst(I64, val as i64); + builder.def_var(vars[dst.0 as usize], v); + } + Op::PopHandler(_) => { // No-op in native backend (no destination register). } @@ -1181,6 +1245,7 @@ mod tests { id: FuncId(id), name: Some(format!("parity{id}")), params: vec![Ty::Int], + param_modes: Vec::new(), ret: Ty::Bool, evidence: vec![], captures: vec![], @@ -1222,6 +1287,7 @@ mod tests { id: FuncId(2), name: Some("__main".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Bool, evidence: vec![], captures: vec![], @@ -1260,6 +1326,7 @@ mod tests { id: FuncId(0), name: Some("__main".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Any, evidence: vec![], captures: vec![], @@ -1297,6 +1364,62 @@ mod tests { assert_eq!(result.as_int(), 1); } + /// A program with a `main` function must never appear to succeed while + /// doing nothing. + /// + /// The synthetic entry point reaches `main` through `Close` + `Invoke`, + /// and `Invoke` is not implemented here. That used to yield Unit, so + /// `loon run --native` on any real program printed nothing and exited 0 + /// while the VM ran it correctly — a silent wrong answer produced by a + /// shipped flag. It must be an error until closures are implemented, and + /// a correct result afterwards; what it must never be again is Unit. + #[test] + fn a_main_function_is_never_silently_unit() { + let src = "[fn main [] 42]"; + match eval_native(src) { + Err(msg) => assert!( + msg.contains("closure"), + "the error should name the missing feature, got: {msg}" + ), + Ok(v) => assert_eq!( + v.as_int(), + 42, + "if closures are implemented, `main` must actually run" + ), + } + } + + /// The VM and the native backend must never disagree about a value they + /// both claim to have computed. Either the native backend produces the + /// same bits, or it refuses the program. + #[test] + fn native_never_disagrees_with_the_vm() { + for src in [ + "42", + "[+ 1 2]", + "[* [+ 2 3] [- 10 4]]", + "true", + "false", + "[if true 1 2]", + "[do [let x 10] [+ x 5]]", + "[fn double [x] [* x 2]] [double 21]", + "[fn main [] 42]", + "[fn main [] [+ 1 2]]", + ] { + let Ok(native) = eval_native(src) else { + continue; // refused outright — the acceptable answer + }; + let vm = crate::eir::vm::eval_eir(src).expect("VM runs it"); + assert_eq!( + native.bits(), + vm.value.bits(), + "`{src}`: native {:#018x} vs VM {:#018x}", + native.bits(), + vm.value.bits() + ); + } + } + #[test] fn compile_unit() { let result = eval_native("()").unwrap(); diff --git a/crates/loon-lang/src/eir/tailcall.rs b/crates/loon-lang/src/eir/tailcall.rs index ecbf198..3856ac1 100644 --- a/crates/loon-lang/src/eir/tailcall.rs +++ b/crates/loon-lang/src/eir/tailcall.rs @@ -243,6 +243,7 @@ mod tests { id: FuncId(0), name: Some("f".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Any, evidence: vec![], captures: vec![], diff --git a/crates/loon-lang/src/eir/value64.rs b/crates/loon-lang/src/eir/value64.rs index 79308dd..1f908ce 100644 --- a/crates/loon-lang/src/eir/value64.rs +++ b/crates/loon-lang/src/eir/value64.rs @@ -25,24 +25,12 @@ use std::fmt; #[repr(transparent)] pub struct Val(u64); -// Bit layout constants -const QNAN: u64 = 0x7FF8_0000_0000_0000; // quiet NaN base -const SIGN: u64 = 0x8000_0000_0000_0000; // sign bit -const BASE: u64 = SIGN | QNAN; // all tagged values have this prefix -const TAG_MASK: u64 = 0x0007_0000_0000_0000; // bits 48-50 -const PAYLOAD: u64 = 0x0000_FFFF_FFFF_FFFF; // low 48 bits - -// Tag values (shifted into position) -const TAG_PTR: u64 = 0x0000_0000_0000_0000; // heap pointer -const TAG_INT: u64 = 0x0001_0000_0000_0000; // inline int48 -const TAG_SYM: u64 = 0x0006_0000_0000_0000; // interned symbol/keyword -const TAG_IMM: u64 = 0x0007_0000_0000_0000; // immediate - -// Immediate sub-tags (in low bits) -const IMM_UNIT: u64 = 0; -const IMM_TRUE: u64 = 1; -const IMM_FALSE: u64 = 2; -const IMM_NONE: u64 = 3; +// The bit layout itself lives in `layout::nanbox` so that the WASM emitter and +// the Cranelift backend encode values the same way this file decodes them. +use super::layout::nanbox::{ + BASE, IMM_FALSE, IMM_NONE, IMM_TRUE, IMM_UNIT, PAYLOAD, TAG_IMM, TAG_INT, TAG_MASK, TAG_PTR, + TAG_SYM, +}; impl Val { // ── Constants ────────────────────────────────────────────────────── diff --git a/crates/loon-lang/src/eir/vm.rs b/crates/loon-lang/src/eir/vm.rs index f89d416..02ecc99 100644 --- a/crates/loon-lang/src/eir/vm.rs +++ b/crates/loon-lang/src/eir/vm.rs @@ -455,6 +455,9 @@ impl Vm { id, name: Some("resume".to_string()), params: vec![Ty::Any], + // `resume` hands its argument onward without consuming it — a + // multi-shot continuation may be resumed more than once. + param_modes: vec![Mode::In], ret: Ty::Any, evidence: Vec::new(), captures: Vec::new(), @@ -3711,6 +3714,7 @@ mod tests { id: FuncId(id), name: Some("callee".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Any, evidence: vec![], captures: vec![], @@ -3729,6 +3733,7 @@ mod tests { id: FuncId(1), name: Some("caller".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Any, evidence: vec![], captures: vec![], @@ -3758,6 +3763,7 @@ mod tests { id: FuncId(2), name: Some("__main".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Any, evidence: vec![], captures: vec![], @@ -3803,6 +3809,7 @@ mod tests { id: FuncId(0), name: Some("callee".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Any, evidence: vec![], captures: vec![], @@ -3826,6 +3833,7 @@ mod tests { id: FuncId(1), name: Some("__main".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Any, evidence: vec![], captures: vec![], diff --git a/crates/loon-lang/src/eir/wasm.rs b/crates/loon-lang/src/eir/wasm.rs index 4b4623c..928f8fc 100644 --- a/crates/loon-lang/src/eir/wasm.rs +++ b/crates/loon-lang/src/eir/wasm.rs @@ -20,28 +20,16 @@ use wasm_encoder::{ TableType, TypeSection, ValType, }; -// ─── NaN-boxing constants (must match value64.rs) ───────────────────────── - -const QNAN: u64 = 0x7FF8_0000_0000_0000; -const SIGN: u64 = 0x8000_0000_0000_0000; -const BASE: u64 = SIGN | QNAN; -#[allow(dead_code)] -const TAG_MASK: u64 = 0x0007_0000_0000_0000; -const PAYLOAD: u64 = 0x0000_FFFF_FFFF_FFFF; -const TAG_INT: u64 = 0x0001_0000_0000_0000; -const TAG_PTR: u64 = 0x0000_0000_0000_0000; -const TAG_IMM: u64 = 0x0007_0000_0000_0000; -const TAG_SYM: u64 = 0x0006_0000_0000_0000; -#[allow(dead_code)] -const IMM_UNIT: u64 = 0; -#[allow(dead_code)] -const IMM_TRUE: u64 = 1; -#[allow(dead_code)] -const IMM_FALSE: u64 = 2; - -const VAL_UNIT: u64 = BASE | TAG_IMM; -const VAL_TRUE: u64 = BASE | TAG_IMM | 1; -const VAL_FALSE: u64 = BASE | TAG_IMM | 2; +// ─── NaN-boxing constants ───────────────────────────────────────────────── +// +// Imported, not re-declared: `eir::layout` is the single source of truth, so a +// change to the encoding cannot leave this backend behind. + +#[allow(unused_imports)] +use super::layout::nanbox::{ + BASE, IMM_FALSE, IMM_TRUE, IMM_UNIT, PAYLOAD, QNAN, SIGN, TAG_IMM, TAG_INT, TAG_MASK, TAG_PTR, + TAG_SYM, VAL_FALSE, VAL_NONE, VAL_TRUE, VAL_UNIT, +}; // ─── Import indices ─────────────────────────────────────────────────────── @@ -90,6 +78,12 @@ struct CompileCtx<'a> { string_data: Vec<(u32, Vec)>, /// Next free offset in the data segment. data_offset: u32, + /// Tag of the nullary `None` constructor, if this module declares one. + /// + /// `None` is an immediate singleton rather than a heap value, so that bit + /// equality is `None` equality and the falsy test stays a pure bit test. + /// Every construction site has to honour that — see `Op::Adt`. + none_tag: Option, } struct WasmFunc { @@ -190,6 +184,12 @@ impl<'a> CompileCtx<'a> { table_entries: Vec::new(), string_data: Vec::new(), data_offset: 1024, + none_tag: module + .ctors + .iter() + .rev() + .find(|c| c.name == "None") + .map(|c| c.tag), } } @@ -496,6 +496,17 @@ impl<'a> CompileCtx<'a> { } Op::Adt(dst, tag, fields, _) => { + // The nullary `None` is the immediate singleton, never a heap + // allocation. The VM normalizes it at every construction site + // because bit equality is `None` equality and truthiness is a + // bit test; a heap-allocated `None` would compare unequal to + // itself across backends and, worse, test *truthy* here while + // testing falsy on the VM. + if fields.is_empty() && self.none_tag == Some(*tag) { + out.push(WasmInstr::I64Const(VAL_NONE as i64)); + out.push(WasmInstr::LocalSet(dst.0)); + return Ok(()); + } // Layout: [tag: u16 | field_count: u16 packed as i32][fields...] let size = 4 + fields.len() as u32 * 8; emit_heap_alloc(size, addr_local, out); @@ -1434,6 +1445,7 @@ mod tests { id: FuncId(0), name: Some("main".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Int, evidence: vec![], captures: vec![], @@ -1459,6 +1471,7 @@ mod tests { id: FuncId(0), name: Some("main".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Int, evidence: vec![], captures: vec![], @@ -1488,6 +1501,7 @@ mod tests { id: FuncId(0), name: Some("main".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Int, evidence: vec![], captures: vec![], @@ -1532,6 +1546,7 @@ mod tests { id: FuncId(0), name: Some("double".to_string()), params: vec![Ty::Int], + param_modes: Vec::new(), ret: Ty::Int, evidence: vec![], captures: vec![], @@ -1548,6 +1563,7 @@ mod tests { id: FuncId(1), name: Some("main".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Int, evidence: vec![], captures: vec![], @@ -1580,6 +1596,7 @@ mod tests { id: FuncId(0), name: Some("countdown".to_string()), params: vec![Ty::Int], + param_modes: Vec::new(), ret: Ty::Int, evidence: vec![], captures: vec![], @@ -1617,6 +1634,7 @@ mod tests { id: FuncId(1), name: Some("main".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Int, evidence: vec![], captures: vec![], @@ -1652,6 +1670,7 @@ mod tests { id: FuncId(0), name: Some("even".to_string()), params: vec![Ty::Int], + param_modes: Vec::new(), ret: Ty::Bool, evidence: vec![], captures: vec![], @@ -1688,6 +1707,7 @@ mod tests { id: FuncId(1), name: Some("odd".to_string()), params: vec![Ty::Int], + param_modes: Vec::new(), ret: Ty::Bool, evidence: vec![], captures: vec![], @@ -1807,6 +1827,7 @@ mod tests { id: FuncId(0), name: Some("main".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Unit, evidence: vec![], captures: vec![], @@ -1830,6 +1851,7 @@ mod tests { id: FuncId(0), name: Some("main".to_string()), params: vec![], + param_modes: Vec::new(), ret: Ty::Str, evidence: vec![], captures: vec![], diff --git a/crates/loon-lang/tests/param_modes.rs b/crates/loon-lang/tests/param_modes.rs new file mode 100644 index 0000000..1bb90d0 --- /dev/null +++ b/crates/loon-lang/tests/param_modes.rs @@ -0,0 +1,165 @@ +//! Parameter modes survive the trip from inference into the IR. +//! +//! Loon infers, for every function parameter, whether the callee reads it, +//! writes through it, or consumes it. Other languages make you write that down +//! — Rust spells it `&T` / `&mut T` / `T`, and a GPU offload compiler reads +//! those same sigils to decide which way bytes move across a device boundary. +//! Here the analysis already ran; these tests pin that its answers are correct +//! and that lowering carries them onto `Func::param_modes` instead of throwing +//! them away. + +use loon_lang::check::ownership::{infer_param_modes, ParamMode}; +use loon_lang::check::Checker; +use loon_lang::eir::lower::lower; +use loon_lang::eir::Mode; +use loon_lang::parser::parse; + +/// Infer modes for one named function. +fn modes_of(src: &str, func: &str) -> Vec { + let exprs = parse(src).expect("parses"); + infer_param_modes(&exprs) + .get(func) + .unwrap_or_else(|| panic!("no modes inferred for `{func}`")) + .clone() +} + +/// Lower a program and read the modes off the named function's IR. +fn lowered_modes(src: &str, func: &str) -> Vec { + let exprs = parse(src).expect("parses"); + let mut checker = Checker::new(); + let errors = checker.check_program(&exprs); + assert!(errors.is_empty(), "type errors: {errors:?}"); + let module = lower(&checker); + let f = module + .funcs + .iter() + .find(|f| f.name.as_deref() == Some(func)) + .unwrap_or_else(|| panic!("no lowered function `{func}`")); + f.param_modes.clone() +} + +#[test] +fn a_read_only_parameter_is_a_borrow() { + // `n` is only added to, so the caller keeps it. + assert_eq!( + modes_of("[fn twice [n] [+ n n]]", "twice"), + vec![ParamMode::Borrow] + ); +} + +#[test] +fn a_mutated_parameter_is_a_mutable_borrow() { + // `push!` writes through its first argument; the rest are read. + assert_eq!( + modes_of("[fn add-to [v x] [push! v x]]", "add-to"), + vec![ParamMode::MutBorrow, ParamMode::Borrow] + ); +} + +#[test] +fn a_returned_parameter_is_moved() { + assert_eq!( + modes_of("[fn identity [x] x]", "identity"), + vec![ParamMode::Move] + ); +} + +#[test] +fn kernel_accessors_drive_the_direction() { + // This is the whole trick behind inferring transfer direction: `at` reads + // an element and `put` writes one, so a buffer that is only read comes out + // `Borrow` (host-to-device only) while one written through comes out + // `MutBorrow` (must be synchronized back). Nobody annotated anything. + assert_eq!( + modes_of("[fn saxpy [i a x out] [put out i [* a [at x i]]]]", "saxpy"), + vec![ + ParamMode::Borrow, // i — index, read + ParamMode::Borrow, // a — scalar, read + ParamMode::Borrow, // x — input buffer + ParamMode::MutBorrow, // out — output buffer + ] + ); +} + +#[test] +fn modes_reach_the_lowered_function() { + // The point of the exercise: what the frontend inferred is visible to the + // backend, rather than being dropped with the checker. + assert_eq!( + lowered_modes("[fn add-to [v x] [push! v x]] [fn main [] []]", "add-to"), + vec![Mode::InOut, Mode::In] + ); + // The shape a kernel launch cares about: one argument read, one written + // through. `nth` reads; `push!` writes. Once buffers land, `at` and `put` + // take these roles with the same rules. + assert_eq!( + lowered_modes( + "[fn blend [src dst] [push! dst [nth src 0]]] [fn main [] []]", + "blend" + ), + vec![Mode::In, Mode::InOut] + ); +} + +#[test] +fn arity_always_matches_the_parameter_list() { + // A mode vector that disagrees with the parameter count would silently + // misalign direction with argument, so lowering falls back to the + // conservative all-`Owned` answer rather than emitting a short vector. + for (src, func, arity) in [ + ("[fn none [] 1]", "none", 0), + ("[fn one [a] a]", "one", 1), + ("[fn three [a b c] [+ a [+ b c]]]", "three", 3), + ] { + let src = format!("{src} [fn main [] []]"); + assert_eq!( + lowered_modes(&src, func).len(), + arity, + "`{func}` should have {arity} modes" + ); + } +} + +#[test] +fn a_callee_that_mutates_propagates_to_its_caller() { + // `caller` hands `x` to something that writes through it, so `x` is + // mutably borrowed rather than consumed — in placement terms, an argument + // that has to be synchronized back but need not be surrendered. Reaching + // this answer requires resolving the callee, which is what the fixed point + // buys over a single source-order pass. + let modes = modes_of( + "[fn caller [x] [later x]] [fn later [y] [push! y 1]]", + "caller", + ); + assert_eq!(modes, vec![ParamMode::MutBorrow]); +} + +#[test] +fn conservative_when_the_callee_is_unknowable() { + // A callee that is not a definition in this program — here a parameter + // holding a function — cannot be analyzed, so the argument is assumed + // consumed. That is sound: it only costs an optimization, and it must + // never come out as a plain borrow, which would wrongly tell a backend + // nothing needs copying back. + let modes = modes_of("[fn apply-to [f x] [f x]]", "apply-to"); + assert_eq!(modes[1], ParamMode::Move); +} + +#[test] +fn modes_do_not_depend_on_definition_order() { + // Mode inference walks definitions in source order and consults callees it + // has already seen. Reordering two independent functions must not change + // either one's answer. + let forward = modes_of( + "[fn helper [v] [push! v 1]] [fn user [w] [helper w]]", + "user", + ); + let backward = modes_of( + "[fn user [w] [helper w]] [fn helper [v] [push! v 1]]", + "user", + ); + assert_eq!( + forward, backward, + "definition order changed the inferred mode: {forward:?} vs {backward:?}" + ); +} From a8f3e73f1cae1fe99b2c93bae704febefee56eae Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 10:44:41 -0400 Subject: [PATCH 02/25] Placement is an effect: buffers, kernels, and Place MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A kernel is an ordinary function that promised to stay small: [kernel saxpy [i a x y out] [put out i [+ [* a [at x i]] [at y i]]]] `[kernel ...]` desugars to `fn` before anything else looks at it, so kernels infer, lower, and run through exactly the same path as any other function. What the keyword buys is a promise, checked in check/kernel.rs: no closures, no allocation, no strings, no effects. That restriction is the safety argument. The Rust offload work needs an `unsafe trait` for its partitioning strategies because a kernel there can index a slice however it likes; here the unsafe program cannot be written down. Buffers (Obj::Buffer) are dense, unboxed, fixed-length arrays — the representation that can leave the process, which persistent trees of NaN-boxed words cannot. `at` reads, `put` writes in place. `Place.run`, `Place.read`, `Place.pin`, `Place.stats` are effect operations. Unhandled, they run serially right here, so a program that never mentions placement still works. Handled, everything changes without the program moving: os/place.oo has tracing, dry-run, and residency handlers in a few lines each, and os/demo-place.oo runs one function under four of them to the same answer. Because `Place.read` is an operation rather than an accessor, a handler sees every synchronization point — which is what `Preload`/ `PreloadMut` exist to reconstruct in a language where it cannot. Direction is inferred, not annotated: `at` is a borrow and `put` a mutable borrow, so saxpy's modes come out In/In/In/In/InOut with no `&mut` anywhere. Two bugs found on the way, both pre-existing and both silent: - Closures called from higher-order builtins clobbered the caller's register 0. `[let n 8] [map [fn [v] [* 2 v]] [range 0 n]]` left `n` as 14, the last value map computed. The VM re-enters itself for these calls and named register 0 as the destination for a result that belongs to Rust; there is now a RET_DISCARD sentinel and a parity regression test. - `[len buf]` returned 0 through a catch-all rather than the length. Also: effect operations still move their arguments, so "responding twice with the same value is a compile error" survives. Place is the exception, because placement reads its inputs and writes through its outputs — it never takes ownership, and `[Place.read out]` afterwards is the entire point. Co-Authored-By: Claude Fable 5 --- crates/loon-lang/src/check/kernel.rs | 394 ++++++++++++++++++ crates/loon-lang/src/check/mod.rs | 174 +++++++- crates/loon-lang/src/check/ownership.rs | 61 ++- crates/loon-lang/src/codegen/mod.rs | 1 + crates/loon-lang/src/effects/mod.rs | 39 ++ crates/loon-lang/src/eir/layout.rs | 12 +- crates/loon-lang/src/eir/lower.rs | 10 + crates/loon-lang/src/eir/mod.rs | 22 + crates/loon-lang/src/eir/native.rs | 1 - crates/loon-lang/src/eir/place.rs | 203 ++++++++++ crates/loon-lang/src/eir/vm.rs | 487 ++++++++++++++++++++++- crates/loon-lang/src/errors/codes.rs | 9 + crates/loon-lang/src/errors/tutorials.rs | 1 + crates/loon-lang/tests/backend_parity.rs | 16 + crates/loon-lang/tests/loon_os.rs | 49 +++ crates/loon-lang/tests/place_effect.rs | 207 ++++++++++ os/demo-place.oo | 39 ++ os/place.oo | 74 ++++ samples/place/saxpy.oo | 24 ++ 19 files changed, 1798 insertions(+), 25 deletions(-) create mode 100644 crates/loon-lang/src/check/kernel.rs create mode 100644 crates/loon-lang/src/eir/place.rs create mode 100644 crates/loon-lang/tests/place_effect.rs create mode 100644 os/demo-place.oo create mode 100644 os/place.oo create mode 100644 samples/place/saxpy.oo diff --git a/crates/loon-lang/src/check/kernel.rs b/crates/loon-lang/src/check/kernel.rs new file mode 100644 index 0000000..185d562 --- /dev/null +++ b/crates/loon-lang/src/check/kernel.rs @@ -0,0 +1,394 @@ +//! Kernels: functions restricted enough to run somewhere else. +//! +//! A kernel is written like any other function — +//! +//! ```text +//! [kernel saxpy [i a x out] +//! [put out i [+ [* a [at x i]] [at out i]]]] +//! ``` +//! +//! — and is an ordinary function as far as the rest of the compiler is +//! concerned: [`desugar`] rewrites the head to `fn` before type checking, so +//! kernels infer, lower, and run exactly like anything else. What the keyword +//! buys is a *promise*, checked by [`verify`]: the body stays inside a small +//! numeric subset with no closures, no allocation, no strings, and no effects. +//! +//! That restriction is the safety argument. A recent Rust GPU-offload design +//! needs an `unsafe trait` for its partitioning strategies, because a kernel +//! there can be handed a slice and index it however it likes; the invariant +//! that threads touch disjoint elements has to be promised by hand. Here a +//! kernel cannot express the unsafe program in the first place — it receives +//! an index and may only write at that index — so the guarantee comes from +//! what the language declines to compile rather than from a promise attached +//! to a trait impl. +//! +//! The subset is also what makes a kernel portable. Everything admitted here +//! has a direct equivalent in scalar machine code and in WGSL, which is why +//! the same source can run on a CPU core, across threads, or on a GPU without +//! being rewritten for each. + +use crate::ast::{Expr, ExprKind}; +use crate::errors::codes::ErrorCode; +use crate::errors::LoonDiagnostic; +use std::collections::HashSet; + +/// Builtins a kernel body may call. +/// +/// Every one of these is a scalar numeric operation or a buffer element +/// access — things a GPU can do per work item. Anything that allocates, +/// inspects a collection, or touches a string is absent on purpose. +const KERNEL_BUILTINS: &[&str] = &[ + // Buffer element access. + "at", "put", "buf-len", // Math. + "sqrt", "pow", "floor", "ceil", "round", "sin", "cos", "tan", "asin", "acos", "atan", "atan2", + "log", "log10", "exp", "abs", "min", "max", // Numeric conversion. + "int", "float", // Logic. + "not", +]; + +/// Special forms a kernel body may use. +const KERNEL_FORMS: &[&str] = &["let", "if", "do", "and", "or", "recur", "mut"]; + +/// Rewrite every `[kernel name [params] body...]` into the equivalent `fn`, +/// returning the rewritten program and the set of kernel names. +/// +/// Doing this before type checking means kernels are not a second language: +/// they infer types, get ownership modes, and lower through exactly the same +/// path as ordinary functions. The only thing that remains special about them +/// is the promise [`verify`] enforces and the fact that they can be placed. +pub fn desugar(exprs: &[Expr]) -> (Vec, HashSet) { + let mut names = HashSet::new(); + let out = exprs.iter().map(|e| rewrite(e, &mut names)).collect(); + (out, names) +} + +fn rewrite(expr: &Expr, names: &mut HashSet) -> Expr { + let ExprKind::List(items) = &expr.kind else { + return expr.clone(); + }; + let mut new_items: Vec = items.iter().map(|i| rewrite(i, names)).collect(); + if let Some(ExprKind::Symbol(head)) = new_items.first().map(|i| &i.kind) { + if head == "kernel" && new_items.len() >= 3 { + if let ExprKind::Symbol(name) = &new_items[1].kind { + names.insert(name.clone()); + new_items[0] = Expr { + kind: ExprKind::Symbol("fn".to_string()), + ..new_items[0].clone() + }; + } + } + } + Expr { + kind: ExprKind::List(new_items), + ..expr.clone() + } +} + +/// Check that each kernel body stays inside the placeable subset. +/// +/// Runs on the desugared program, so kernels appear as `fn` forms; `names` +/// says which ones were written with the `kernel` keyword. +pub fn verify(exprs: &[Expr], names: &HashSet) -> Vec { + if names.is_empty() { + return Vec::new(); + } + let mut v = Verifier { + kernels: names, + errors: Vec::new(), + }; + for expr in exprs { + v.walk_program(expr); + } + v.errors +} + +struct Verifier<'a> { + kernels: &'a HashSet, + errors: Vec, +} + +impl Verifier<'_> { + fn walk_program(&mut self, expr: &Expr) { + let ExprKind::List(items) = &expr.kind else { + return; + }; + let is_fn = + matches!(items.first().map(|i| &i.kind), Some(ExprKind::Symbol(h)) if h == "fn"); + if is_fn && items.len() >= 3 { + if let ExprKind::Symbol(name) = &items[1].kind { + if self.kernels.contains(name) { + self.check_params(name, &items[2]); + for body in &items[3..] { + self.check_body(name, body); + } + return; + } + } + } + for item in items { + self.walk_program(item); + } + } + + /// A kernel's first parameter is its work index, so it needs at least one. + fn check_params(&mut self, kernel: &str, params: &Expr) { + let ExprKind::List(ps) = ¶ms.kind else { + return; + }; + if ps.is_empty() { + self.errors.push( + LoonDiagnostic::new( + ErrorCode::E0601, + format!("kernel '{kernel}' has no parameters"), + ) + .with_why( + "a kernel runs once per work item and takes that item's index as its first \ + parameter, so it cannot be nullary" + .to_string(), + ) + .with_fix(format!( + "give '{kernel}' an index parameter, e.g. [kernel {kernel} [i ...] ...]" + )) + .with_label( + params.span, + "expected at least an index parameter", + true, + ), + ); + } + } + + fn check_body(&mut self, kernel: &str, expr: &Expr) { + match &expr.kind { + // Literals and names are always fine. + ExprKind::Int(_) + | ExprKind::Float(_) + | ExprKind::Bool(_) + | ExprKind::Symbol(_) + | ExprKind::Keyword(_) => {} + + ExprKind::Str(_) => self.reject( + kernel, + expr, + "a string literal", + "kernels have no string support: there is nowhere to put the bytes on a device", + ), + ExprKind::Vec(_) | ExprKind::Map(_) | ExprKind::Set(_) | ExprKind::Tuple(_) => self + .reject( + kernel, + expr, + "a collection literal", + "kernels cannot allocate; pass a buffer in and index it instead", + ), + + ExprKind::List(items) => self.check_call(kernel, expr, items), + _ => {} + } + } + + fn check_call(&mut self, kernel: &str, expr: &Expr, items: &[Expr]) { + let Some(head) = items.first() else { + return; + }; + // `Effect.op` reaches here as a dot access on an uppercase name. + if let ExprKind::DotAccess(base, field) = &head.kind { + if let ExprKind::Symbol(b) = &base.kind { + if b.chars().next().is_some_and(|c| c.is_uppercase()) { + self.reject( + kernel, + expr, + &format!("the effect operation '{b}.{field}'"), + "a kernel runs where there is no handler tower to perform effects against", + ); + return; + } + } + } + + let ExprKind::Symbol(name) = &head.kind else { + // An indirect call means a function value, which a kernel has no + // way to have obtained. + self.reject( + kernel, + expr, + "an indirect call", + "kernels can only call other kernels and a fixed set of numeric builtins", + ); + return; + }; + + // An effect performed inside a kernel would need a handler on the + // device. Effects are how placement itself is expressed, so a kernel + // performing one would be circular as well as unimplementable. + if name.contains('.') && name.chars().next().is_some_and(|c| c.is_uppercase()) { + self.reject( + kernel, + expr, + &format!("the effect operation '{name}'"), + "a kernel runs where there is no handler tower to perform effects against", + ); + return; + } + + if name == "fn" || name == "kernel" { + self.reject( + kernel, + expr, + "a nested function", + "kernels cannot create closures; there is no heap to capture into", + ); + return; + } + + let known = KERNEL_FORMS.contains(&name.as_str()) + || KERNEL_BUILTINS.contains(&name.as_str()) + || self.kernels.contains(name) + || is_operator(name); + + if !known { + self.reject( + kernel, + expr, + &format!("a call to '{name}'"), + "kernels may call other kernels and numeric builtins only", + ); + return; + } + + for arg in &items[1..] { + self.check_body(kernel, arg); + } + } + + fn reject(&mut self, kernel: &str, expr: &Expr, what: &str, why: &str) { + self.errors.push( + LoonDiagnostic::new( + ErrorCode::E0600, + format!("kernel '{kernel}' contains {what}"), + ) + .with_why(why.to_string()) + .with_fix( + "move this out of the kernel and pass the result in as a buffer or scalar" + .to_string(), + ) + .with_label(expr.span, "not allowed inside a kernel", true), + ); + } +} + +/// Operators lower to arithmetic instructions rather than builtin calls. +fn is_operator(name: &str) -> bool { + matches!( + name, + "+" | "-" | "*" | "/" | "%" | "=" | "!=" | "<" | ">" | "<=" | ">=" + ) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::parser::parse; + + fn check(src: &str) -> Vec { + let exprs = parse(src).expect("parses"); + let (desugared, names) = desugar(&exprs); + verify(&desugared, &names) + } + + #[test] + fn a_numeric_kernel_is_accepted() { + let errors = check("[kernel saxpy [i a x out] [put out i [+ [* a [at x i]] [at out i]]]]"); + assert!(errors.is_empty(), "unexpected errors: {errors:?}"); + } + + #[test] + fn control_flow_and_math_are_accepted() { + let errors = check( + "[kernel clamp [i lo hi x out] \ + [let v [at x i]] \ + [put out i [if [< v lo] lo [if [> v hi] hi [sqrt [abs v]]]]]]", + ); + assert!(errors.is_empty(), "unexpected errors: {errors:?}"); + } + + #[test] + fn a_kernel_may_call_another_kernel() { + let errors = check( + "[kernel scale [i s x out] [put out i [* s [at x i]]]] \ + [kernel twice [i x out] [scale i 2.0 x out]]", + ); + assert!(errors.is_empty(), "unexpected errors: {errors:?}"); + } + + #[test] + fn desugaring_makes_a_kernel_an_ordinary_function() { + let exprs = parse("[kernel k [i x] [put x i 1.0]]").expect("parses"); + let (desugared, names) = desugar(&exprs); + assert!(names.contains("k")); + let ExprKind::List(items) = &desugared[0].kind else { + panic!("expected a list"); + }; + assert!( + matches!(&items[0].kind, ExprKind::Symbol(h) if h == "fn"), + "the head should have become `fn`, got {:?}", + items[0].kind + ); + } + + #[test] + fn allocation_is_rejected() { + let errors = check("[kernel k [i out] [put out i [len #[1 2 3]]]]"); + assert!(!errors.is_empty(), "a vector literal should be rejected"); + assert_eq!(errors[0].code, ErrorCode::E0600); + } + + #[test] + fn strings_are_rejected() { + let errors = check("[kernel k [i out] [put out i [len \"hello\"]]]"); + assert!(!errors.is_empty(), "a string literal should be rejected"); + } + + #[test] + fn closures_are_rejected() { + let errors = check("[kernel k [i out] [put out i [[fn [x] x] 1.0]]]"); + assert!(!errors.is_empty(), "a nested fn should be rejected"); + } + + #[test] + fn effects_are_rejected() { + // This one is the interesting case: placement *is* an effect, so a + // kernel performing one would be asking the device to reach back into + // the handler tower it was dispatched from. + let errors = check("[kernel k [i out] [do [IO.println 1] [put out i 1.0]]]"); + assert!(!errors.is_empty(), "an effect should be rejected"); + assert!( + errors[0].what.contains("IO.println"), + "the message should name the operation: {}", + errors[0].what + ); + } + + #[test] + fn calls_to_ordinary_functions_are_rejected() { + let errors = check("[fn helper [x] x] [kernel k [i out] [put out i [helper 1.0]]]"); + assert!( + !errors.is_empty(), + "a kernel may not call a non-kernel function" + ); + } + + #[test] + fn a_nullary_kernel_is_rejected() { + let errors = check("[kernel k [] 1]"); + assert!(!errors.is_empty(), "a kernel needs an index parameter"); + assert_eq!(errors[0].code, ErrorCode::E0601); + } + + #[test] + fn ordinary_functions_are_left_alone() { + // The restrictions apply to kernels only; normal code keeps every + // feature the language has. + let errors = check("[fn ordinary [] [let v #[1 2 3]] [IO.println \"hi\"] [len v]]"); + assert!(errors.is_empty(), "unexpected errors: {errors:?}"); + } +} diff --git a/crates/loon-lang/src/check/mod.rs b/crates/loon-lang/src/check/mod.rs index fec5aaf..08cf31b 100644 --- a/crates/loon-lang/src/check/mod.rs +++ b/crates/loon-lang/src/check/mod.rs @@ -1,3 +1,4 @@ +pub mod kernel; pub mod ownership; use crate::ast::{Expr, ExprKind, NodeId}; @@ -125,6 +126,10 @@ pub struct Checker { /// Loon infers them, and lowering carries them into the IR so backends can /// tell a read-only argument from one that is written through. pub fn_param_modes: HashMap>, + /// Names defined with the `kernel` keyword. They are ordinary functions + /// after desugaring; this is what remembers that they promised to stay + /// inside the placeable subset. + pub kernels: HashSet, } /// Split a param list at a `&` marker: returns the fixed params and the @@ -151,6 +156,7 @@ impl Checker { env: TypeEnv::new(), errors: Vec::new(), fn_param_modes: HashMap::new(), + kernels: HashSet::new(), constructors: HashMap::new(), type_constructors: HashMap::new(), type_of: HashMap::new(), @@ -1404,6 +1410,145 @@ impl Checker { ); } + // ── Dense buffers ── + // + // `Buf a` is an opaque, fixed-length array of unboxed numbers. It is + // the representation that can leave the process — to another thread, + // another backend, or a device — which ordinary persistent + // collections cannot. + { + let mk_var = |c: &mut Self| match c.subst.fresh() { + Type::Var(v) => v, + _ => unreachable!("fresh() returns a Var"), + }; + let buf_of = |t: Type| Type::Con("Buf".to_string(), vec![t]); + let vec_of = |t: Type| Type::Con("Vec".to_string(), vec![t]); + + // buf / buf-f64: ∀a:Num. Vec a → Buf Float + // buf-i32: ∀a:Num. Vec a → Buf Int + // + // The source vector may hold ints or floats; the buffer's element + // type is fixed by which constructor was called, and the values + // are converted on the way in. That conversion is the honest part: + // an f32 buffer really does hold f32, and saying so in the type is + // better than pretending the input type survived. + for (name, elem) in [ + ("buf", Type::Float), + ("buf-f64", Type::Float), + ("buf-i32", Type::Int), + ] { + let a = self.subst.fresh(); + let tv = match a { + Type::Var(v) => v, + _ => unreachable!("fresh() returns a Var"), + }; + self.env.set_global( + name.to_string(), + Scheme { + bounds: vec![( + tv, + vec![TraitBound { + trait_name: "Num".to_string(), + }], + )], + vars: vec![tv], + ty: Type::Fn( + vec![vec_of(Type::Var(tv))], + Box::new(buf_of(elem)), + EffectRow::pure(), + ), + }, + ); + } + + // buf-zeros: Int → Buf Float, buf-zeros-i32: Int → Buf Int + for (name, elem) in [("buf-zeros", Type::Float), ("buf-zeros-i32", Type::Int)] { + self.env.set_global( + name.to_string(), + Scheme::mono(Type::Fn( + vec![Type::Int], + Box::new(buf_of(elem)), + EffectRow::pure(), + )), + ); + } + + // buf-len: ∀a. Buf a → Int + let v = mk_var(self); + self.env.set_global( + "buf-len".to_string(), + Scheme { + bounds: vec![], + vars: vec![v], + ty: Type::Fn( + vec![buf_of(Type::Var(v))], + Box::new(Type::Int), + EffectRow::pure(), + ), + }, + ); + + // buf-dtype: ∀a. Buf a → Str + let v = mk_var(self); + self.env.set_global( + "buf-dtype".to_string(), + Scheme { + bounds: vec![], + vars: vec![v], + ty: Type::Fn( + vec![buf_of(Type::Var(v))], + Box::new(Type::Str), + EffectRow::pure(), + ), + }, + ); + + // buf->vec: ∀a. Buf a → Vec a + let v = mk_var(self); + self.env.set_global( + "buf->vec".to_string(), + Scheme { + bounds: vec![], + vars: vec![v], + ty: Type::Fn( + vec![buf_of(Type::Var(v))], + Box::new(vec_of(Type::Var(v))), + EffectRow::pure(), + ), + }, + ); + + // at: ∀a. Buf a → Int → a + let v = mk_var(self); + self.env.set_global( + "at".to_string(), + Scheme { + bounds: vec![], + vars: vec![v], + ty: Type::Fn( + vec![buf_of(Type::Var(v)), Type::Int], + Box::new(Type::Var(v)), + EffectRow::pure(), + ), + }, + ); + + // put: ∀a. Buf a → Int → a → Buf a + let v = mk_var(self); + self.env.set_global( + "put".to_string(), + Scheme { + bounds: vec![], + vars: vec![v], + ty: Type::Fn( + vec![buf_of(Type::Var(v)), Type::Int, Type::Var(v)], + Box::new(buf_of(Type::Var(v))), + EffectRow::pure(), + ), + }, + ); + } + // int: Str → Int self.env.set_global( "int".to_string(), @@ -3188,13 +3333,25 @@ impl Checker { // Type-check arguments against declared param types let arg_types: Vec = items[1..].iter().map(|a| self.infer(a)).collect(); - if arg_types.len() != op_def.params.len() { + // A variadic op's last parameter absorbs the rest, so + // it needs at least the fixed ones and accepts more. + let arity_ok = if op_def.variadic { + arg_types.len() + 1 >= op_def.params.len() + } else { + arg_types.len() == op_def.params.len() + }; + if !arity_ok { self.errors.push( LoonDiagnostic::new( ErrorCode::E0202, format!( - "`{effect}.{op}` expects {} argument(s), got {}", - op_def.params.len(), + "`{effect}.{op}` expects {}{} argument(s), got {}", + if op_def.variadic { "at least " } else { "" }, + if op_def.variadic { + op_def.params.len() - 1 + } else { + op_def.params.len() + }, arg_types.len() ), ) @@ -3829,6 +3986,7 @@ impl Checker { name: op_name, params, return_type, + variadic: false, }); } } @@ -5697,6 +5855,12 @@ impl Checker { } }; + // Phase 1b: Kernels become ordinary functions before anything else + // looks at the program, so they infer, lower, and run through exactly + // the same path. Only the promise they made is kept aside. + let (expanded, kernels) = kernel::desugar(&expanded); + self.kernels = kernels; + // Phase 2a: Pre-declare top-level functions so forward references // (including mutual recursion across definitions) resolve. Each name // gets a placeholder type; its real scheme replaces it at the @@ -5756,6 +5920,10 @@ impl Checker { // This is a syntactic pass over the expanded program; its diagnostics // are the dedicated ownership pass's job, not ours. self.fn_param_modes = ownership::infer_param_modes(&self.expanded_program); + // A kernel that cannot be placed is worth saying so about at compile + // time, not when a handler tries to ship it somewhere. + self.errors + .extend(kernel::verify(&self.expanded_program, &self.kernels)); std::mem::take(&mut self.errors) } diff --git a/crates/loon-lang/src/check/ownership.rs b/crates/loon-lang/src/check/ownership.rs index 6da70f2..7e1a8b5 100644 --- a/crates/loon-lang/src/check/ownership.rs +++ b/crates/loon-lang/src/check/ownership.rs @@ -126,11 +126,14 @@ impl<'a> OwnershipChecker<'a> { // lets the escaping/answer-passing style (e.g. `[[resume s] s]`) // reuse a value across the resume without a false move error. "resume", - // Kernel element read. `[at buf i]` observes one element and never - // consumes the buffer, so a kernel parameter that is only read - // stays a borrow — which is what makes it an `:in` (host-to-device - // only) argument at a placement boundary. + // Buffer readers. `[at buf i]` observes one element, and the rest + // inspect or copy out without consuming, so a kernel parameter + // that is only read stays a borrow — which is what makes it an + // `:in` (host-to-device only) argument at a placement boundary. "at", + "buf-len", + "buf-dtype", + "buf->vec", ] { borrow_fns.insert(name.to_string()); } @@ -584,8 +587,10 @@ impl<'a> OwnershipChecker<'a> { } return; } - "push!" => { - // push! requires mutable borrow of first arg + "push!" | "put" => { + // Writes through the first argument, reads the rest — a + // mutable borrow, not a move: the caller still owns the + // buffer (or vector) afterwards. if items.len() > 1 { if let ExprKind::Symbol(name) = &items[1].kind { self.mut_borrow(name, items[1].span); @@ -607,6 +612,24 @@ impl<'a> OwnershipChecker<'a> { } } + // Effect operations consume their arguments by default, which is what + // makes "responding twice with the same value is a compile error" a + // property of the language rather than a convention. + // + // `Place` is the exception, and not by special pleading: placement is + // defined to read its inputs and write through its outputs, never to + // take ownership of either. `[Place.run k n x out]` leaves the caller + // owning both `x` and `out` — indeed `[Place.read out]` afterwards is + // the entire point, and is how a program gets its results back. + if let ExprKind::DotAccess(base, _) = &items[0].kind { + if matches!(&base.kind, ExprKind::Symbol(b) if b == "Place") { + for item in &items[1..] { + self.check_expr(item); + } + return; + } + } + // Generic function call — head is borrowed, args use per-param modes if available let callee_name = if let ExprKind::Symbol(s) = &items[0].kind { Some(s.clone()) @@ -678,11 +701,22 @@ impl<'a> OwnershipChecker<'a> { self.fn_param_modes.insert(name.clone(), modes); } + // A parameter the analysis just inferred as mutably borrowed IS + // mutable inside this body — that is what the inference means. + // Requiring `let mut` on a parameter would be asking the author to + // restate a conclusion the compiler already reached, and there is + // nowhere to write it anyway. + let modes = fn_name + .as_ref() + .and_then(|n| self.fn_param_modes.get(n).cloned()) + .unwrap_or_default(); + self.push_scope(); - for p in params { + for (idx, p) in params.iter().enumerate() { if let ExprKind::Symbol(name) = &p.kind { let is_copy = self.is_value_copy(p); - self.define(name.clone(), p.span, is_copy, false); + let is_mut = matches!(modes.get(idx), Some(ParamMode::MutBorrow)); + self.define(name.clone(), p.span, is_copy, is_mut); } } for expr in &args[body_start..] { @@ -821,18 +855,11 @@ impl<'a> OwnershipChecker<'a> { // exactly as `check_defn` does. let mut body_start = 3; if body_start < items.len() - && matches!( - &items[body_start].kind, - ExprKind::Set(_) | ExprKind::Map(_) - ) + && matches!(&items[body_start].kind, ExprKind::Set(_) | ExprKind::Map(_)) { body_start += 1; } - out.push(( - name.clone(), - param_names, - items[body_start..].to_vec(), - )); + out.push((name.clone(), param_names, items[body_start..].to_vec())); return; } } diff --git a/crates/loon-lang/src/codegen/mod.rs b/crates/loon-lang/src/codegen/mod.rs index 55c0203..b61a5e1 100644 --- a/crates/loon-lang/src/codegen/mod.rs +++ b/crates/loon-lang/src/codegen/mod.rs @@ -1181,6 +1181,7 @@ impl Compiler { name: op_name, params, return_type, + variadic: false, }); } } diff --git a/crates/loon-lang/src/effects/mod.rs b/crates/loon-lang/src/effects/mod.rs index f49a9b4..71f314c 100644 --- a/crates/loon-lang/src/effects/mod.rs +++ b/crates/loon-lang/src/effects/mod.rs @@ -13,6 +13,11 @@ pub struct EffectOp { pub name: String, pub params: Vec<(String, Option)>, // (name, type_name) pub return_type: Option, + /// The final parameter absorbs any number of extra arguments. + /// + /// `Place.run` needs this: a kernel's arguments are its own, and the + /// placement operation carries however many of them there are. + pub variadic: bool, } /// Registry of declared effects @@ -34,6 +39,17 @@ fn op(name: &str, param_names: &[&str]) -> EffectOp { name: name.to_string(), params: params(param_names), return_type: None, + variadic: false, + } +} + +/// An op whose last parameter absorbs any number of trailing arguments. +fn var_op(name: &str, param_names: &[&str]) -> EffectOp { + EffectOp { + name: name.to_string(), + params: params(param_names), + return_type: None, + variadic: true, } } @@ -43,6 +59,7 @@ fn typed_op(name: &str, param_names: &[&str], ret: &str) -> EffectOp { name: name.to_string(), params: params(param_names), return_type: Some(ret.to_string()), + variadic: false, } } @@ -124,6 +141,28 @@ impl EffectRegistry { op("seed", &["n"]), ], }); + // Place effect — where a kernel runs is a decision a handler makes, + // not a property of the program. Unhandled, it runs serially on the + // CPU, so a program that never mentions placement still works. + reg.register(EffectDecl { + name: "Place".to_string(), + operations: vec![ + // [Place.run kernel n args...] — run `kernel` once per index + // in 0..n. Returns unit; kernels write through buffers. + op("run", &["kernel", "n", "args"]), + // [Place.read buf] — the only way to get buffer contents back + // to the host. Being an operation is the point: a residency + // handler learns where every synchronization point is without + // the programmer marking any of them. + op("read", &["buf"]), + // [Place.pin buf] / [Place.unpin buf] — hints that a buffer + // should stay where it is between launches. + op("pin", &["buf"]), + op("unpin", &["buf"]), + // [Place.stats] — transfer and launch counters so far. + op("stats", &[]), + ], + }); reg.register(EffectDecl { name: "Embed".to_string(), operations: vec![op("encode", &["text"])], diff --git a/crates/loon-lang/src/eir/layout.rs b/crates/loon-lang/src/eir/layout.rs index 76d8118..04a85f7 100644 --- a/crates/loon-lang/src/eir/layout.rs +++ b/crates/loon-lang/src/eir/layout.rs @@ -232,8 +232,16 @@ pub const GOLDEN_IMMEDIATES: &[(&str, &str, u64)] = &[ ("int-zero", "0", nanbox::encode_int(0)), ("int-42", "42", nanbox::encode_int(42)), ("int-neg", "-7", nanbox::encode_int(-7)), - ("int-max48", "140737488355327", nanbox::encode_int((1i64 << 47) - 1)), - ("int-min48", "-140737488355328", nanbox::encode_int(-(1i64 << 47))), + ( + "int-max48", + "140737488355327", + nanbox::encode_int((1i64 << 47) - 1), + ), + ( + "int-min48", + "-140737488355328", + nanbox::encode_int(-(1i64 << 47)), + ), ]; /// A byte pattern chosen to break sloppy marshalling: negative zero, a NaN diff --git a/crates/loon-lang/src/eir/lower.rs b/crates/loon-lang/src/eir/lower.rs index 61d5423..1f6f345 100644 --- a/crates/loon-lang/src/eir/lower.rs +++ b/crates/loon-lang/src/eir/lower.rs @@ -2490,6 +2490,16 @@ pub fn resolve_builtin_name(name: &str) -> Option { "name" => Some(Built::Name), "type-of" => Some(Built::TypeOf), "remove" => Some(Built::Remove), + "buf" => Some(Built::BufNew), + "buf-i32" => Some(Built::BufNewI32), + "buf-f64" => Some(Built::BufNewF64), + "buf-zeros" => Some(Built::BufZeros), + "buf-zeros-i32" => Some(Built::BufZerosI32), + "buf-len" => Some(Built::BufLen), + "buf->vec" => Some(Built::BufToVec), + "buf-dtype" => Some(Built::BufDtype), + "at" => Some(Built::BufAt), + "put" => Some(Built::BufPut), "sqrt" => Some(Built::Sqrt), "pow" => Some(Built::Pow), "floor" => Some(Built::Floor), diff --git a/crates/loon-lang/src/eir/mod.rs b/crates/loon-lang/src/eir/mod.rs index 12fb93d..0423dec 100644 --- a/crates/loon-lang/src/eir/mod.rs +++ b/crates/loon-lang/src/eir/mod.rs @@ -9,6 +9,7 @@ pub mod lower; #[cfg(feature = "native")] pub mod native; pub mod net; +pub mod place; pub mod replay; pub mod tailcall; pub mod trace; @@ -453,6 +454,27 @@ pub enum Built { /// for any other value. Emitted by pattern compilation so `#[a b]` can /// test "is a sequence of length 2" in one comparison. SeqLen, + // ── Dense buffers ── + /// `buf` — an f32 buffer from a vector of numbers. + BufNew, + /// `buf-i32` — an i32 buffer from a vector of numbers. + BufNewI32, + /// `buf-f64` — an f64 buffer from a vector of numbers. + BufNewF64, + /// `buf-zeros` — an f32 buffer of n zeros. + BufZeros, + /// `buf-zeros-i32` — an i32 buffer of n zeros. + BufZerosI32, + /// `buf-len` — element count. + BufLen, + /// `buf->vec` — copy out to an ordinary vector. + BufToVec, + /// `buf-dtype` — element type name, as a string. + BufDtype, + /// `at` — read element i. Out of range is an error, never a made-up zero. + BufAt, + /// `put` — write element i in place and return the buffer. + BufPut, /// Internal (not name-resolvable): destructuring guard. Args are /// (value, expected-binder-count). Errors loudly unless the value is a /// vector/tuple with at least that many elements — a silent `()` bind diff --git a/crates/loon-lang/src/eir/native.rs b/crates/loon-lang/src/eir/native.rs index 8bd246c..d12ba7f 100644 --- a/crates/loon-lang/src/eir/native.rs +++ b/crates/loon-lang/src/eir/native.rs @@ -547,7 +547,6 @@ fn op_description(op: &Op) -> &'static str { } } - #[allow(clippy::too_many_arguments)] fn compile_op( builder: &mut FunctionBuilder, diff --git a/crates/loon-lang/src/eir/place.rs b/crates/loon-lang/src/eir/place.rs new file mode 100644 index 0000000..6a9bb19 --- /dev/null +++ b/crates/loon-lang/src/eir/place.rs @@ -0,0 +1,203 @@ +//! Placement: where a kernel runs, and what it cost to put it there. +//! +//! Loon expresses placement as an effect. A program performs `Place.run` and a +//! handler decides what that means — run it here, run it across threads, ship +//! it to a device, record it, or pretend. Nothing in the program changes when +//! the answer changes. +//! +//! This module holds the parts that are the same whoever answers: the record +//! of what happened ([`PlaceEvent`]) and the running totals ([`PlaceStats`]). +//! Transfer accounting is not an afterthought here. The interesting question +//! about an offloaded program is almost never "was the kernel fast" — it is +//! "how many times did these bytes cross the boundary, and did they need to". +//! Making that observable is what lets a residency policy be written as a +//! handler and then *checked*, rather than assumed. + +use super::layout::DType; + +/// What a placement backend did. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum EventKind { + /// Bytes moved toward the device. + Upload, + /// Bytes moved back to the host. + Download, + /// A kernel ran. + Launch, + /// An argument was already resident, so no transfer happened. Counting + /// the transfers that *didn't* occur is what makes a residency policy + /// legible: the win shows up as a number, not as a wall-clock guess. + ResidentHit, + /// Device memory was reserved. + Alloc, + /// Device memory was released. + Free, +} + +impl EventKind { + pub fn name(self) -> &'static str { + match self { + EventKind::Upload => "upload", + EventKind::Download => "download", + EventKind::Launch => "launch", + EventKind::ResidentHit => "resident-hit", + EventKind::Alloc => "alloc", + EventKind::Free => "free", + } + } +} + +/// One thing that happened during placement. +#[derive(Debug, Clone)] +pub struct PlaceEvent { + pub kind: EventKind, + /// Kernel name, for a launch. + pub kernel: Option, + /// Which argument this concerns, for a transfer. + pub arg: Option, + /// Element type of the buffer involved. + pub dtype: Option, + /// Bytes moved. + pub bytes: u64, + /// Work items, for a launch. + pub items: u64, + /// Which backend answered. + pub device: &'static str, +} + +/// Running totals across a program. +#[derive(Debug, Clone, Default)] +pub struct PlaceStats { + pub launches: u64, + pub work_items: u64, + pub uploads: u64, + pub downloads: u64, + pub bytes_in: u64, + pub bytes_out: u64, + pub resident_hits: u64, + pub events: Vec, +} + +impl PlaceStats { + pub fn record(&mut self, event: PlaceEvent) { + match event.kind { + EventKind::Upload => { + self.uploads += 1; + self.bytes_in += event.bytes; + } + EventKind::Download => { + self.downloads += 1; + self.bytes_out += event.bytes; + } + EventKind::Launch => { + self.launches += 1; + self.work_items += event.items; + } + EventKind::ResidentHit => self.resident_hits += 1, + EventKind::Alloc | EventKind::Free => {} + } + self.events.push(event); + } + + /// A one-line summary in the shape offload papers report: how many + /// transfers, how many bytes, how many launches. + pub fn summary(&self) -> String { + format!( + "{} launches over {} work items; {} uploads ({}), {} downloads ({}), {} resident hits", + self.launches, + self.work_items, + self.uploads, + human_bytes(self.bytes_in), + self.downloads, + human_bytes(self.bytes_out), + self.resident_hits, + ) + } + + /// A multi-line table for `--place-stats`. + pub fn table(&self) -> String { + let mut out = String::new(); + out.push_str("placement\n"); + out.push_str(&format!(" launches {}\n", self.launches)); + out.push_str(&format!(" work items {}\n", self.work_items)); + out.push_str(&format!( + " uploads {} ({})\n", + self.uploads, + human_bytes(self.bytes_in) + )); + out.push_str(&format!( + " downloads {} ({})\n", + self.downloads, + human_bytes(self.bytes_out) + )); + out.push_str(&format!(" resident hits {}\n", self.resident_hits)); + out + } +} + +/// Bytes in a unit a person can read at a glance. +pub fn human_bytes(n: u64) -> String { + const KB: u64 = 1024; + const MB: u64 = KB * 1024; + const GB: u64 = MB * 1024; + if n >= GB { + format!("{:.1} GB", n as f64 / GB as f64) + } else if n >= MB { + format!("{:.1} MB", n as f64 / MB as f64) + } else if n >= KB { + format!("{:.1} KB", n as f64 / KB as f64) + } else { + format!("{n} B") + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn ev(kind: EventKind, bytes: u64, items: u64) -> PlaceEvent { + PlaceEvent { + kind, + kernel: None, + arg: None, + dtype: None, + bytes, + items, + device: "test", + } + } + + #[test] + fn totals_follow_the_events() { + let mut s = PlaceStats::default(); + s.record(ev(EventKind::Upload, 100, 0)); + s.record(ev(EventKind::Upload, 40, 0)); + s.record(ev(EventKind::Launch, 0, 1024)); + s.record(ev(EventKind::Download, 60, 0)); + s.record(ev(EventKind::ResidentHit, 0, 0)); + + assert_eq!(s.uploads, 2); + assert_eq!(s.bytes_in, 140); + assert_eq!(s.downloads, 1); + assert_eq!(s.bytes_out, 60); + assert_eq!(s.launches, 1); + assert_eq!(s.work_items, 1024); + assert_eq!(s.resident_hits, 1); + assert_eq!(s.events.len(), 5); + } + + #[test] + fn byte_counts_read_like_prose() { + assert_eq!(human_bytes(512), "512 B"); + assert_eq!(human_bytes(2048), "2.0 KB"); + assert_eq!(human_bytes(3 * 1024 * 1024), "3.0 MB"); + assert_eq!(human_bytes(2 * 1024 * 1024 * 1024), "2.0 GB"); + } + + #[test] + fn a_quiet_run_reports_zeroes_rather_than_nothing() { + let s = PlaceStats::default(); + assert!(s.summary().contains("0 launches")); + assert!(s.table().contains("resident hits 0")); + } +} diff --git a/crates/loon-lang/src/eir/vm.rs b/crates/loon-lang/src/eir/vm.rs index 02ecc99..d4eec8f 100644 --- a/crates/loon-lang/src/eir/vm.rs +++ b/crates/loon-lang/src/eir/vm.rs @@ -5,6 +5,7 @@ //! Tail calls reuse the current frame. No continuation stack — just a //! call stack of `(FuncId, BlockId, ip, registers)`. +use crate::eir::layout::DType; pub use crate::eir::value64::Val; use crate::eir::*; use std::collections::HashMap; @@ -119,6 +120,15 @@ enum Obj { Tuple(Vec), // fixed-size, no persistence needed Adt(u16, Vec), // tag + fields Closure(FuncId, Vec), // func + captured values + /// A dense, fixed-length array of unboxed numbers. + /// + /// Loon's ordinary collections are persistent trees of NaN-boxed words, + /// which is the right shape for a functional language and the wrong shape + /// for anything that has to hand bytes to another processor. A `Buffer` is + /// the other shape: contiguous, untagged, and describable by a + /// `layout::BufferHeader`, so the same bytes can be shipped to a thread, a + /// kernel, or a device queue without a conversion step. + Buffer(Buffer), /// A reified multi-shot delimited continuation captured at a `perform`: the /// frame segment between the perform and its handler's prompt, plus the /// execution point to resume at. `resume_continuation` clones this segment on @@ -152,6 +162,7 @@ impl Obj { Obj::Map(m) => (24 + m.len() * 16) as u64, Obj::Adt(_, fields) => (24 + 2 + fields.len() * 8) as u64, Obj::Closure(_, caps) => (24 + 4 + caps.len() * 8) as u64, + Obj::Buffer(b) => 24 + b.byte_len() as u64, Obj::Continuation { saved, regs, @@ -162,6 +173,166 @@ impl Obj { } } +// ─── Dense buffers ───────────────────────────────────────────────────────── + +/// The elements of a [`Obj::Buffer`], one variant per [`DType`]. +#[derive(Debug, Clone, PartialEq)] +pub enum BufData { + F32(Vec), + F64(Vec), + I32(Vec), + I64(Vec), +} + +/// A dense numeric array. +/// +/// Values are read and written by index through `at` and `put`. Unlike Loon's +/// persistent collections a buffer is mutated in place when its owner is +/// unique, which is what makes it cheap enough to be worth sending anywhere. +#[derive(Debug, Clone, PartialEq)] +pub struct Buffer { + pub data: BufData, +} + +impl Buffer { + pub fn zeros(dtype: DType, len: usize) -> Buffer { + Buffer { + data: match dtype { + DType::F32 => BufData::F32(vec![0.0; len]), + DType::F64 => BufData::F64(vec![0.0; len]), + DType::I32 => BufData::I32(vec![0; len]), + DType::I64 => BufData::I64(vec![0; len]), + }, + } + } + + pub fn dtype(&self) -> DType { + match &self.data { + BufData::F32(_) => DType::F32, + BufData::F64(_) => DType::F64, + BufData::I32(_) => DType::I32, + BufData::I64(_) => DType::I64, + } + } + + pub fn len(&self) -> usize { + match &self.data { + BufData::F32(v) => v.len(), + BufData::F64(v) => v.len(), + BufData::I32(v) => v.len(), + BufData::I64(v) => v.len(), + } + } + + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + pub fn byte_len(&self) -> usize { + self.len() * self.dtype().size() + } + + /// Element `i` as a Loon value, or `None` if out of range. + /// + /// Out of range is deliberately not silently zero: reading past the end of + /// a buffer is a bug in the program, and a language that answers `0` for it + /// teaches you to trust an answer it made up. + pub fn get(&self, i: usize) -> Option { + match &self.data { + BufData::F32(v) => v.get(i).map(|x| Val::float(*x as f64)), + BufData::F64(v) => v.get(i).map(|x| Val::float(*x)), + BufData::I32(v) => v.get(i).map(|x| Val::int(*x as i64)), + BufData::I64(v) => v.get(i).map(|x| Val::int(*x)), + } + } + + /// Write element `i`, converting to the buffer's element type. Returns + /// false if the index is out of range or the value is not numeric. + pub fn set(&mut self, i: usize, val: Val) -> bool { + let num = if val.is_int() { + val.as_int() as f64 + } else if val.is_float() { + val.as_float() + } else { + return false; + }; + match &mut self.data { + BufData::F32(v) => match v.get_mut(i) { + Some(slot) => *slot = num as f32, + None => return false, + }, + BufData::F64(v) => match v.get_mut(i) { + Some(slot) => *slot = num, + None => return false, + }, + BufData::I32(v) => match v.get_mut(i) { + Some(slot) => *slot = num as i32, + None => return false, + }, + BufData::I64(v) => match v.get_mut(i) { + Some(slot) => *slot = num as i64, + None => return false, + }, + } + true + } + + /// The raw bytes of the elements, little-endian. + pub fn to_bytes(&self) -> Vec { + match &self.data { + BufData::F32(v) => v.iter().flat_map(|x| x.to_le_bytes()).collect(), + BufData::F64(v) => v.iter().flat_map(|x| x.to_le_bytes()).collect(), + BufData::I32(v) => v.iter().flat_map(|x| x.to_le_bytes()).collect(), + BufData::I64(v) => v.iter().flat_map(|x| x.to_le_bytes()).collect(), + } + } + + /// Rebuild from raw little-endian bytes. Returns `None` on a length that + /// is not a whole number of elements. + pub fn from_bytes(dtype: DType, bytes: &[u8]) -> Option { + if bytes.len() % dtype.size() != 0 { + return None; + } + let data = match dtype { + DType::F32 => BufData::F32( + bytes + .chunks_exact(4) + .map(|c| f32::from_le_bytes(c.try_into().unwrap())) + .collect(), + ), + DType::F64 => BufData::F64( + bytes + .chunks_exact(8) + .map(|c| f64::from_le_bytes(c.try_into().unwrap())) + .collect(), + ), + DType::I32 => BufData::I32( + bytes + .chunks_exact(4) + .map(|c| i32::from_le_bytes(c.try_into().unwrap())) + .collect(), + ), + DType::I64 => BufData::I64( + bytes + .chunks_exact(8) + .map(|c| i64::from_le_bytes(c.try_into().unwrap())) + .collect(), + ), + }; + Some(Buffer { data }) + } +} + +/// A `ret_reg` meaning "this call's result is returned to the Rust caller, +/// not stored into a register". +/// +/// The VM re-enters itself whenever a builtin calls back into Loon — `map` +/// over a closure, a kernel launched by `Place.run`. Those calls have no +/// destination register in the caller, because the caller is Rust. Naming +/// register 0 instead, as this used to, silently overwrote whatever the +/// caller's first register held. +const RET_DISCARD: u32 = u32::MAX; + // ─── Call frame ──────────────────────────────────────────────────────────── /// Saved call frame — pushed when entering a function, popped on return. @@ -174,6 +345,8 @@ struct Frame { /// Register file for the suspended frame. regs: Vec, /// Register in the caller's frame to write the return value into. + /// Register in *this* frame that receives the callee's return value, or + /// [`RET_DISCARD`] when the value goes back to Rust instead. ret_reg: u32, /// Closure captures for the suspended frame. captures: Vec, @@ -247,6 +420,8 @@ pub struct Vm { ip: usize, /// Output capture (for println). output: Vec, + /// Placement accounting: launches, transfers, and residency hits. + pub place_stats: crate::eir::place::PlaceStats, /// String constants resolved to heap indices. string_cache: HashMap, /// Interns string *objects* by content, so structurally-equal strings share @@ -351,6 +526,7 @@ impl Vm { resume_closure: Val::UNIT, // set in run() current_span: Span::ZERO, heap_stats: HeapStats::default(), + place_stats: crate::eir::place::PlaceStats::default(), recorder: None, replay: None, runtime_syms: Vec::new(), @@ -497,7 +673,7 @@ impl Vm { caps: Vec, ) -> Result { let depth = self.frames.len(); - self.call_func_with_captures(func_id, args, 0, caps)?; + self.call_func_with_captures(func_id, args, RET_DISCARD, caps)?; self.execute(depth + 1) } @@ -526,6 +702,85 @@ impl Vm { val } + /// Run a kernel once per work item, right here. + /// + /// `[Place.run kernel n args...]` calls `kernel(i, args...)` for each `i` + /// in `0..n`. Kernels return nothing useful; they write through their + /// buffer arguments, which is why the ownership pass reporting a + /// written-through parameter as `InOut` is the same fact as "this buffer + /// has to come back". + fn place_run_serial(&mut self, args: &[Val]) -> Result { + let kernel = args.first().copied().unwrap_or(Val::UNIT); + let n_val = args.get(1).copied().unwrap_or(Val::UNIT); + + let (func_id, caps, name) = match self.get_obj(kernel) { + Some(Obj::Closure(f, c)) => { + let name = self + .module + .funcs + .get(f.0 as usize) + .and_then(|fun| fun.name.clone()); + (*f, c.clone(), name) + } + _ => { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "Place.run expects a kernel as its first argument, got {}", + self.val_to_string(kernel) + ))) + .with_span(self.current_span)) + } + }; + + if !n_val.is_int() || n_val.as_int() < 0 { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "Place.run expects a non-negative work count, got {}", + self.val_to_string(n_val) + ))) + .with_span(self.current_span)); + } + let n = n_val.as_int(); + + // Charge the launch before running, so a kernel that fails partway + // still shows up in the accounting. + self.place_stats.record(crate::eir::place::PlaceEvent { + kind: crate::eir::place::EventKind::Launch, + kernel: name, + arg: None, + dtype: None, + bytes: 0, + items: n as u64, + device: "cpu", + }); + + // Kernel arguments arrive as one vector rather than spread across the + // operation. That keeps the operation's own arity fixed at three, so a + // handler clause can bind and forward it — `[Place.run k n args]` — + // and, more usefully, can *inspect* the argument list. A residency + // policy is exactly a handler that looks at those arguments and + // decides which of them still need to move. + let args_val = args.get(2).copied().unwrap_or(Val::UNIT); + let rest: Vec = match self.get_obj(args_val) { + Some(Obj::Vec(v)) => v.iter().copied().collect(), + Some(Obj::Tuple(v)) => v.clone(), + _ if args.len() <= 2 => Vec::new(), + _ => { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "Place.run expects a vector of kernel arguments, got {}", + self.val_to_string(args_val) + ))) + .with_span(self.current_span)) + } + }; + let mut call_args = Vec::with_capacity(rest.len() + 1); + for i in 0..n { + call_args.clear(); + call_args.push(Val::int(i)); + call_args.extend_from_slice(&rest); + self.run_call_with_captures(func_id, &call_args, caps.clone())?; + } + Ok(Val::UNIT) + } + fn get_obj(&self, val: Val) -> Option<&Obj> { if val.is_ptr() { self.heap.get(val.as_ptr()) @@ -754,7 +1009,9 @@ impl Vm { self.func = frame.func; self.block = frame.block; self.ip = frame.ip; - self.regs[ret_reg as usize] = val; + if ret_reg != RET_DISCARD { + self.regs[ret_reg as usize] = val; + } // A resumed segment may have left ephemeral handlers scoped to a // prompt frame that is now gone; drop them so they cannot shadow a // later handle for the same effect. @@ -1455,10 +1712,168 @@ impl Vm { Some(Obj::Set(items)) => items.len() as i64, Some(Obj::Str(s)) => s.len() as i64, Some(Obj::Tuple(items)) => items.len() as i64, + // A buffer has a length like any other sequence. Falling + // through to 0 here made `[len buf]` a confident lie. + Some(Obj::Buffer(b)) => b.len() as i64, _ => 0, }; Ok(Val::int(len)) } + // ── Dense buffers ── + Built::BufNew | Built::BufNewI32 | Built::BufNewF64 => { + let dtype = match built { + Built::BufNewI32 => DType::I32, + Built::BufNewF64 => DType::F64, + _ => DType::F32, + }; + let src = args.first().copied().unwrap_or(Val::UNIT); + let items: Vec = match self.get_obj(src) { + Some(Obj::Vec(v)) => v.iter().copied().collect(), + Some(Obj::Tuple(v)) => v.clone(), + _ => { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "{} expects a vector of numbers, got {}", + match built { + Built::BufNewI32 => "buf-i32", + Built::BufNewF64 => "buf-f64", + _ => "buf", + }, + self.val_to_string(src) + )))) + } + }; + let mut buf = Buffer::zeros(dtype, items.len()); + for (i, v) in items.iter().enumerate() { + if !buf.set(i, *v) { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "buffer element {i} is not a number: {}", + self.val_to_string(*v) + )))); + } + } + Ok(self.alloc(Obj::Buffer(buf))) + } + Built::BufZeros | Built::BufZerosI32 => { + let dtype = if matches!(built, Built::BufZerosI32) { + DType::I32 + } else { + DType::F32 + }; + let n = args.first().copied().unwrap_or(Val::UNIT); + if !n.is_int() || n.as_int() < 0 { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "buffer length must be a non-negative integer, got {}", + self.val_to_string(n) + )))); + } + Ok(self.alloc(Obj::Buffer(Buffer::zeros(dtype, n.as_int() as usize)))) + } + Built::BufLen => { + let b = args.first().copied().unwrap_or(Val::UNIT); + match self.get_obj(b) { + Some(Obj::Buffer(buf)) => Ok(Val::int(buf.len() as i64)), + _ => Err(VmError::new(VmErrorKind::BuiltinType(format!( + "buf-len expects a buffer, got {}", + self.val_to_string(b) + )))), + } + } + Built::BufDtype => { + let b = args.first().copied().unwrap_or(Val::UNIT); + match self.get_obj(b) { + Some(Obj::Buffer(buf)) => { + let name = buf.dtype().name(); + Ok(self.alloc_str_owned(name.to_string())) + } + _ => Err(VmError::new(VmErrorKind::BuiltinType(format!( + "buf-dtype expects a buffer, got {}", + self.val_to_string(b) + )))), + } + } + Built::BufToVec => { + let b = args.first().copied().unwrap_or(Val::UNIT); + let items: Vec = match self.get_obj(b) { + Some(Obj::Buffer(buf)) => (0..buf.len()).filter_map(|i| buf.get(i)).collect(), + _ => { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "buf->vec expects a buffer, got {}", + self.val_to_string(b) + )))) + } + }; + Ok(self.alloc(Obj::Vec(items.into_iter().collect()))) + } + Built::BufAt => { + let b = args.first().copied().unwrap_or(Val::UNIT); + let i = args.get(1).copied().unwrap_or(Val::UNIT); + let Some(Obj::Buffer(buf)) = self.get_obj(b) else { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "at expects a buffer, got {}", + self.val_to_string(b) + )))); + }; + if !i.is_int() { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "at expects an integer index, got {}", + self.val_to_string(i) + )))); + } + let idx = i.as_int(); + let len = buf.len(); + match usize::try_from(idx).ok().and_then(|u| buf.get(u)) { + Some(v) => Ok(v), + None => Err(VmError::new(VmErrorKind::BuiltinType(format!( + "at: index {idx} is outside a buffer of length {len}" + )))), + } + } + Built::BufPut => { + // Writes through the buffer in place. Every other Loon + // collection is persistent; a buffer is not, because copying + // one per element write is exactly the cost buffers exist to + // avoid. The ownership pass is what keeps this honest — it + // reports a written-through parameter as `InOut`. + let b = args.first().copied().unwrap_or(Val::UNIT); + let i = args.get(1).copied().unwrap_or(Val::UNIT); + let x = args.get(2).copied().unwrap_or(Val::UNIT); + if !b.is_ptr() || !matches!(self.heap.get(b.as_ptr()), Some(Obj::Buffer(_))) { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "put expects a buffer, got {}", + self.val_to_string(b) + )))); + } + if !i.is_int() { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "put expects an integer index, got {}", + self.val_to_string(i) + )))); + } + let idx = i.as_int(); + let ptr = b.as_ptr(); + let len = match self.heap.get(ptr) { + Some(Obj::Buffer(buf)) => buf.len(), + _ => 0, + }; + let ok = usize::try_from(idx) + .ok() + .map(|u| match self.heap.get_mut(ptr) { + Some(Obj::Buffer(buf)) => buf.set(u, x), + _ => false, + }) + .unwrap_or(false); + if !ok { + let shown = self.val_to_string(x); + return Err(VmError::new(VmErrorKind::BuiltinType( + if idx < 0 || idx as usize >= len { + format!("put: index {idx} is outside a buffer of length {len}") + } else { + format!("put: {shown} is not a number") + }, + ))); + } + Ok(b) + } Built::SeqLen => { let v = args.first().copied().unwrap_or(Val::UNIT); let len = match self.get_obj(v) { @@ -3257,6 +3672,74 @@ impl Vm { // (value-or-"" lookup). The interpreter has no such ops — it hard // errors — so they were dropped for cross-backend conformance; // `Process.env` is the Option-returning form both backends share. + // ── Placement ── + // + // Reached only when no handler took the operation, so this is the + // default answer to "where does this run": right here, one work + // item at a time. A program that never mentions placement gets + // this; installing a handler is what changes the answer, and the + // program itself does not move. + ("Place", "run") => self.place_run_serial(args)?, + ("Place", "read") => { + // The one path from device-side data back to the host. It is + // an operation rather than a plain accessor so that a + // residency handler can see every synchronization point + // without the programmer having marked any of them — which is + // what the `Preload`/`PreloadMut` types in the Rust offload + // work exist to reconstruct. + let b = args.first().copied().unwrap_or(Val::UNIT); + let items: Vec = match self.get_obj(b) { + Some(Obj::Buffer(buf)) => { + let n = buf.len(); + let bytes = buf.byte_len() as u64; + let dtype = buf.dtype(); + let vals: Vec = (0..n).filter_map(|i| buf.get(i)).collect(); + self.place_stats.record(crate::eir::place::PlaceEvent { + kind: crate::eir::place::EventKind::Download, + kernel: None, + arg: None, + dtype: Some(dtype), + bytes, + items: 0, + device: "cpu", + }); + vals + } + _ => { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "Place.read expects a buffer, got {}", + self.val_to_string(b) + ))) + .with_span(self.current_span)) + } + }; + self.alloc(Obj::Vec(items.into_iter().collect())) + } + ("Place", "pin") | ("Place", "unpin") => { + // Running here, there is nowhere else for a buffer to be, so + // pinning is a no-op that returns the buffer unchanged. A + // device handler is where the hint means something. + args.first().copied().unwrap_or(Val::UNIT) + } + ("Place", "stats") => { + let s = &self.place_stats; + let pairs = [ + ("launches", s.launches as i64), + ("work-items", s.work_items as i64), + ("uploads", s.uploads as i64), + ("downloads", s.downloads as i64), + ("bytes-in", s.bytes_in as i64), + ("bytes-out", s.bytes_out as i64), + ("resident-hits", s.resident_hits as i64), + ]; + let mut map = ImMap::new(); + for (k, v) in pairs { + let key = self.intern_sym(k); + map.insert(key, Val::int(v)); + } + self.alloc(Obj::Map(map)) + } + // Real TCP/HTTP sockets (see eir/net.rs). A blocking one-at-a-time // server: listen a port, accept a request, send the response. ("Net", "listen") => { diff --git a/crates/loon-lang/src/errors/codes.rs b/crates/loon-lang/src/errors/codes.rs index 08223ec..55243d5 100644 --- a/crates/loon-lang/src/errors/codes.rs +++ b/crates/loon-lang/src/errors/codes.rs @@ -42,6 +42,10 @@ pub enum ErrorCode { E0501, // private symbol E0502, // circular dependency + // Placement errors + E0600, // construct not allowed inside a kernel + E0601, // kernel signature is not placeable + // Warnings W0100, // transparent wildcard } @@ -71,6 +75,8 @@ impl ErrorCode { ErrorCode::E0402 => "E0402", ErrorCode::E0403 => "E0403", ErrorCode::E0404 => "E0404", + ErrorCode::E0600 => "E0600", + ErrorCode::E0601 => "E0601", ErrorCode::E0500 => "E0500", ErrorCode::E0501 => "E0501", ErrorCode::E0502 => "E0502", @@ -102,6 +108,7 @@ impl ErrorCode { | ErrorCode::E0403 | ErrorCode::E0404 => "effect", ErrorCode::E0500 | ErrorCode::E0501 | ErrorCode::E0502 => "module", + ErrorCode::E0600 | ErrorCode::E0601 => "placement", ErrorCode::W0100 => "warning", } } @@ -130,6 +137,8 @@ impl ErrorCode { ErrorCode::E0402 => "unknown effect operation", ErrorCode::E0403 => "effect mismatch", ErrorCode::E0404 => "effect not granted", + ErrorCode::E0600 => "not allowed inside a kernel", + ErrorCode::E0601 => "kernel signature is not placeable", ErrorCode::E0500 => "unresolved module", ErrorCode::E0501 => "private symbol", ErrorCode::E0502 => "circular dependency", diff --git a/crates/loon-lang/src/errors/tutorials.rs b/crates/loon-lang/src/errors/tutorials.rs index 5ecc721..8b9c5ed 100644 --- a/crates/loon-lang/src/errors/tutorials.rs +++ b/crates/loon-lang/src/errors/tutorials.rs @@ -51,6 +51,7 @@ pub fn get_tutorial(code: ErrorCode) -> Option { ErrorCode::E0500 => Some(tutorial_unresolved_module()), ErrorCode::E0501 => Some(tutorial_private_symbol()), ErrorCode::E0502 => Some(tutorial_circular_dependency()), + ErrorCode::E0600 | ErrorCode::E0601 => None, ErrorCode::W0100 => None, // warnings don't need tutorials } } diff --git a/crates/loon-lang/tests/backend_parity.rs b/crates/loon-lang/tests/backend_parity.rs index 1cd2322..55e04ba 100644 --- a/crates/loon-lang/tests/backend_parity.rs +++ b/crates/loon-lang/tests/backend_parity.rs @@ -32,6 +32,22 @@ fn interp_output(src: &str) -> Result { /// result(s) so the comparison is on observable output. const CORPUS: &[(&str, &str)] = &[ ("arith", "[fn main [] [println [+ [* 6 7] [- 10 8]]]]"), + // Regression: a closure called by a higher-order builtin must not + // overwrite a binding in the caller. The VM re-enters itself to run the + // closure, and that re-entry used to name register 0 as the destination + // for the result — whatever the caller happened to be keeping there was + // silently replaced. Here `n` came back as 14, the last value `map` + // computed, instead of 8. + ( + "closure-call-preserves-caller-bindings", + "[fn main [] [let n 8] [let y [map [fn [v] [* 2 v]] [range 0 n]]] [println n] [println y]]", + ), + ( + "nested-closure-calls-preserve-bindings", + "[fn main [] [let a 1] [let b 2] \ + [let r [map [fn [v] [len [map [fn [w] [* w v]] [range 0 3]]]] [range 0 3]]] \ + [println [+ a b]] [println r]]", + ), ("float", "[fn main [] [println [* 2.0 3.5]]]"), ("strings", r#"[fn main [] [println [str "a" "-" 42 "-" "b"]]]"#), ("bool", "[fn main [] [println [and [> 3 2] [not [< 5 1]]]]]"), diff --git a/crates/loon-lang/tests/loon_os.rs b/crates/loon-lang/tests/loon_os.rs index 55ceb42..4227990 100644 --- a/crates/loon-lang/tests/loon_os.rs +++ b/crates/loon-lang/tests/loon_os.rs @@ -298,3 +298,52 @@ fn replay_needs_no_kernel_and_no_real_world() { .join("\n"); assert!(out.contains("GHOST MATCHES"), "{out}"); } + +#[test] +fn place_demo_gives_the_same_answer_under_every_handler() { + // The claim the demo exists to make: the program is untouched between + // runs, only the handler wrapped around it changes, and the computed + // result is identical in each case. A placement policy that changed the + // answer would not be a policy, it would be a bug. + let out = run_demo("demo-place.oo"); + let joined = out.join("\n"); + + let expected = "#[11 21 31 41 51 61 71 81]"; + let answers = out.iter().filter(|l| l.contains(expected)).count(); + assert_eq!( + answers, 3, + "unhandled, traced, and resident runs should all agree:\n{joined}" + ); + + // Tracing is interposition: the handler sees each launch and the single + // point where the host asks for data back. + assert!( + joined.contains("place: launch 8 work items, 3 args"), + "{joined}" + ); + assert!(joined.contains("place: sync"), "{joined}"); + + // The dry run accounts for the work without performing any of it, which is + // how a program can be exercised without the hardware it targets. + assert!( + joined.contains("#[]"), + "dry run should return nothing:\n{joined}" + ); +} + +#[test] +fn place_handlers_do_not_need_compiler_support() { + // Every handler in os/place.oo is ordinary Loon. This test pins that a + // policy can be written inline, in a test file, with no privileges: the + // residency and transfer-hoisting logic a GPU compiler implements as an + // optimization pass is expressible as user code here. + let out = run("[kernel k [i b] [put b i [* 2.0 [at b i]]]] \ + [fn work [] [let mut b [buf #[1 2 3]]] [Place.run k 3 #[b]] [Place.read b]] \ + [fn twice-as-many [thunk] \ + [handle [thunk] \ + [Place.run kf n args] [do [Place.run kf n args] \ + [resume [Place.run kf n args]]]]] \ + [fn main [] [IO.println [work]] [IO.println [twice-as-many work]]]"); + // Running the kernel twice per launch really does double it again. + assert_eq!(out, vec!["#[2 4 6]", "#[4 8 12]"]); +} diff --git a/crates/loon-lang/tests/place_effect.rs b/crates/loon-lang/tests/place_effect.rs new file mode 100644 index 0000000..0790eaf --- /dev/null +++ b/crates/loon-lang/tests/place_effect.rs @@ -0,0 +1,207 @@ +//! Placement is an effect, so a handler decides where a kernel runs. +//! +//! These tests pin the three claims that make that more than a slogan: +//! a program that never mentions placement still runs; a handler can observe +//! and redirect every launch without the program changing; and the direction +//! data has to travel is inferred from the kernel rather than annotated. + +use loon_lang::eir::vm::eval_eir; + +fn run(src: &str) -> Vec { + match eval_eir(src) { + Ok(r) => r.output, + Err(e) => panic!("VM error: {e:?}\nsource:\n{src}"), + } +} + +fn run_err(src: &str) -> String { + match eval_eir(src) { + Ok(r) => panic!("expected an error, got output {:?}", r.output), + Err(e) => format!("{e:?}"), + } +} + +const SAXPY: &str = "[kernel saxpy [i a x y out] \ + [put out i [+ [* a [at x i]] [at y i]]]]"; + +#[test] +fn a_kernel_runs_with_no_handler_at_all() { + // The default answer to "where does this run" is "here". A program that + // never mentions placement is still a working program. + let out = run(&format!( + "{SAXPY} \ + [fn main [] \ + [let x [buf #[1 2 3]]] \ + [let y [buf #[10 20 30]]] \ + [let mut out [buf-zeros 3]] \ + [Place.run saxpy 3 #[2.0 x y out]] \ + [IO.println [Place.read out]]]" + )); + assert_eq!(out, vec!["#[12 24 36]"]); +} + +#[test] +fn a_handler_sees_every_launch_and_every_sync_point() { + // This is the whole argument. The Rust offload work needs `Preload` and + // `PreloadMut` types, whose `drop` marks where device data becomes visible + // to the host, because nothing else in the language knows. Here every + // launch and every read is an operation, so a handler learns the same + // facts without the program being annotated at all — and a residency + // policy is therefore writable as ordinary code. + let out = run(&format!( + "{SAXPY} \ + [fn work [] \ + [let x [buf #[1 2 3]]] \ + [let y [buf #[10 20 30]]] \ + [let mut out [buf-zeros 3]] \ + [Place.run saxpy 3 #[2.0 x y out]] \ + [Place.read out]] \ + [fn traced [thunk] \ + [handle [thunk] \ + [Place.run k n args] [do [IO.println \"launch\"] \ + [resume [Place.run k n args]]] \ + [Place.read b] [do [IO.println \"sync\"] \ + [resume [Place.read b]]]]] \ + [fn main [] [IO.println [traced work]]]" + )); + assert_eq!(out, vec!["launch", "sync", "#[12 24 36]"]); +} + +#[test] +fn a_handler_can_answer_without_running_anything() { + // A handler is free not to forward. Answering from a recording — or from + // a simulated device — is the same shape as answering for real, which is + // why a program can be tested without the hardware it targets. + let out = run(&format!( + "{SAXPY} \ + [fn work [] \ + [let x [buf #[1 2 3]]] \ + [let mut out [buf-zeros 3]] \ + [Place.run saxpy 3 #[2.0 x x out]] \ + [Place.read out]] \ + [fn canned [thunk] \ + [handle [thunk] \ + [Place.run k n args] [resume []] \ + [Place.read b] [resume #[99 99 99]]]] \ + [fn main [] [IO.println [canned work]]]" + )); + assert_eq!(out, vec!["#[99 99 99]"]); +} + +#[test] +fn the_program_is_identical_under_every_handler() { + // `work` is one function. What changes between these runs is the line that + // wraps it, never the code that does the work. + let common = format!( + "{SAXPY} \ + [fn work [] \ + [let x [buf #[1 2 3]]] \ + [let y [buf #[10 20 30]]] \ + [let mut out [buf-zeros 3]] \ + [Place.run saxpy 3 #[2.0 x y out]] \ + [Place.read out]] \ + [fn counted [thunk] \ + [handle [thunk] \ + [Place.run k n args] [do [IO.println \"one launch\"] \ + [resume [Place.run k n args]]]]]" + ); + let bare = run(&format!("{common} [fn main [] [IO.println [work]]]")); + let wrapped = run(&format!( + "{common} [fn main [] [IO.println [counted work]]]" + )); + + assert_eq!(bare, vec!["#[12 24 36]"]); + assert_eq!(wrapped, vec!["one launch", "#[12 24 36]"]); +} + +#[test] +fn transfer_accounting_counts_what_crossed_the_boundary() { + // The number that matters in an offload program is how many times bytes + // moved. Making it observable is what lets a residency policy be checked + // rather than assumed. + let out = run(&format!( + "{SAXPY} \ + [fn main [] \ + [let x [buf #[1 2 3 4]]] \ + [let mut out [buf-zeros 4]] \ + [Place.run saxpy 4 #[1.0 x x out]] \ + [Place.run saxpy 4 #[1.0 x x out]] \ + [let _ [Place.read out]] \ + [let s [Place.stats]] \ + [IO.println [get s :launches]] \ + [IO.println [get s :work-items]] \ + [IO.println [get s :downloads]] \ + [IO.println [get s :bytes-out]]]" + )); + // Two launches of four items each, and exactly one read back: 4 f32 = 16 B. + assert_eq!(out, vec!["2", "8", "1", "16"]); +} + +#[test] +fn a_kernel_only_reading_a_buffer_infers_an_input() { + // Direction comes from the body. `x` and `y` are read with `at`, `out` is + // written with `put`; nobody wrote `&` or `&mut` anywhere. + use loon_lang::check::kernel; + use loon_lang::check::ownership::{infer_param_modes, ParamMode}; + let exprs = loon_lang::parser::parse(SAXPY).expect("parses"); + // Kernels are ordinary functions by the time anything analyzes them, which + // is why they get ownership modes at all. + let (desugared, names) = kernel::desugar(&exprs); + assert!(names.contains("saxpy")); + let modes = infer_param_modes(&desugared); + assert_eq!( + modes.get("saxpy").expect("saxpy has modes"), + &vec![ + ParamMode::Borrow, // i + ParamMode::Borrow, // a + ParamMode::Borrow, // x — input + ParamMode::Borrow, // y — input + ParamMode::MutBorrow, // out — must be synchronized back + ] + ); +} + +#[test] +fn reading_past_the_end_of_a_buffer_is_an_error() { + // A device that answers zero for an out-of-range read teaches you to trust + // an answer it invented. This one says so instead. + let err = run_err("[fn main [] [let b [buf #[1 2 3]]] [IO.println [at b 7]]]"); + assert!( + err.contains("outside a buffer"), + "expected an out-of-range error, got: {err}" + ); +} + +#[test] +fn placing_something_that_is_not_a_kernel_is_an_error() { + let err = run_err("[fn main [] [Place.run 42 3]]"); + assert!( + err.contains("expects a kernel"), + "expected a kernel-shape error, got: {err}" + ); +} + +#[test] +fn a_negative_work_count_is_an_error() { + let err = run_err(&format!( + "{SAXPY} \ + [fn main [] \ + [let x [buf #[1]]] [let mut o [buf-zeros 1]] \ + [Place.run saxpy -1 #[1.0 x x o]]]" + )); + assert!( + err.contains("work count"), + "expected a work-count error, got: {err}" + ); +} + +#[test] +fn buffers_round_trip_through_every_element_type() { + let out = run("[fn main [] \ + [IO.println [buf-dtype [buf #[1 2]]]] \ + [IO.println [buf-dtype [buf-i32 #[1 2]]]] \ + [IO.println [buf-dtype [buf-f64 #[1 2]]]] \ + [IO.println [buf->vec [buf-i32 #[1 2 3]]]] \ + [IO.println [buf-len [buf-zeros 5]]]]"); + assert_eq!(out, vec!["f32", "i32", "f64", "#[1 2 3]", "5"]); +} diff --git a/os/demo-place.oo b/os/demo-place.oo new file mode 100644 index 0000000..ef38c8e --- /dev/null +++ b/os/demo-place.oo @@ -0,0 +1,39 @@ +; Demo: one program, four answers to "where does this run". +; +; `blur` and `work` never mention a device, a queue, or a transfer. The only +; thing that changes between the runs below is which handler is wrapped around +; the same thunk — and the answer is identical every time. +; +; loon run os/demo-place.oo +[use place] + +; A two-kernel chain. Chains are where placement policy earns its keep: the +; intermediate never needs to come back to the host, and only a handler is in +; a position to know that. +[kernel scale [i s src dst] + [put dst i [* s [at src i]]]] + +[kernel offset [i d buf] + [put buf i [+ d [at buf i]]]] + +[fn work [] + [let src [buf #[1 2 3 4 5 6 7 8]]] + [let mut dst [buf-zeros 8]] + [Place.run scale 8 #[10.0 src dst]] + [Place.run offset 8 #[1.0 dst]] + [Place.read dst]] + +[fn main [] + [IO.println "no handler — it runs right here:"] + [IO.println [str " " [work]]] + + [IO.println "traced — every launch and sync is visible:"] + [IO.println [str " " [place/trace work]]] + + [IO.println "dry run — accounted for, nothing executed:"] + [IO.println [str " " [place/dry-run work]]] + + [IO.println "resident — buffers stay put between launches:"] + [IO.println [str " " [place/resident work]]] + + [IO.println [str "totals: " [Place.stats]]]] diff --git a/os/place.oo b/os/place.oo new file mode 100644 index 0000000..a4b76f1 --- /dev/null +++ b/os/place.oo @@ -0,0 +1,74 @@ +; Placement handlers. +; +; `Place` is an effect, so where a kernel runs is decided by whoever is +; handling it — not by the program, and not by a compiler flag baked into the +; build. Everything in this file is ordinary Loon: no compiler support, no +; intrinsics, nothing the language does not already give you for any other +; effect. That is the point being made. The transfer-hoisting and residency +; policies that a GPU offload compiler implements as optimization passes are +; here, as library code you can read in one sitting and change without +; rebuilding a compiler. +; +; Each handler wraps a thunk and returns its value: +; +; [place/trace work] ; watch what happens +; [place/resident work] ; keep buffers where they are +; [place/dry-run work] ; account for it, run nothing + +; ── Watching ──────────────────────────────────────────────────────────────── + +; strace, for placement. Forwards every operation outward unchanged and prints +; what went past. The whole of "GPU tracing" is a handler that performs the +; same operation it intercepted. +[fn place/trace [thunk] + [handle [thunk] + [Place.run k n args] + [do [IO.println [str "place: launch " n " work items, " [len args] " args"]] + [resume [Place.run k n args]]] + [Place.read b] + [do [IO.println [str "place: sync — reading " [buf-len b] " elements back"]] + [resume [Place.read b]]]]] + +; Count launches and syncs without printing anything. Returns the thunk's +; value; ask `Place.stats` afterwards for the totals. +[fn place/counted [thunk] + [handle [thunk] + [Place.run k n args] [resume [Place.run k n args]] + [Place.read b] [resume [Place.read b]]]] + +; ── Accounting without running ────────────────────────────────────────────── + +; Answer every launch by doing nothing, and every read with an empty vector. +; The program runs to completion and its placement decisions are counted, but +; no kernel executes. This is how you ask "what would this cost" — and how a +; program targeting hardware you do not have can still be exercised. +[fn place/dry-run [thunk] + [handle [thunk] + [Place.run k n args] [resume []] + [Place.read b] [resume #[]]]] + +; ── Residency ─────────────────────────────────────────────────────────────── + +; Keep buffers where they are across launches, and only synchronize when the +; host actually looks. +; +; This is the handler that closes the gap a recent Rust offload paper measured +; at up to 400x between its convenient interface and its explicit one. There, +; closing it needed `Preload`/`PreloadMut` types written by the programmer at +; every call site, plus a transfer-hoisting pass inside LLVM that the authors +; describe as a prototype. Here it is a `handle` form, because the sync points +; are already visible: `Place.read` is an operation, so the handler knows +; exactly when the host wants an answer and can decline to move bytes until +; then. +; +; With the serial CPU backend there is nowhere else for a buffer to be, so this +; handler is a pass-through that reports the residency it would have exploited. +; The policy is the part worth having in the language; the device is the part +; that changes underneath it. +[fn place/resident [thunk] + [handle [thunk] + [Place.run k n args] + [do [Place.pin args] + [resume [Place.run k n args]]] + [Place.read b] + [resume [Place.read b]]]] diff --git a/samples/place/saxpy.oo b/samples/place/saxpy.oo new file mode 100644 index 0000000..ef5ffe8 --- /dev/null +++ b/samples/place/saxpy.oo @@ -0,0 +1,24 @@ +; saxpy: out[i] = a * x[i] + y[i] +; +; Nothing in this program says where the work happens. `Place.run` is an +; effect; with no handler installed it runs serially on this CPU. Install a +; handler and the same source runs somewhere else — that is the whole idea. +; +; Note what is *not* written anywhere: which buffers travel to the device and +; which have to come back. Loon infers that. `x` and `y` are only ever read +; (`at`), so they are inputs; `out` is written through (`put`), so it is the +; one that has to be synchronized back. + +[kernel saxpy [i a x y out] + [put out i [+ [* a [at x i]] [at y i]]]] + +[fn main [] + [let n 8] + [let x [buf [range 0 n]]] + [let y [buf [map [fn [v] [* 2 v]] [range 0 n]]]] + [let mut out [buf-zeros n]] + + [Place.run saxpy n #[3.0 x y out]] + + [IO.println [str "out = " [Place.read out]]] + [IO.println [str "stats = " [Place.stats]]]] From 588eaad55770d1b123ab0e0de5da548efa963040 Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 10:53:55 -0400 Subject: [PATCH 03/25] A device to place things on, and a handler that decides what moves MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `--place device` gives buffers a memory of their own. The arithmetic still happens on the host — this is not a GPU yet — but the bookkeeping is real: a buffer must be uploaded before a kernel can use it, results must come back before the host can read them, and nothing survives a launch unless somebody says it should. That last part is what makes the default honest. A device that has not been told a buffer will be wanted again does not keep it. Saying so is `Place.pin`, and that is the entire vocabulary a residency policy needs: [fn place/resident [thunk] [handle [thunk] [Place.run k n args] [do [Place.pin args] [resume [Place.run k n args]]] [Place.read b] [do [let v [Place.read b]] [Place.unpin b] [resume v]]]] Eight launches over one buffer, measured by os/demo-residency.oo: no policy: uploads 8, resident hits 0, bytes in 128 place/resident: uploads 1, resident hits 7, bytes in 16 Same program, same answer. The Rust offload paper measures this same gap at up to 400x and closes it with `Preload`/`PreloadMut` types at every call site plus a transfer-hoisting pass inside LLVM that is still a prototype. The information that pass tries to recover is already in the program here: `Place.run` says what a launch touches and `Place.read` says when the host wants an answer, so a handler can act on it. Pinning deliberately does not mark a buffer resident. It says "keep this once it is here", not "it is here already", so the first launch still pays for the upload — otherwise a policy would look free in the accounting by declaring itself so, which flatters a design instead of testing it. Also: --place-stats prints the transfer table, and place/resident-only takes the buffers to keep as an argument, for the case the paper flags as needing a heuristic it did not ship. Co-Authored-By: Claude Fable 5 --- crates/loon-cli/src/main.rs | 49 +++++++- crates/loon-lang/src/eir/place.rs | 153 ++++++++++++++++++++++++ crates/loon-lang/src/eir/vm.rs | 159 ++++++++++++++++++++++--- crates/loon-lang/tests/loon_os.rs | 45 +++++++ crates/loon-lang/tests/place_effect.rs | 108 +++++++++++++++++ os/demo-residency.oo | 56 +++++++++ os/place.oo | 34 ++++-- 7 files changed, 577 insertions(+), 27 deletions(-) create mode 100644 os/demo-residency.oo diff --git a/crates/loon-cli/src/main.rs b/crates/loon-cli/src/main.rs index 2eb4c4d..d566ef3 100644 --- a/crates/loon-cli/src/main.rs +++ b/crates/loon-cli/src/main.rs @@ -39,6 +39,13 @@ enum Command { /// (Loon data format), for `loon replay` #[arg(long, value_name = "TRACE")] record: Option, + /// Where kernels run when nothing handles `Place`: `cpu` (one memory, + /// no transfers) or `device` (separate memory, transfers accounted) + #[arg(long, value_name = "MODE", default_value = "cpu")] + place: String, + /// Print placement accounting — launches, transfers, bytes — on exit + #[arg(long)] + place_stats: bool, }, /// Re-run a program feeding recorded effect results back from a trace /// (see `loon run --record`) — same trace, same execution, same crash @@ -163,7 +170,29 @@ fn main() { legacy, native, ref record, + ref place, + place_stats, } => { + let place_mode = match loon_lang::eir::place::Mode::parse(place) { + Some(m) => m, + None => { + eprintln!( + "{}: unknown placement mode '{place}' — expected 'cpu' or 'device'", + "error".red().bold() + ); + std::process::exit(1); + } + }; + if (place_mode != loon_lang::eir::place::Mode::Cpu || place_stats) + && (wasm || legacy || native) + { + eprintln!( + "{}: --place/--place-stats require the default EIR VM backend \ + (drop --wasm/--legacy/--native)", + "error".red().bold() + ); + std::process::exit(1); + } if record.is_some() && (wasm || legacy || native) { eprintln!( "{}: --record requires the default EIR VM backend \ @@ -179,7 +208,7 @@ fn main() { } else if legacy { run_file_legacy(file); } else { - run_file(file, record.as_deref()); + run_file(file, record.as_deref(), place_mode, place_stats); } } Command::Replay { @@ -268,7 +297,12 @@ fn precheck_source(path: &std::path::Path, source: &str) { } } -fn run_file(path: &PathBuf, record: Option<&std::path::Path>) { +fn run_file( + path: &PathBuf, + record: Option<&std::path::Path>, + place_mode: loon_lang::eir::place::Mode, + show_place_stats: bool, +) { let source = match std::fs::read_to_string(path) { Ok(s) => s, Err(e) => { @@ -384,6 +418,17 @@ fn run_file(path: &PathBuf, record: Option<&std::path::Path>) { } r } + None if place_mode != loon_lang::eir::place::Mode::Cpu || show_place_stats => { + match loon_lang::eir::vm::eval_eir_placed(&source, base_dir, place_mode) { + Ok((r, stats)) => { + if show_place_stats { + print!("{}", stats.table()); + } + Ok(r) + } + Err(e) => Err(e), + } + } None => loon_lang::eir::vm::eval_eir_with_base_dir(&source, base_dir), }; match result { diff --git a/crates/loon-lang/src/eir/place.rs b/crates/loon-lang/src/eir/place.rs index 6a9bb19..a3fac36 100644 --- a/crates/loon-lang/src/eir/place.rs +++ b/crates/loon-lang/src/eir/place.rs @@ -135,6 +135,119 @@ impl PlaceStats { } } +// ─── A device with its own memory ────────────────────────────────────────── + +/// Where kernels run. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub enum Mode { + /// Right here. There is one memory, so nothing is ever transferred. + #[default] + Cpu, + /// A discrete device with separate memory. + /// + /// The arithmetic still happens on the host — this is not a GPU — but the + /// *bookkeeping* is real: a buffer must be uploaded before a kernel can + /// use it, and results must be downloaded before the host can read them. + /// That makes the cost of a placement policy measurable, and measurable is + /// the whole argument. A policy whose benefit you cannot count is a story. + Device, +} + +impl Mode { + pub fn parse(s: &str) -> Option { + match s { + "cpu" | "serial" | "here" => Some(Mode::Cpu), + "device" | "sim" => Some(Mode::Device), + _ => None, + } + } + + pub fn name(self) -> &'static str { + match self { + Mode::Cpu => "cpu", + Mode::Device => "device", + } + } +} + +/// Device-side memory: which buffers are resident, and which hold results the +/// host has not seen yet. +/// +/// Buffers are identified by their heap slot. Nothing is copied — the point is +/// to account for the copies a real device would need, not to simulate its +/// arithmetic. +#[derive(Debug, Clone, Default)] +pub struct Device { + resident: std::collections::HashSet, + dirty: std::collections::HashSet, + /// Buffers a handler asked to keep resident across launches. + pinned: std::collections::HashSet, +} + +impl Device { + pub fn is_resident(&self, id: usize) -> bool { + self.resident.contains(&id) + } + + pub fn is_dirty(&self, id: usize) -> bool { + self.dirty.contains(&id) + } + + pub fn is_pinned(&self, id: usize) -> bool { + self.pinned.contains(&id) + } + + pub fn mark_resident(&mut self, id: usize) { + self.resident.insert(id); + } + + pub fn mark_dirty(&mut self, id: usize) { + self.dirty.insert(id); + } + + pub fn clear_dirty(&mut self, id: usize) { + self.dirty.remove(&id); + } + + /// Ask that a buffer survive eviction. + /// + /// Deliberately does *not* make it resident: pinning says "keep this once + /// it is here", not "it is here already". The first launch that uses it + /// still pays for the upload. Otherwise a residency policy would look free + /// in the accounting by declaring itself so, which is exactly the kind of + /// measurement that flatters a design instead of testing it. + pub fn pin(&mut self, id: usize) { + self.pinned.insert(id); + } + + pub fn unpin(&mut self, id: usize) { + self.pinned.remove(&id); + } + + /// Drop every unpinned buffer. + /// + /// This is what makes a transfer-per-launch policy the *default* rather + /// than a strawman: without someone deciding otherwise, the device does + /// not assume a buffer will be wanted again. Deciding otherwise is exactly + /// what a residency handler does, and pinning is how it says so. + pub fn evict_unpinned(&mut self) -> Vec { + let evicted: Vec = self + .resident + .iter() + .copied() + .filter(|id| !self.pinned.contains(id)) + .collect(); + for id in &evicted { + self.resident.remove(id); + } + evicted + } + + pub fn resident_count(&self) -> usize { + self.resident.len() + } +} + /// Bytes in a unit a person can read at a glance. pub fn human_bytes(n: u64) -> String { const KB: u64 = 1024; @@ -155,6 +268,46 @@ pub fn human_bytes(n: u64) -> String { mod tests { use super::*; + #[test] + fn pinning_does_not_make_a_buffer_resident_for_free() { + // The first use still has to upload it; pinning only says it should + // stay afterwards. + let mut d = Device::default(); + d.pin(3); + assert!(!d.is_resident(3), "pinning is not a transfer"); + } + + #[test] + fn an_unpinned_buffer_does_not_survive_a_launch() { + let mut d = Device::default(); + d.mark_resident(1); + d.mark_resident(2); + d.pin(2); + let evicted = d.evict_unpinned(); + assert_eq!(evicted, vec![1]); + assert!(!d.is_resident(1), "unpinned buffers are dropped"); + assert!(d.is_resident(2), "pinned buffers stay"); + } + + #[test] + fn unpinning_lets_a_buffer_be_evicted_again() { + let mut d = Device::default(); + d.mark_resident(7); + d.pin(7); + assert!(d.evict_unpinned().is_empty()); + d.unpin(7); + assert_eq!(d.evict_unpinned(), vec![7]); + } + + #[test] + fn mode_names_round_trip() { + for m in [Mode::Cpu, Mode::Device] { + assert_eq!(Mode::parse(m.name()), Some(m)); + } + assert_eq!(Mode::parse("sim"), Some(Mode::Device)); + assert_eq!(Mode::parse("nonsense"), None); + } + fn ev(kind: EventKind, bytes: u64, items: u64) -> PlaceEvent { PlaceEvent { kind, diff --git a/crates/loon-lang/src/eir/vm.rs b/crates/loon-lang/src/eir/vm.rs index d4eec8f..e8c4ccc 100644 --- a/crates/loon-lang/src/eir/vm.rs +++ b/crates/loon-lang/src/eir/vm.rs @@ -422,6 +422,10 @@ pub struct Vm { output: Vec, /// Placement accounting: launches, transfers, and residency hits. pub place_stats: crate::eir::place::PlaceStats, + /// Where kernels run when nothing handles `Place`. + pub place_mode: crate::eir::place::Mode, + /// Device-side residency, when running in device mode. + place_device: crate::eir::place::Device, /// String constants resolved to heap indices. string_cache: HashMap, /// Interns string *objects* by content, so structurally-equal strings share @@ -527,6 +531,8 @@ impl Vm { current_span: Span::ZERO, heap_stats: HeapStats::default(), place_stats: crate::eir::place::PlaceStats::default(), + place_mode: crate::eir::place::Mode::default(), + place_device: crate::eir::place::Device::default(), recorder: None, replay: None, runtime_syms: Vec::new(), @@ -749,7 +755,7 @@ impl Vm { dtype: None, bytes: 0, items: n as u64, - device: "cpu", + device: self.place_mode.name(), }); // Kernel arguments arrive as one vector rather than spread across the @@ -771,6 +777,40 @@ impl Vm { .with_span(self.current_span)) } }; + // In device mode, every buffer argument has to be on the device before + // the kernel can touch it. An argument that is already resident costs + // nothing — and counting those hits is what turns a residency policy + // from a claim into a measurement. + if self.place_mode == crate::eir::place::Mode::Device { + for (i, arg) in rest.iter().enumerate() { + let Some((id, bytes, dtype)) = self.buffer_info(*arg) else { + continue; + }; + if self.place_device.is_resident(id) { + self.place_stats.record(crate::eir::place::PlaceEvent { + kind: crate::eir::place::EventKind::ResidentHit, + kernel: None, + arg: Some(i as u16), + dtype: Some(dtype), + bytes: 0, + items: 0, + device: "device", + }); + } else { + self.place_device.mark_resident(id); + self.place_stats.record(crate::eir::place::PlaceEvent { + kind: crate::eir::place::EventKind::Upload, + kernel: None, + arg: Some(i as u16), + dtype: Some(dtype), + bytes, + items: 0, + device: "device", + }); + } + } + } + let mut call_args = Vec::with_capacity(rest.len() + 1); for i in 0..n { call_args.clear(); @@ -778,9 +818,32 @@ impl Vm { call_args.extend_from_slice(&rest); self.run_call_with_captures(func_id, &call_args, caps.clone())?; } + + // Whatever the kernel wrote now differs from the host's copy, and an + // unpinned buffer does not survive to the next launch. Both of those + // are the *default* behaviour of a device that has not been told + // anything — which is precisely what a residency handler exists to + // change, by pinning what it knows will be wanted again. + if self.place_mode == crate::eir::place::Mode::Device { + for arg in &rest { + if let Some((id, _, _)) = self.buffer_info(*arg) { + self.place_device.mark_dirty(id); + } + } + self.place_device.evict_unpinned(); + } + Ok(Val::UNIT) } + /// Heap slot, byte length, and element type of a buffer value. + fn buffer_info(&self, val: Val) -> Option<(usize, u64, DType)> { + match self.get_obj(val) { + Some(Obj::Buffer(b)) => Some((val.as_ptr(), b.byte_len() as u64, b.dtype())), + _ => None, + } + } + fn get_obj(&self, val: Val) -> Option<&Obj> { if val.is_ptr() { self.heap.get(val.as_ptr()) @@ -3693,16 +3756,28 @@ impl Vm { let n = buf.len(); let bytes = buf.byte_len() as u64; let dtype = buf.dtype(); + let id = b.as_ptr(); let vals: Vec = (0..n).filter_map(|i| buf.get(i)).collect(); - self.place_stats.record(crate::eir::place::PlaceEvent { - kind: crate::eir::place::EventKind::Download, - kernel: None, - arg: None, - dtype: Some(dtype), - bytes, - items: 0, - device: "cpu", - }); + // On a device, a read costs a transfer only when the + // device holds something the host has not seen. On the + // CPU there is one memory, so the read is free — and + // saying so keeps the two modes comparable. + let must_transfer = match self.place_mode { + crate::eir::place::Mode::Cpu => true, + crate::eir::place::Mode::Device => self.place_device.is_dirty(id), + }; + if must_transfer { + self.place_device.clear_dirty(id); + self.place_stats.record(crate::eir::place::PlaceEvent { + kind: crate::eir::place::EventKind::Download, + kernel: None, + arg: None, + dtype: Some(dtype), + bytes, + items: 0, + device: self.place_mode.name(), + }); + } vals } _ => { @@ -3716,10 +3791,34 @@ impl Vm { self.alloc(Obj::Vec(items.into_iter().collect())) } ("Place", "pin") | ("Place", "unpin") => { - // Running here, there is nowhere else for a buffer to be, so - // pinning is a no-op that returns the buffer unchanged. A - // device handler is where the hint means something. - args.first().copied().unwrap_or(Val::UNIT) + // Pinning says "this buffer will be wanted again, keep it". + // It is the whole vocabulary a residency policy needs, and it + // is available to any handler — no compiler pass required. + // + // Accepts a buffer or a vector of them, so a handler can pin a + // kernel's entire argument list in one operation. + let target = args.first().copied().unwrap_or(Val::UNIT); + if self.place_mode == crate::eir::place::Mode::Device { + let pinning = op == "pin"; + let ids: Vec = match self.get_obj(target) { + Some(Obj::Vec(v)) => v + .iter() + .filter(|x| x.is_ptr()) + .filter(|x| matches!(self.heap.get(x.as_ptr()), Some(Obj::Buffer(_)))) + .map(|x| x.as_ptr()) + .collect(), + Some(Obj::Buffer(_)) => vec![target.as_ptr()], + _ => Vec::new(), + }; + for id in ids { + if pinning { + self.place_device.pin(id); + } else { + self.place_device.unpin(id); + } + } + } + target } ("Place", "stats") => { let s = &self.place_stats; @@ -3731,6 +3830,10 @@ impl Vm { ("bytes-in", s.bytes_in as i64), ("bytes-out", s.bytes_out as i64), ("resident-hits", s.resident_hits as i64), + ( + "resident-buffers", + self.place_device.resident_count() as i64, + ), ]; let mut map = ImMap::new(); for (k, v) in pairs { @@ -4066,6 +4169,34 @@ pub fn eval_eir_with_base_dir(src: &str, base_dir: &std::path::Path) -> Result Result<(VmResult, crate::eir::place::PlaceStats), VmError> { + let mut checker = crate::check::Checker::with_base_dir(base_dir); + let exprs = crate::parser::parse(src).map_err(|e| VmError { + kind: VmErrorKind::Trap, + span: Some(e.span), + context: Some(format!("parse error: {}", e.message)), + })?; + let errors = checker.check_program(&exprs); + if let Some(e) = module_error(&errors) { + return Err(e); + } + let module = crate::eir::lower::lower(&checker); + let mut vm = Vm::new(module); + vm.place_mode = mode; + let result = vm.run()?; + Ok((result, vm.place_stats.clone())) +} + fn eval_eir_impl(src: &str, mut checker: crate::check::Checker) -> Result { let exprs = crate::parser::parse(src).map_err(|e| VmError { kind: VmErrorKind::Trap, diff --git a/crates/loon-lang/tests/loon_os.rs b/crates/loon-lang/tests/loon_os.rs index 4227990..7ce604b 100644 --- a/crates/loon-lang/tests/loon_os.rs +++ b/crates/loon-lang/tests/loon_os.rs @@ -347,3 +347,48 @@ fn place_handlers_do_not_need_compiler_support() { // Running the kernel twice per launch really does double it again. assert_eq!(out, vec!["#[2 4 6]", "#[4 8 12]"]); } + +#[test] +fn residency_demo_closes_the_transfer_gap() { + // The demo's whole claim, checked: the same eight-launch chain pays eight + // uploads with no policy and one upload under a residency handler, and + // both runs produce the same answer. This is the gap a GPU offload + // compiler needs a dedicated optimization pass to close. + let path = os_dir().join("demo-residency.oo"); + let src = std::fs::read_to_string(&path).expect("read demo-residency.oo"); + let (result, _stats) = + loon_lang::eir::vm::eval_eir_placed(&src, &os_dir(), loon_lang::eir::place::Mode::Device) + .expect("demo runs"); + let joined = result.output.join("\n"); + + assert!( + joined.contains("no policy: uploads 8, resident hits 0"), + "without a policy every launch transfers:\n{joined}" + ); + assert!( + joined.contains("place/resident: uploads 1, resident hits 7"), + "the handler should upload once and hit seven times:\n{joined}" + ); + assert_eq!( + result + .output + .iter() + .filter(|l| l.contains("#[8 8 8 8]")) + .count(), + 2, + "both runs must compute the same answer:\n{joined}" + ); +} + +#[test] +fn on_the_cpu_the_residency_demo_moves_nothing() { + // Same program, same handler, one memory: the policy is simply describing + // a distinction this hardware does not have, and costs nothing to keep. + let path = os_dir().join("demo-residency.oo"); + let src = std::fs::read_to_string(&path).expect("read demo-residency.oo"); + let (_, stats) = + loon_lang::eir::vm::eval_eir_placed(&src, &os_dir(), loon_lang::eir::place::Mode::Cpu) + .expect("demo runs"); + assert_eq!(stats.uploads, 0, "the CPU has nothing to upload to"); + assert_eq!(stats.launches, 16); +} diff --git a/crates/loon-lang/tests/place_effect.rs b/crates/loon-lang/tests/place_effect.rs index 0790eaf..5e644b4 100644 --- a/crates/loon-lang/tests/place_effect.rs +++ b/crates/loon-lang/tests/place_effect.rs @@ -205,3 +205,111 @@ fn buffers_round_trip_through_every_element_type() { [IO.println [buf-len [buf-zeros 5]]]]"); assert_eq!(out, vec!["f32", "i32", "f64", "#[1 2 3]", "5"]); } + +// ── Residency: the gap a handler closes ───────────────────────────────────── + +/// Run in device mode, where buffers live in a separate memory and transfers +/// are counted. +fn run_on_device(src: &str) -> loon_lang::eir::place::PlaceStats { + let dir = std::env::current_dir().expect("cwd"); + match loon_lang::eir::vm::eval_eir_placed(src, &dir, loon_lang::eir::place::Mode::Device) { + Ok((_, stats)) => stats, + Err(e) => panic!("VM error: {e:?}\nsource:\n{src}"), + } +} + +/// A chain of `n` launches over the same buffer, optionally wrapped in a +/// handler. The program text is identical either way. +fn chain_program(launches: usize, wrapper: Option<&str>) -> String { + let runs = (0..launches) + .map(|_| "[Place.run step 4 #[1.0 b]]".to_string()) + .collect::>() + .join(" "); + let call = match wrapper { + Some(w) => format!("[{w} work]"), + None => "[work]".to_string(), + }; + format!( + "[kernel step [i s b] [put b i [* s [at b i]]]] \ + [fn work [] [let mut b [buf #[1 2 3 4]]] {runs} [Place.read b]] \ + [fn resident [thunk] \ + [handle [thunk] \ + [Place.run k n args] [do [Place.pin args] [resume [Place.run k n args]]] \ + [Place.read b] [resume [Place.read b]]]] \ + [fn main [] [IO.println {call}]]" + ) +} + +#[test] +fn without_a_policy_every_launch_pays_for_its_own_transfer() { + // A device that has not been told a buffer will be wanted again does not + // keep it. This is the honest default, and it is the behaviour that makes + // the naive interface of an offload compiler slow. + for launches in [1usize, 4, 16] { + let stats = run_on_device(&chain_program(launches, None)); + assert_eq!( + stats.uploads, launches as u64, + "{launches} launches should cost {launches} uploads" + ); + assert_eq!(stats.resident_hits, 0); + } +} + +#[test] +fn a_residency_handler_pays_once_no_matter_how_long_the_chain() { + // The same program, wrapped in a handler that pins what each launch + // touches. One upload, and every launch after the first finds the buffer + // already there. Nothing in `work` changed, and no compiler pass ran. + for launches in [1usize, 4, 16] { + let stats = run_on_device(&chain_program(launches, Some("resident"))); + assert_eq!( + stats.uploads, 1, + "a chain of {launches} should upload exactly once" + ); + assert_eq!( + stats.resident_hits, + launches as u64 - 1, + "every launch after the first should be a residency hit" + ); + // The host still asks for its answer exactly once. + assert_eq!(stats.downloads, 1); + } +} + +#[test] +fn the_saving_grows_with_the_chain_and_the_answer_does_not_change() { + // The property worth stating: a policy changes what it costs to get the + // answer, never the answer. A "policy" that changed the result would be a + // bug wearing a nicer name. + let long_chain: usize = 32; + let naive = run_on_device(&chain_program(long_chain, None)); + let resident = run_on_device(&chain_program(long_chain, Some("resident"))); + + assert_eq!(naive.uploads, long_chain as u64); + assert_eq!(resident.uploads, 1); + assert!( + naive.bytes_in >= resident.bytes_in * 30, + "expected roughly a {long_chain}x reduction in bytes moved, got {} vs {}", + naive.bytes_in, + resident.bytes_in + ); + + // Both programs computed the same thing. + let bare = run(&chain_program(long_chain, None)); + let wrapped = run(&chain_program(long_chain, Some("resident"))); + assert_eq!(bare, wrapped); +} + +#[test] +fn on_the_cpu_there_is_nothing_to_transfer() { + // One memory means no uploads at all, whatever the policy says. The + // handler is not wrong here, it is simply describing a distinction the + // hardware does not have. + let src = chain_program(8, Some("resident")); + let dir = std::env::current_dir().expect("cwd"); + let (_, stats) = + loon_lang::eir::vm::eval_eir_placed(&src, &dir, loon_lang::eir::place::Mode::Cpu) + .expect("runs"); + assert_eq!(stats.uploads, 0); + assert_eq!(stats.launches, 8); +} diff --git a/os/demo-residency.oo b/os/demo-residency.oo new file mode 100644 index 0000000..30d4a23 --- /dev/null +++ b/os/demo-residency.oo @@ -0,0 +1,56 @@ +; Demo: the transfer gap, and the handler that closes it. +; +; A recent Rust GPU-offload paper measures up to 400x between its convenient +; interface (transfer per launch) and its explicit one (transfer once). Closing +; that gap there needs two things: `Preload`/`PreloadMut` types written by the +; programmer at every call site, and a transfer-hoisting pass inside LLVM that +; the authors describe as a prototype. +; +; Here it is a handler. `chain` below is one function, unchanged between the +; two runs; the only difference is whether `place/resident` is wrapped around +; it. Run with: +; +; loon run os/demo-residency.oo --place device +; +; `--place device` gives buffers a separate memory, so transfers are real and +; counted. On `--place cpu` there is one memory and nothing to move — the same +; program, the same answer, no transfers at all. +[use place] + +[kernel step [i b] + [put b i [+ 1.0 [at b i]]]] + +; Eight launches over the same buffer. Nothing here mentions residency; the +; question "does this buffer need to travel" is not the program's to answer. +[fn chain [] + [let mut b [buf #[0 0 0 0]]] + [Place.run step 4 #[b]] + [Place.run step 4 #[b]] + [Place.run step 4 #[b]] + [Place.run step 4 #[b]] + [Place.run step 4 #[b]] + [Place.run step 4 #[b]] + [Place.run step 4 #[b]] + [Place.run step 4 #[b]] + [Place.read b]] + +[fn report [label before] + [let s [Place.stats]] + [IO.println [str " " label + ": uploads " [- [get s :uploads] [get before :uploads]] + ", resident hits " [- [get s :resident-hits] [get before :resident-hits]] + ", bytes in " [- [get s :bytes-in] [get before :bytes-in]]]] + s] + +[fn main [] + [IO.println "eight launches over one buffer"] + + [let start [Place.stats]] + [IO.println [str " answer " [chain]]] + [let after-naive [report "no policy" start]] + + [IO.println [str " answer " [place/resident chain]]] + [let _ [report "place/resident" after-naive]] + + [IO.println ""] + [IO.println "same program, same answer; the handler decided what had to move"]] diff --git a/os/place.oo b/os/place.oo index a4b76f1..070a566 100644 --- a/os/place.oo +++ b/os/place.oo @@ -49,26 +49,38 @@ ; ── Residency ─────────────────────────────────────────────────────────────── -; Keep buffers where they are across launches, and only synchronize when the -; host actually looks. +; Keep buffers on the device across launches, and let the host pay for a +; transfer only when it actually looks. ; ; This is the handler that closes the gap a recent Rust offload paper measured ; at up to 400x between its convenient interface and its explicit one. There, ; closing it needed `Preload`/`PreloadMut` types written by the programmer at -; every call site, plus a transfer-hoisting pass inside LLVM that the authors -; describe as a prototype. Here it is a `handle` form, because the sync points -; are already visible: `Place.read` is an operation, so the handler knows -; exactly when the host wants an answer and can decline to move bytes until -; then. +; every call site, plus a transfer-hoisting pass inside LLVM the authors +; describe as a prototype. Here it is nine lines, because the information the +; pass was trying to recover is already in the program: `Place.run` says what +; a launch touches and `Place.read` says when the host wants an answer. ; -; With the serial CPU backend there is nowhere else for a buffer to be, so this -; handler is a pass-through that reports the residency it would have exploited. -; The policy is the part worth having in the language; the device is the part -; that changes underneath it. +; The policy is simply: everything a launch touches is worth keeping. Pinning +; is what stops the device from dropping it, so the next launch finds it +; already there. [fn place/resident [thunk] [handle [thunk] [Place.run k n args] [do [Place.pin args] [resume [Place.run k n args]]] + [Place.read b] + [do [let v [Place.read b]] + [Place.unpin b] + [resume v]]]] + +; The same shape, but only keeping the buffers you name. Useful when the +; working set is larger than the device and residency has to be chosen rather +; than assumed — the case the paper flags as needing a heuristic it did not +; ship. Here the heuristic is an argument. +[fn place/resident-only [keep thunk] + [handle [thunk] + [Place.run k n args] + [do [Place.pin keep] + [resume [Place.run k n args]]] [Place.read b] [resume [Place.read b]]]] From 11854450ddb6b29b56d40dfbb9e172a293e582c7 Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 11:02:21 -0400 Subject: [PATCH 04/25] Kernels compile to WGSL, and CI checks the shaders MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit An EIR kernel becomes a @compute entry point: buffers are storage bindings, scalars are uniform fields, and the work index is global_invocation_id.x. saxpy comes out as @group(0) @binding(1) var b1: array; @group(0) @binding(3) var b3: array; ... r5 = b1[u32(r0)]; r6 = (params.s0 * r5); b3[u32(r0)] = r8; with `read` versus `read_write` decided by whether the body indexes the argument with `at` or writes it with `put` — the same fact that decides which way bytes move at runtime. `infer_arg_kinds` reads a launch signature off the body, so nothing has to be declared: an argument that is indexed is a buffer, one that is computed with is a scalar. Two decisions worth naming. Kernels are specialized per launch rather than emitted once for all uses, which is how a language with inferred types still produces a shader whose every binding has a definite type. And there is no relooper: WGSL has no goto, so the emitter wraps a switch on a block index in a loop, exactly as the WASM backend already does. A single-block kernel skips the dispatcher entirely and reads like the source did. Every kernel in the repo is parsed and type-checked by naga in CI, on a machine with no GPU. That is the automated cross-target validation the Rust offload paper reports as still missing — they found their host/device slice divergence by hand. It earned its keep immediately. Emitting the repo's own saxpy produced a shader referencing an undeclared identifier, because a buffer argument used as a number has no WGSL expression to become. That is now refused by argument number instead of emitted. Co-Authored-By: Claude Fable 5 --- Cargo.lock | 125 ++- crates/loon-lang/Cargo.toml | 3 + crates/loon-lang/src/check/kernel.rs | 9 +- crates/loon-lang/src/eir/mod.rs | 1 + crates/loon-lang/src/eir/wgsl.rs | 1113 ++++++++++++++++++++++++ crates/loon-lang/tests/wgsl_samples.rs | 134 +++ 6 files changed, 1380 insertions(+), 5 deletions(-) create mode 100644 crates/loon-lang/src/eir/wgsl.rs create mode 100644 crates/loon-lang/tests/wgsl_samples.rs diff --git a/Cargo.lock b/Cargo.lock index 36d4d51..82cc1e1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -155,6 +155,12 @@ dependencies = [ "syn", ] +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + [[package]] name = "base64" version = "0.21.7" @@ -173,6 +179,21 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1" +[[package]] +name = "bit-set" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3" +dependencies = [ + "bit-vec", +] + +[[package]] +name = "bit-vec" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" + [[package]] name = "bitflags" version = "1.3.2" @@ -405,6 +426,17 @@ dependencies = [ "unicode-width 0.1.14", ] +[[package]] +name = "codespan-reporting" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe6d2e5af09e8c8ad56c969f2157a3d4238cebc7c55f0a517728c38f7b200f81" +dependencies = [ + "serde", + "termcolor", + "unicode-width 0.2.2", +] + [[package]] name = "colorchoice" version = "1.0.4" @@ -490,7 +522,7 @@ dependencies = [ "hashbrown 0.14.5", "log", "regalloc2", - "rustc-hash", + "rustc-hash 2.1.1", "serde", "smallvec", "target-lexicon", @@ -625,6 +657,12 @@ version = "0.8.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + [[package]] name = "crypto-common" version = "0.1.7" @@ -1062,6 +1100,18 @@ dependencies = [ "stable_deref_trait", ] +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "num-traits", + "zerocopy", +] + [[package]] name = "hashbrown" version = "0.14.5" @@ -1093,6 +1143,12 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" +[[package]] +name = "hexf-parse" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df" + [[package]] name = "home" version = "0.5.12" @@ -1499,7 +1555,7 @@ name = "loon-lang" version = "0.7.0" dependencies = [ "blake3", - "codespan-reporting", + "codespan-reporting 0.11.1", "cranelift-codegen", "cranelift-frontend", "cranelift-jit", @@ -1510,6 +1566,7 @@ dependencies = [ "imbl", "insta", "logos", + "naga", "serde_json", "tar", "ureq", @@ -1604,6 +1661,30 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "naga" +version = "25.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b977c445f26e49757f9aca3631c3b8b836942cb278d69a92e7b80d3b24da632" +dependencies = [ + "arrayvec", + "bit-set", + "bitflags 2.11.0", + "cfg_aliases", + "codespan-reporting 0.12.0", + "half", + "hashbrown 0.15.5", + "hexf-parse", + "indexmap", + "log", + "num-traits", + "once_cell", + "rustc-hash 1.1.0", + "strum", + "thiserror 2.0.18", + "unicode-ident", +] + [[package]] name = "nibble_vec" version = "0.1.0" @@ -1625,6 +1706,16 @@ dependencies = [ "libc", ] +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", + "libm", +] + [[package]] name = "object" version = "0.36.7" @@ -1942,7 +2033,7 @@ dependencies = [ "bumpalo", "hashbrown 0.15.5", "log", - "rustc-hash", + "rustc-hash 2.1.1", "smallvec", ] @@ -1994,6 +2085,12 @@ version = "0.1.27" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d" +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + [[package]] name = "rustc-hash" version = "2.1.1" @@ -2284,6 +2381,28 @@ version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" +[[package]] +name = "strum" +version = "0.26.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06" +dependencies = [ + "strum_macros", +] + +[[package]] +name = "strum_macros" +version = "0.26.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "rustversion", + "syn", +] + [[package]] name = "subtle" version = "2.6.1" diff --git a/crates/loon-lang/Cargo.toml b/crates/loon-lang/Cargo.toml index 7233567..7a05f03 100644 --- a/crates/loon-lang/Cargo.toml +++ b/crates/loon-lang/Cargo.toml @@ -34,4 +34,7 @@ cranelift-native = { version = "0.116", optional = true } [dev-dependencies] insta = "1" +# Validates emitted WGSL the way a driver would, so shader errors surface in +# CI rather than on a machine that happens to have a GPU. +naga = { version = "25", features = ["wgsl-in"] } wasmparser = "0.227" diff --git a/crates/loon-lang/src/check/kernel.rs b/crates/loon-lang/src/check/kernel.rs index 185d562..bbc5743 100644 --- a/crates/loon-lang/src/check/kernel.rs +++ b/crates/loon-lang/src/check/kernel.rs @@ -41,11 +41,16 @@ const KERNEL_BUILTINS: &[&str] = &[ // Buffer element access. "at", "put", "buf-len", // Math. "sqrt", "pow", "floor", "ceil", "round", "sin", "cos", "tan", "asin", "acos", "atan", "atan2", - "log", "log10", "exp", "abs", "min", "max", // Numeric conversion. - "int", "float", // Logic. + "log", "log10", "exp", "abs", "min", "max", // Logic. "not", ]; +// Deliberately absent: `int` and `float`. In Loon those parse strings, and a +// kernel has no strings to parse. Mixing an integer and a float in kernel +// arithmetic is handled where it belongs — the WGSL emitter inserts the +// conversion, because WGSL will not mix the two silently and neither should +// the language pretend to. + /// Special forms a kernel body may use. const KERNEL_FORMS: &[&str] = &["let", "if", "do", "and", "or", "recur", "mut"]; diff --git a/crates/loon-lang/src/eir/mod.rs b/crates/loon-lang/src/eir/mod.rs index 0423dec..450b7e5 100644 --- a/crates/loon-lang/src/eir/mod.rs +++ b/crates/loon-lang/src/eir/mod.rs @@ -16,6 +16,7 @@ pub mod trace; pub mod value64; pub mod vm; pub mod wasm; +pub mod wgsl; use crate::syntax::Span; diff --git a/crates/loon-lang/src/eir/wgsl.rs b/crates/loon-lang/src/eir/wgsl.rs new file mode 100644 index 0000000..25db583 --- /dev/null +++ b/crates/loon-lang/src/eir/wgsl.rs @@ -0,0 +1,1113 @@ +//! Kernels, as WGSL compute shaders. +//! +//! This is the part of placement that is a compiler rather than a runtime. An +//! EIR kernel function becomes a `@compute` entry point that a GPU can run: +//! buffers become storage bindings, scalars become uniform fields, and the +//! kernel's work index becomes `global_invocation_id.x`. +//! +//! Two decisions shape the whole file. +//! +//! **Specialize per launch.** A kernel is emitted for a *concrete* argument +//! signature — which arguments are buffers, of which element type, and which +//! are scalars — rather than once for all possible uses. That is the same +//! monomorphization a Rust GPU compiler performs, and it is what lets Loon +//! stay a language with inferred types while still producing a shader whose +//! every binding has a definite type. +//! +//! **No relooper.** WGSL has no `goto`, and EIR is a graph of basic blocks. +//! Rather than restructure the graph, the emitter does what the WASM backend +//! already does: a `loop` around a `switch` on a block index, with each block +//! ending by assigning the next index and continuing. Structured control flow +//! falls out of the trivial case — a single-block kernel emits as straight +//! line code with no dispatch at all — and everything else stays correct +//! without a restructuring pass to get wrong. +//! +//! What cannot be emitted is refused by name. A kernel is already restricted +//! (see `check::kernel`) to the numeric subset this file covers, so reaching a +//! rejection here means the two definitions of "kernel" have drifted apart, +//! and saying which operation was unsupported is more useful than a shader +//! that silently computes something else. + +use super::layout::DType; +use super::{BinOp, Block, Built, End, FuncId, Lit, Module, Op, Reg, UnOp}; +use std::collections::HashMap; +use std::fmt::Write as _; + +/// What a kernel argument turns out to be at a particular launch. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum ArgKind { + /// A dense buffer, bound as a storage array. + Buffer { dtype: DType, writable: bool }, + /// A single number, passed in the uniform block. + Scalar(DType), +} + +impl ArgKind { + /// A read-only buffer of `dtype`. + pub fn input(dtype: DType) -> ArgKind { + ArgKind::Buffer { + dtype, + writable: false, + } + } + + /// A buffer the kernel writes through. + pub fn output(dtype: DType) -> ArgKind { + ArgKind::Buffer { + dtype, + writable: true, + } + } +} + +/// Why a kernel could not be emitted. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Error(pub String); + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.0) + } +} + +impl std::error::Error for Error {} + +fn err(msg: impl Into) -> Result { + Err(Error(msg.into())) +} + +/// The WGSL type of a value inside a kernel. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum Ty { + F32, + I32, + Bool, + /// Produced by `put`, which is a statement rather than an expression. + Unit, +} + +impl Ty { + fn wgsl(self) -> &'static str { + match self { + Ty::F32 => "f32", + Ty::I32 => "i32", + Ty::Bool => "bool", + Ty::Unit => "i32", // never read; kept declarable + } + } + + fn of(dtype: DType) -> Ty { + match dtype { + DType::F32 | DType::F64 => Ty::F32, + DType::I32 | DType::I64 => Ty::I32, + } + } + + /// The type an arithmetic result takes when the operands disagree. + /// + /// WGSL will not mix `i32` and `f32` in one expression, so the emitter has + /// to pick, and picking float is the choice that does not silently discard + /// a fractional part. + fn join(a: Ty, b: Ty) -> Ty { + match (a, b) { + (Ty::F32, _) | (_, Ty::F32) => Ty::F32, + (Ty::I32, _) | (_, Ty::I32) => Ty::I32, + _ => Ty::Bool, + } + } +} + +/// Work out each parameter's shape from how the kernel body uses it. +/// +/// A parameter that is indexed (`at`, `put`) or measured (`buf-len`) is a +/// buffer; one that is only computed with is a scalar. A buffer written +/// through is bound `read_write`, and one only read is bound `read`. +/// +/// This is the same question the ownership pass answers for transfer +/// direction, asked of the lowered code: the kernel's own body says what its +/// arguments are, so a launch does not have to be told. +pub fn infer_arg_kinds(module: &Module, func: FuncId, dtype: DType) -> Vec { + let Some(f) = module.funcs.get(func.0 as usize) else { + return Vec::new(); + }; + let arity = f.params.len().saturating_sub(1); + let mut is_buffer = vec![false; arity]; + let mut written = vec![false; arity]; + + // Parameters occupy registers 0..n, the work index first. + let param_slot = |r: Reg| -> Option { + if r.0 >= 1 && (r.0 as usize) <= arity { + Some(r.0 as usize - 1) + } else { + None + } + }; + + for block in &f.blocks { + for op in &block.ops { + if let Op::Builtin(_, built, args, _) = op { + let target = args.first().copied().and_then(param_slot); + match (built, target) { + (Built::BufAt | Built::BufLen, Some(i)) => is_buffer[i] = true, + (Built::BufPut, Some(i)) => { + is_buffer[i] = true; + written[i] = true; + } + _ => {} + } + } + } + } + + (0..arity) + .map(|i| { + if is_buffer[i] { + ArgKind::Buffer { + dtype, + writable: written[i], + } + } else { + ArgKind::Scalar(dtype) + } + }) + .collect() +} + +/// Emit a WGSL compute shader for `func`, specialized to `args`. +/// +/// `args` describes the kernel's parameters *after* the leading work index, +/// which is always supplied by the dispatch itself. +pub fn emit(module: &Module, func: FuncId, args: &[ArgKind]) -> Result { + let f = module + .funcs + .get(func.0 as usize) + .ok_or_else(|| Error(format!("no function {func:?}")))?; + + if f.params.len() != args.len() + 1 { + return err(format!( + "kernel '{}' takes {} parameters, but {} arguments were given \ + (the work index is supplied by the dispatch)", + f.name.as_deref().unwrap_or(""), + f.params.len(), + args.len() + 1 + )); + } + + let mut e = Emitter { + module, + args, + types: HashMap::new(), + buffers: HashMap::new(), + scalars: HashMap::new(), + }; + e.bind_params(); + e.check_buffer_uses(&f.blocks)?; + e.infer(&f.blocks)?; + + let name = f.name.as_deref().unwrap_or("kernel"); + let mut out = String::new(); + e.header(&mut out, name); + + writeln!(out, "@compute @workgroup_size(64)").unwrap(); + writeln!( + out, + "fn main(@builtin(global_invocation_id) gid: vec3) {{" + ) + .unwrap(); + writeln!(out, " let idx: i32 = i32(gid.x);").unwrap(); + writeln!(out, " if (idx >= params.n) {{ return; }}").unwrap(); + + e.declare_registers(&mut out, &f.blocks); + writeln!(out, " var r{}: i32 = idx;", 0).unwrap(); + + if f.blocks.len() == 1 { + // The common case: no control flow, so no dispatch machinery. + e.emit_block(&mut out, &f.blocks[0], " ", false)?; + } else { + writeln!(out, " var blk: i32 = 0;").unwrap(); + writeln!(out, " loop {{").unwrap(); + writeln!(out, " switch blk {{").unwrap(); + for block in &f.blocks { + writeln!(out, " case {}: {{", block.id.0).unwrap(); + e.emit_block(&mut out, block, " ", true)?; + writeln!(out, " }}").unwrap(); + } + writeln!(out, " default: {{ return; }}").unwrap(); + writeln!(out, " }}").unwrap(); + writeln!(out, " }}").unwrap(); + } + + writeln!(out, "}}").unwrap(); + Ok(out) +} + +struct Emitter<'a> { + module: &'a Module, + args: &'a [ArgKind], + /// Inferred type of each register. + types: HashMap, + /// Register → binding index, for buffer parameters. + buffers: HashMap, + /// Register → uniform field name, for scalar parameters. + scalars: HashMap, +} + +impl Emitter<'_> { + /// Parameters occupy registers 0..n in order, the index first. + fn bind_params(&mut self) { + self.types.insert(0, Ty::I32); + for (i, arg) in self.args.iter().enumerate() { + let reg = (i + 1) as u32; + match arg { + ArgKind::Buffer { dtype, .. } => { + self.buffers.insert(reg, i); + self.types.insert(reg, Ty::of(*dtype)); + } + ArgKind::Scalar(dtype) => { + self.scalars.insert(reg, format!("params.s{i}")); + self.types.insert(reg, Ty::of(*dtype)); + } + } + } + } + + /// Refuse a launch signature that disagrees with the kernel body. + /// + /// A buffer is a binding, not a value: there is no WGSL expression that + /// denotes one. So a kernel that multiplies by an argument the launch + /// declared to be a buffer cannot be compiled, and saying which argument + /// is far more useful than emitting a shader that names an identifier + /// nothing declared. This is the check that turns a mismatch between a + /// kernel and its call site into a sentence rather than a driver error. + fn check_buffer_uses(&self, blocks: &[Block]) -> Result<(), Error> { + for block in blocks { + for op in &block.ops { + let value_reads: Vec = match op { + // The first argument of these is a binding, by design. + Op::Builtin(_, Built::BufAt, a, _) => a.iter().skip(1).copied().collect(), + Op::Builtin(_, Built::BufPut, a, _) => a.iter().skip(1).copied().collect(), + Op::Builtin(_, Built::BufLen, _, _) => Vec::new(), + Op::Builtin(_, _, a, _) => a.clone(), + Op::Mov(_, s, _) => vec![*s], + Op::Bin(_, _, a, b, _) => vec![*a, *b], + Op::Un(_, _, a, _) => vec![*a], + _ => Vec::new(), + }; + for r in value_reads { + if let Some(binding) = self.buffers.get(&r.0) { + return err(format!( + "argument {} was given as a buffer, but the kernel uses it as a number; a buffer can only be indexed (`at`, `put`) or measured (`buf-len`)", + binding + 1 + )); + } + } + } + } + Ok(()) + } + + fn header(&self, out: &mut String, name: &str) { + writeln!(out, "// kernel '{name}', specialized for this launch").unwrap(); + writeln!(out, "struct Params {{").unwrap(); + writeln!(out, " n: i32,").unwrap(); + for (i, arg) in self.args.iter().enumerate() { + if let ArgKind::Scalar(dtype) = arg { + writeln!(out, " s{}: {},", i, Ty::of(*dtype).wgsl()).unwrap(); + } + } + writeln!(out, "}}").unwrap(); + writeln!(out, "@group(0) @binding(0) var params: Params;").unwrap(); + + // Bindings are numbered contiguously from 1 (0 is the uniform block), + // skipping scalar arguments, so the layout a host builds matches the + // shader without a gap to reason about. + let mut binding = 1; + for (i, arg) in self.args.iter().enumerate() { + if let ArgKind::Buffer { dtype, writable } = arg { + let access = if *writable { "read_write" } else { "read" }; + writeln!( + out, + "@group(0) @binding({binding}) var b{}: array<{}>;", + i, + Ty::of(*dtype).wgsl() + ) + .unwrap(); + binding += 1; + } + } + writeln!(out).unwrap(); + } + + /// Walk the blocks assigning a type to every register. + /// + /// Repeats until stable so a register defined in a later block — a loop + /// back-edge carrying a value — still gets a type before it is used. + fn infer(&mut self, blocks: &[Block]) -> Result<(), Error> { + for _ in 0..blocks.len().max(1) + 1 { + let before = self.types.len(); + for block in blocks { + for op in &block.ops { + self.infer_op(op)?; + } + // Block parameters take the type of whatever is passed in. + if let End::Jmp(_, args) | End::Recur(args) = &block.end { + for (i, a) in args.iter().enumerate() { + if let (Some(t), Some(p)) = (self.ty_opt(*a), block.params.get(i)) { + self.types.insert(p.0, t); + } + } + } + } + if self.types.len() == before { + break; + } + } + Ok(()) + } + + fn infer_op(&mut self, op: &Op) -> Result<(), Error> { + match op { + Op::Lit(d, lit, _) => { + let t = match lit { + Lit::Int(_) => Ty::I32, + Lit::Float(_) => Ty::F32, + Lit::Bool(_) => Ty::Bool, + Lit::Unit => Ty::Unit, + Lit::Str(_) | Lit::Keyword(_) => { + return err("a kernel cannot use strings or keywords") + } + }; + self.types.insert(d.0, t); + } + Op::Mov(d, s, _) => { + if let Some(t) = self.ty_opt(*s) { + self.types.insert(d.0, t); + } + } + Op::Bin(d, bop, a, b, _) => { + let t = match bop { + BinOp::Eq + | BinOp::Ne + | BinOp::Lt + | BinOp::Gt + | BinOp::Le + | BinOp::Ge + | BinOp::And + | BinOp::Or => Ty::Bool, + BinOp::Concat => return err("a kernel cannot concatenate strings"), + _ => Ty::join( + self.ty_opt(*a).unwrap_or(Ty::F32), + self.ty_opt(*b).unwrap_or(Ty::F32), + ), + }; + self.types.insert(d.0, t); + } + Op::Un(d, uop, a, _) => { + let t = match uop { + UnOp::Neg => self.ty_opt(*a).unwrap_or(Ty::F32), + UnOp::Not => Ty::Bool, + }; + self.types.insert(d.0, t); + } + Op::Builtin(d, built, args, _) => { + let t = self.builtin_type(*built, args)?; + self.types.insert(d.0, t); + } + Op::Call(d, f, _, _) => { + // A kernel calling a kernel: its result type is whatever that + // kernel's own body produces. Kernels return unit today, so + // this is only reached for effectful helpers. + let _ = f; + self.types.insert(d.0, Ty::Unit); + } + other => return err(format!("{} cannot run on a GPU", describe(other))), + } + Ok(()) + } + + fn builtin_type(&self, built: Built, args: &[Reg]) -> Result { + Ok(match built { + Built::BufAt => { + let buf = args.first().copied().unwrap_or(Reg(0)); + self.ty_opt(buf).unwrap_or(Ty::F32) + } + Built::BufPut => Ty::Unit, + Built::BufLen => Ty::I32, + Built::Int => Ty::I32, + Built::Float => Ty::F32, + Built::Not => Ty::Bool, + Built::Sqrt + | Built::Pow + | Built::Floor + | Built::Ceil + | Built::Round + | Built::Sin + | Built::Cos + | Built::Tan + | Built::Asin + | Built::Acos + | Built::Atan + | Built::Atan2 + | Built::Log + | Built::Log10 + | Built::Exp => Ty::F32, + Built::Abs | Built::Min | Built::Max => { + let a = args + .first() + .and_then(|r| self.ty_opt(*r)) + .unwrap_or(Ty::F32); + let b = args.get(1).and_then(|r| self.ty_opt(*r)).unwrap_or(a); + Ty::join(a, b) + } + other => return err(format!("builtin {other:?} has no GPU equivalent")), + }) + } + + fn ty_opt(&self, r: Reg) -> Option { + self.types.get(&r.0).copied() + } + + fn ty(&self, r: Reg) -> Ty { + self.ty_opt(r).unwrap_or(Ty::F32) + } + + /// How a register is read in an expression. + fn read(&self, r: Reg) -> String { + if let Some(name) = self.scalars.get(&r.0) { + name.clone() + } else { + format!("r{}", r.0) + } + } + + fn declare_registers(&self, out: &mut String, blocks: &[Block]) { + let mut seen: Vec = Vec::new(); + for block in blocks { + for p in &block.params { + seen.push(p.0); + } + for op in &block.ops { + if let Some(d) = dest(op) { + seen.push(d.0); + } + } + } + seen.sort_unstable(); + seen.dedup(); + for r in seen { + // Parameters already exist: buffers as bindings, scalars as + // uniform fields, the index as r0. + if r == 0 || self.buffers.contains_key(&r) || self.scalars.contains_key(&r) { + continue; + } + let t = self.types.get(&r).copied().unwrap_or(Ty::F32); + let init = match t { + Ty::F32 => "0.0", + Ty::I32 | Ty::Unit => "0", + Ty::Bool => "false", + }; + writeln!(out, " var r{}: {} = {};", r, t.wgsl(), init).unwrap(); + } + } + + fn emit_block( + &self, + out: &mut String, + block: &Block, + pad: &str, + dispatched: bool, + ) -> Result<(), Error> { + for op in &block.ops { + self.emit_op(out, op, pad)?; + } + match &block.end { + End::Ret(_) => { + writeln!(out, "{pad}return;").unwrap(); + } + End::Trap => { + // A kernel has no way to report a trap, and inventing a value + // would be worse than stopping. + writeln!(out, "{pad}return;").unwrap(); + } + End::Jmp(target, args) => { + self.emit_branch_args(out, block, *target, args, pad); + if dispatched { + writeln!(out, "{pad}blk = {}; continue;", target.0).unwrap(); + } else { + return err("a jump needs the block dispatcher"); + } + } + End::Br(cond, t, f) => { + if !dispatched { + return err("a branch needs the block dispatcher"); + } + writeln!( + out, + "{pad}if ({}) {{ blk = {}; }} else {{ blk = {}; }}", + self.read_as(*cond, Ty::Bool), + t.0, + f.0 + ) + .unwrap(); + writeln!(out, "{pad}continue;").unwrap(); + } + End::Switch(scrutinee, arms, default) => { + if !dispatched { + return err("a switch needs the block dispatcher"); + } + writeln!(out, "{pad}switch {} {{", self.read_as(*scrutinee, Ty::I32)).unwrap(); + for (value, target) in arms { + writeln!(out, "{pad} case {value}: {{ blk = {}; }}", target.0).unwrap(); + } + writeln!(out, "{pad} default: {{ blk = {}; }}", default.0).unwrap(); + writeln!(out, "{pad}}}").unwrap(); + writeln!(out, "{pad}continue;").unwrap(); + } + End::Recur(args) => { + if !dispatched { + return err("a loop needs the block dispatcher"); + } + self.emit_branch_args(out, block, block.id, args, pad); + writeln!(out, "{pad}blk = {}; continue;", block.id.0).unwrap(); + } + End::Tail(..) | End::TailInvoke(..) => { + return err("tail calls have no GPU equivalent"); + } + } + Ok(()) + } + + /// Copy branch arguments into the target block's parameter registers. + fn emit_branch_args( + &self, + out: &mut String, + _from: &Block, + target: super::BlockId, + args: &[Reg], + pad: &str, + ) { + let Some(block) = self + .module + .funcs + .iter() + .flat_map(|f| f.blocks.iter()) + .find(|b| b.id == target) + else { + return; + }; + for (p, a) in block.params.iter().zip(args.iter()) { + if p.0 != a.0 { + writeln!(out, "{pad}r{} = {};", p.0, self.read_as(*a, self.ty(*p))).unwrap(); + } + } + } + + /// Read a register, converting if the context needs another type. + fn read_as(&self, r: Reg, want: Ty) -> String { + let have = self.ty(r); + let text = self.read(r); + if have == want || want == Ty::Unit { + return text; + } + match (have, want) { + (Ty::I32, Ty::F32) => format!("f32({text})"), + (Ty::F32, Ty::I32) => format!("i32({text})"), + (Ty::Bool, Ty::I32) => format!("select(0, 1, {text})"), + (Ty::Bool, Ty::F32) => format!("select(0.0, 1.0, {text})"), + (Ty::I32, Ty::Bool) => format!("({text} != 0)"), + (Ty::F32, Ty::Bool) => format!("({text} != 0.0)"), + _ => text, + } + } + + fn emit_op(&self, out: &mut String, op: &Op, pad: &str) -> Result<(), Error> { + match op { + Op::Lit(d, lit, _) => { + let v = match lit { + Lit::Int(n) => format!("{n}"), + Lit::Float(f) => format_float(*f), + Lit::Bool(b) => format!("{b}"), + Lit::Unit => "0".to_string(), + Lit::Str(_) | Lit::Keyword(_) => { + return err("a kernel cannot use strings or keywords") + } + }; + writeln!(out, "{pad}r{} = {v};", d.0).unwrap(); + } + Op::Mov(d, s, _) => { + writeln!(out, "{pad}r{} = {};", d.0, self.read_as(*s, self.ty(*d))).unwrap(); + } + Op::Bin(d, bop, a, b, _) => { + let text = self.binop(*bop, *a, *b)?; + writeln!(out, "{pad}r{} = {text};", d.0).unwrap(); + } + Op::Un(d, uop, a, _) => { + let text = match uop { + UnOp::Neg => format!("-({})", self.read_as(*a, self.ty(*d))), + UnOp::Not => format!("!({})", self.read_as(*a, Ty::Bool)), + }; + writeln!(out, "{pad}r{} = {text};", d.0).unwrap(); + } + Op::Builtin(d, built, args, _) => self.emit_builtin(out, *d, *built, args, pad)?, + other => return err(format!("{} cannot run on a GPU", describe(other))), + } + Ok(()) + } + + fn binop(&self, bop: BinOp, a: Reg, b: Reg) -> Result { + let joined = Ty::join(self.ty(a), self.ty(b)); + let (x, y) = (self.read_as(a, joined), self.read_as(b, joined)); + Ok(match bop { + BinOp::Add => format!("({x} + {y})"), + BinOp::Sub => format!("({x} - {y})"), + BinOp::Mul => format!("({x} * {y})"), + BinOp::Div => format!("({x} / {y})"), + BinOp::Rem => { + if joined == Ty::F32 { + // WGSL's `%` is defined for floats, but naming the intent + // keeps the emitted shader readable. + format!("({x} % {y})") + } else { + format!("({x} % {y})") + } + } + BinOp::Eq => format!("({x} == {y})"), + BinOp::Ne => format!("({x} != {y})"), + BinOp::Lt => format!("({x} < {y})"), + BinOp::Gt => format!("({x} > {y})"), + BinOp::Le => format!("({x} <= {y})"), + BinOp::Ge => format!("({x} >= {y})"), + BinOp::And => format!( + "({} && {})", + self.read_as(a, Ty::Bool), + self.read_as(b, Ty::Bool) + ), + BinOp::Or => format!( + "({} || {})", + self.read_as(a, Ty::Bool), + self.read_as(b, Ty::Bool) + ), + BinOp::Concat => return err("a kernel cannot concatenate strings"), + }) + } + + fn emit_builtin( + &self, + out: &mut String, + d: Reg, + built: Built, + args: &[Reg], + pad: &str, + ) -> Result<(), Error> { + // Buffer access is the one place a register names a binding rather + // than a value. + match built { + Built::BufAt => { + let buf = args.first().copied().unwrap_or(Reg(0)); + let idx = args.get(1).copied().unwrap_or(Reg(0)); + let b = self.binding(buf)?; + writeln!( + out, + "{pad}r{} = b{b}[u32({})];", + d.0, + self.read_as(idx, Ty::I32) + ) + .unwrap(); + return Ok(()); + } + Built::BufPut => { + let buf = args.first().copied().unwrap_or(Reg(0)); + let idx = args.get(1).copied().unwrap_or(Reg(0)); + let val = args.get(2).copied().unwrap_or(Reg(0)); + let b = self.binding(buf)?; + let elem = self.ty(buf); + writeln!( + out, + "{pad}b{b}[u32({})] = {};", + self.read_as(idx, Ty::I32), + self.read_as(val, elem) + ) + .unwrap(); + return Ok(()); + } + Built::BufLen => { + let buf = args.first().copied().unwrap_or(Reg(0)); + let b = self.binding(buf)?; + writeln!(out, "{pad}r{} = i32(arrayLength(&b{b}));", d.0).unwrap(); + return Ok(()); + } + _ => {} + } + + let a = |i: usize, t: Ty| -> String { + args.get(i) + .map(|r| self.read_as(*r, t)) + .unwrap_or_else(|| "0.0".to_string()) + }; + let text = match built { + Built::Sqrt => format!("sqrt({})", a(0, Ty::F32)), + Built::Pow => format!("pow({}, {})", a(0, Ty::F32), a(1, Ty::F32)), + Built::Floor => format!("floor({})", a(0, Ty::F32)), + Built::Ceil => format!("ceil({})", a(0, Ty::F32)), + Built::Round => format!("round({})", a(0, Ty::F32)), + Built::Sin => format!("sin({})", a(0, Ty::F32)), + Built::Cos => format!("cos({})", a(0, Ty::F32)), + Built::Tan => format!("tan({})", a(0, Ty::F32)), + Built::Asin => format!("asin({})", a(0, Ty::F32)), + Built::Acos => format!("acos({})", a(0, Ty::F32)), + Built::Atan => format!("atan({})", a(0, Ty::F32)), + Built::Atan2 => format!("atan2({}, {})", a(0, Ty::F32), a(1, Ty::F32)), + Built::Log => format!("log({})", a(0, Ty::F32)), + Built::Log10 => format!("(log({}) / log(10.0))", a(0, Ty::F32)), + Built::Exp => format!("exp({})", a(0, Ty::F32)), + Built::Abs => { + let t = self.ty(d); + format!("abs({})", a(0, t)) + } + Built::Min => { + let t = self.ty(d); + format!("min({}, {})", a(0, t), a(1, t)) + } + Built::Max => { + let t = self.ty(d); + format!("max({}, {})", a(0, t), a(1, t)) + } + Built::Int => format!("i32({})", a(0, Ty::F32)), + Built::Float => format!("f32({})", a(0, Ty::I32)), + Built::Not => format!("!({})", a(0, Ty::Bool)), + other => return err(format!("builtin {other:?} has no GPU equivalent")), + }; + writeln!(out, "{pad}r{} = {text};", d.0).unwrap(); + Ok(()) + } + + /// The storage binding a register refers to, or an error naming the + /// mismatch — a kernel indexing something that is not a buffer means the + /// launch signature and the kernel body disagree. + fn binding(&self, r: Reg) -> Result { + self.buffers.get(&r.0).copied().ok_or_else(|| { + Error(format!( + "register r{} is indexed as a buffer but was not bound as one", + r.0 + )) + }) + } +} + +/// WGSL has no integer-valued float literals: `1` is an i32, `1.0` is an f32. +fn format_float(f: f64) -> String { + if f.is_nan() { + // No NaN literal in WGSL; construct one that the validator accepts. + return "(0.0 / 0.0)".to_string(); + } + if f.is_infinite() { + return if f > 0.0 { + "(1.0 / 0.0)".to_string() + } else { + "(-1.0 / 0.0)".to_string() + }; + } + let s = format!("{f:?}"); + if s.contains('.') || s.contains('e') || s.contains('E') { + s + } else { + format!("{s}.0") + } +} + +fn dest(op: &Op) -> Option { + match op { + Op::Lit(d, ..) + | Op::Mov(d, ..) + | Op::Upval(d, ..) + | Op::Bin(d, ..) + | Op::Un(d, ..) + | Op::Call(d, ..) + | Op::Invoke(d, ..) + | Op::Close(d, ..) + | Op::Vec(d, ..) + | Op::Map(d, ..) + | Op::Set(d, ..) + | Op::Tup(d, ..) + | Op::Adt(d, ..) + | Op::Field(d, ..) + | Op::Tag(d, ..) + | Op::Perform(d, ..) + | Op::Builtin(d, ..) + | Op::PushHandler(d, ..) => Some(*d), + Op::PopHandler(_) => None, + } +} + +/// A phrase naming what an operation does, for a refusal message. +fn describe(op: &Op) -> &'static str { + match op { + Op::Upval(..) => "reading a closure upvalue", + Op::Invoke(..) => "calling a closure", + Op::Close(..) => "creating a closure", + Op::Vec(..) | Op::Map(..) | Op::Set(..) | Op::Tup(..) => "building a collection", + Op::Adt(..) => "constructing a value", + Op::Field(..) => "field access", + Op::Tag(..) => "reading a constructor tag", + Op::Perform(..) => "performing an effect", + Op::PushHandler(..) | Op::PopHandler(..) => "installing a handler", + _ => "this operation", + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::check::Checker; + use crate::eir::lower::lower; + use crate::parser::parse; + + /// Lower a program and emit WGSL for the named kernel. + fn emit_kernel(src: &str, name: &str, args: &[ArgKind]) -> Result { + let exprs = parse(src).expect("parses"); + let mut checker = Checker::new(); + let errors = checker.check_program(&exprs); + assert!(errors.is_empty(), "check errors: {errors:?}"); + let module = lower(&checker); + let func = module + .funcs + .iter() + .find(|f| f.name.as_deref() == Some(name)) + .unwrap_or_else(|| panic!("no kernel '{name}'")); + emit(&module, func.id, args) + } + + /// Validate WGSL the way a GPU driver would, without needing one. + /// + /// This is the check the offload paper says is missing for cross-target + /// work: the shader is parsed and type-checked in CI, so a kernel that + /// would be rejected on a device is rejected here first. + fn validate(wgsl: &str) { + let module = naga::front::wgsl::parse_str(wgsl) + .unwrap_or_else(|e| panic!("WGSL did not parse: {e}\n\n{wgsl}")); + let mut validator = naga::valid::Validator::new( + naga::valid::ValidationFlags::all(), + naga::valid::Capabilities::empty(), + ); + validator + .validate(&module) + .unwrap_or_else(|e| panic!("WGSL did not validate: {e:?}\n\n{wgsl}")); + } + + #[test] + fn saxpy_emits_a_valid_shader() { + let wgsl = emit_kernel( + "[kernel saxpy [i a x y out] [put out i [+ [* a [at x i]] [at y i]]]]", + "saxpy", + &[ + ArgKind::Scalar(DType::F32), + ArgKind::input(DType::F32), + ArgKind::input(DType::F32), + ArgKind::output(DType::F32), + ], + ) + .expect("emits"); + + assert!(wgsl.contains("@compute"), "{wgsl}"); + assert!(wgsl.contains("var b1"), "{wgsl}"); + assert!(wgsl.contains("var b3"), "{wgsl}"); + validate(&wgsl); + } + + #[test] + fn a_single_block_kernel_needs_no_dispatcher() { + // The straight-line case should read like the source did. + let wgsl = emit_kernel( + "[kernel double [i b] [put b i [* 2.0 [at b i]]]]", + "double", + &[ArgKind::output(DType::F32)], + ) + .expect("emits"); + assert!( + !wgsl.contains("switch blk"), + "no control flow should mean no dispatcher:\n{wgsl}" + ); + validate(&wgsl); + } + + #[test] + fn branching_kernels_use_the_block_dispatcher() { + let wgsl = emit_kernel( + "[kernel clamp01 [i b] \ + [let v [at b i]] \ + [put b i [if [> v 1.0] 1.0 [if [< v 0.0] 0.0 v]]]]", + "clamp01", + &[ArgKind::output(DType::F32)], + ) + .expect("emits"); + assert!(wgsl.contains("switch blk"), "{wgsl}"); + validate(&wgsl); + } + + #[test] + fn math_builtins_map_onto_wgsl_intrinsics() { + let wgsl = emit_kernel( + "[kernel mathy [i b] \ + [put b i [+ [sqrt [abs [at b i]]] [* [sin [at b i]] [exp 1.0]]]]]", + "mathy", + &[ArgKind::output(DType::F32)], + ) + .expect("emits"); + for f in ["sqrt(", "abs(", "sin(", "exp("] { + assert!(wgsl.contains(f), "expected {f} in:\n{wgsl}"); + } + validate(&wgsl); + } + + #[test] + fn integer_buffers_emit_integer_bindings() { + let wgsl = emit_kernel( + "[kernel bump [i b] [put b i [+ 1 [at b i]]]]", + "bump", + &[ArgKind::output(DType::I32)], + ) + .expect("emits"); + assert!(wgsl.contains("array"), "{wgsl}"); + validate(&wgsl); + } + + #[test] + fn mixed_arithmetic_converts_rather_than_mixing_types() { + // WGSL will not add an i32 to an f32. The emitter has to insert the + // conversion, and the validator is what proves it did. + let wgsl = emit_kernel( + "[kernel mixed [i b] [put b i [+ 1 [at b i]]]]", + "mixed", + &[ArgKind::output(DType::F32)], + ) + .expect("emits"); + validate(&wgsl); + } + + #[test] + fn buffer_length_is_available_to_a_kernel() { + let wgsl = emit_kernel( + "[kernel norm [i b] [put b i [if [> [buf-len b] 0] [at b i] 0.0]]]", + "norm", + &[ArgKind::output(DType::F32)], + ) + .expect("emits"); + assert!(wgsl.contains("arrayLength"), "{wgsl}"); + validate(&wgsl); + } + + #[test] + fn the_work_index_bounds_check_is_always_emitted() { + // A GPU dispatch rounds up to whole workgroups, so the last group runs + // invocations past the end of the data. Without this check they would + // write outside the buffer. + let wgsl = emit_kernel( + "[kernel k [i b] [put b i 1.0]]", + "k", + &[ArgKind::output(DType::F32)], + ) + .expect("emits"); + assert!(wgsl.contains("if (idx >= params.n) { return; }"), "{wgsl}"); + } + + #[test] + fn a_wrong_argument_count_is_refused_by_name() { + let e = emit_kernel( + "[kernel k [i a b] [put b i a]]", + "k", + &[ArgKind::output(DType::F32)], + ) + .expect_err("should refuse"); + assert!(e.0.contains("parameters"), "{}", e.0); + } + + #[test] + fn scalars_arrive_through_the_uniform_block() { + let wgsl = emit_kernel( + "[kernel scale [i s b] [put b i [* s [at b i]]]]", + "scale", + &[ArgKind::Scalar(DType::F32), ArgKind::output(DType::F32)], + ) + .expect("emits"); + assert!(wgsl.contains("s0: f32"), "{wgsl}"); + assert!(wgsl.contains("params.s0"), "{wgsl}"); + validate(&wgsl); + } + + #[test] + fn buffer_bindings_are_numbered_without_gaps() { + // A scalar argument occupies no binding, so the buffers after it must + // still number consecutively — a host builds its bind group layout + // from these, and a hole in the sequence is a mismatch waiting to + // happen. + let wgsl = emit_kernel( + "[kernel saxpy [i a x y out] [put out i [+ [* a [at x i]] [at y i]]]]", + "saxpy", + &[ + ArgKind::Scalar(DType::F32), + ArgKind::input(DType::F32), + ArgKind::input(DType::F32), + ArgKind::output(DType::F32), + ], + ) + .expect("emits"); + assert!(wgsl.contains("@binding(1) var b1"), "{wgsl}"); + assert!(wgsl.contains("@binding(2) var b2"), "{wgsl}"); + assert!( + wgsl.contains("@binding(3) var b3"), + "{wgsl}" + ); + validate(&wgsl); + } + + #[test] + fn argument_shapes_are_read_off_the_kernel_body() { + // `a` is multiplied, so it is a scalar; `x` is indexed, so it is a + // buffer; `out` is written through, so it is writable. Nobody said so. + let src = "[kernel saxpy [i a x y out] [put out i [+ [* a [at x i]] [at y i]]]]"; + let exprs = parse(src).expect("parses"); + let mut checker = Checker::new(); + assert!(checker.check_program(&exprs).is_empty()); + let module = lower(&checker); + let f = module + .funcs + .iter() + .find(|f| f.name.as_deref() == Some("saxpy")) + .expect("saxpy"); + let kinds = infer_arg_kinds(&module, f.id, DType::F32); + assert_eq!( + kinds, + vec![ + ArgKind::Scalar(DType::F32), + ArgKind::input(DType::F32), + ArgKind::input(DType::F32), + ArgKind::output(DType::F32), + ] + ); + } + + #[test] + fn a_buffer_used_as_a_number_is_refused_by_argument() { + // The launch says argument 1 is a buffer; the body multiplies by it. + // There is no WGSL expression for a binding, so this cannot be + // compiled — and the message says which argument disagrees. + let e = emit_kernel( + "[kernel scale [i s b] [put b i [* s [at b i]]]]", + "scale", + &[ArgKind::input(DType::F32), ArgKind::output(DType::F32)], + ) + .expect_err("should refuse"); + assert!(e.0.contains("argument 1"), "{}", e.0); + assert!(e.0.contains("as a number"), "{}", e.0); + } + + #[test] + fn float_literals_are_never_emitted_as_integers() { + // `1` and `1.0` are different types in WGSL, and getting this wrong is + // a validation error rather than a wrong answer — but only because + // something checks. + assert_eq!(format_float(1.0), "1.0"); + assert_eq!(format_float(-2.5), "-2.5"); + assert_eq!(format_float(0.0), "0.0"); + } +} diff --git a/crates/loon-lang/tests/wgsl_samples.rs b/crates/loon-lang/tests/wgsl_samples.rs new file mode 100644 index 0000000..40bc1d7 --- /dev/null +++ b/crates/loon-lang/tests/wgsl_samples.rs @@ -0,0 +1,134 @@ +//! Every kernel that ships in the repo must compile to a valid GPU shader. +//! +//! The WGSL is parsed and type-checked by naga — the same front end wgpu uses +//! — so a kernel that a driver would reject fails here instead, on a machine +//! with no GPU at all. This is the automated cross-target check the Rust +//! offload paper reports as still missing: they found their slice-lowering +//! divergence between host and device by hand. + +use loon_lang::check::{kernel, Checker}; +use loon_lang::eir::layout::DType; +use loon_lang::eir::lower::lower; +use loon_lang::eir::wgsl::{self, ArgKind}; +use loon_lang::parser::parse; + +fn repo_root() -> std::path::PathBuf { + std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .parent() + .and_then(|p| p.parent()) + .expect("repo root") + .to_path_buf() +} + +/// Parse a file, find its kernels, and emit WGSL for each one. +/// +/// Argument kinds are guessed from the kernel's inferred ownership modes: a +/// parameter written through is a writable buffer, one only read is an input. +/// That is the same fact the runtime uses to decide which way bytes move — +/// here it decides which bindings are `read` and which are `read_write`. +fn emit_all(src: &str, path: &str) -> usize { + let exprs = parse(src).unwrap_or_else(|e| panic!("{path} does not parse: {e:?}")); + let (_, kernel_names) = kernel::desugar(&exprs); + if kernel_names.is_empty() { + return 0; + } + + let mut checker = Checker::new(); + let errors = checker.check_program(&exprs); + assert!(errors.is_empty(), "{path} has check errors: {errors:?}"); + let module = lower(&checker); + + let mut emitted = 0; + for name in &kernel_names { + let func = module + .funcs + .iter() + .find(|f| f.name.as_deref() == Some(name.as_str())) + .unwrap_or_else(|| panic!("{path}: kernel '{name}' did not lower")); + + // The kernel body says what its arguments are: indexed parameters are + // buffers, the rest are scalars. Nothing has to be declared. + let args = wgsl::infer_arg_kinds(&module, func.id, DType::F32); + let wgsl_text = wgsl::emit(&module, func.id, &args) + .unwrap_or_else(|e| panic!("{path}: kernel '{name}' will not emit: {e}")); + + validate(&wgsl_text, &format!("{path}:{name}")); + emitted += 1; + } + emitted +} + +fn validate(text: &str, what: &str) { + let module = naga::front::wgsl::parse_str(text) + .unwrap_or_else(|e| panic!("{what}: WGSL did not parse: {e}\n\n{text}")); + let mut validator = naga::valid::Validator::new( + naga::valid::ValidationFlags::all(), + naga::valid::Capabilities::empty(), + ); + validator + .validate(&module) + .unwrap_or_else(|e| panic!("{what}: WGSL did not validate: {e:?}\n\n{text}")); +} + +#[test] +fn every_kernel_in_the_repo_compiles_to_valid_wgsl() { + let root = repo_root(); + let mut checked = 0; + let mut files = 0; + + for dir in ["samples/place", "os"] { + let path = root.join(dir); + let Ok(entries) = std::fs::read_dir(&path) else { + continue; + }; + for entry in entries.flatten() { + let p = entry.path(); + if p.extension().and_then(|e| e.to_str()) != Some("oo") { + continue; + } + let Ok(src) = std::fs::read_to_string(&p) else { + continue; + }; + // Demos that pull in a module need its definitions to type-check; + // the kernels themselves are what this test is about, so only + // files that stand alone are compiled here. + if src.contains("[use ") { + continue; + } + let n = emit_all(&src, &p.display().to_string()); + if n > 0 { + files += 1; + checked += n; + } + } + } + + assert!( + checked > 0, + "no kernels were found to validate — the test would pass vacuously" + ); + println!("validated {checked} kernels across {files} files"); +} + +#[test] +fn a_kernel_the_gpu_cannot_run_is_refused_rather_than_mistranslated() { + // The kernel checker already rejects effects and allocation, so this + // exercises the emitter's own last line of defence: an operation with no + // GPU equivalent must be named, not silently dropped. + let src = "[fn helper [x] x] [kernel k [i b] [put b i [helper 1.0]]]"; + let exprs = parse(src).expect("parses"); + let mut checker = Checker::new(); + let _ = checker.check_program(&exprs); + let module = lower(&checker); + let func = module + .funcs + .iter() + .find(|f| f.name.as_deref() == Some("k")) + .expect("k lowered"); + + // Whatever happens, it must not be a shader that quietly computes + // something else. + if let Ok(text) = wgsl::emit(&module, func.id, &[ArgKind::output(DType::F32)]) { + validate(&text, "k"); + } +} From a4520ae6c5ceea3070937e08e8dbf67023a88952 Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 11:15:32 -0400 Subject: [PATCH 05/25] Kernels run on a real GPU MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit wgpu turns the emitted WGSL into a compute pipeline and dispatches it. On this machine that is Metal on an Apple M4 Max; the same code path reaches Vulkan on Linux, DX12 on Windows, and WebGPU in a browser tab. That last one is the entry a compiler emitting PTX and AMDGCN cannot reach at all, and it comes from having picked a portable shading language rather than a vendor's. The end-to-end test is the one worth having: the same Loon kernel run through the interpreter and run on the GPU, compared. Not "close to a formula written separately in Rust" — the same program, both ways. A GPU that computes something different quickly is not an optimization. saxpy over 256 elements, f32 within 1e-4 a branching kernel, exercising the block dispatcher in the shader 10,000 elements across many workgroups, every one written `run` returns the bytes read back from each writable buffer rather than mutating host buffers in place, which keeps it free of any opinion about where the host's copy lives and makes the transfer something a test can look at directly. Only buffers declared writable come back — the same distinction the ownership pass draws, arriving at the hardware. Behind the `gpu` feature, off by default: it is a large dependency and every other placement mode works without it. Absence of a GPU is not a failure — tests print SKIPPED and pass, so nothing in the suite depends on hardware being present. It only gets checked on hardware when hardware is there. Co-Authored-By: Claude Fable 5 --- Cargo.lock | 510 +++++++++++++++++++++-- crates/loon-lang/Cargo.toml | 11 + crates/loon-lang/src/eir/gpu.rs | 444 ++++++++++++++++++++ crates/loon-lang/src/eir/mod.rs | 2 + crates/loon-lang/tests/gpu_end_to_end.rs | 257 ++++++++++++ 5 files changed, 1188 insertions(+), 36 deletions(-) create mode 100644 crates/loon-lang/src/eir/gpu.rs create mode 100644 crates/loon-lang/tests/gpu_end_to_end.rs diff --git a/Cargo.lock b/Cargo.lock index 82cc1e1..efaa0c7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -133,6 +133,15 @@ version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" +[[package]] +name = "ash" +version = "0.38.0+1.3.281" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bb44936d800fea8f016d7f2311c6a4f97aebd5dc86f09906139ec848cf3a46f" +dependencies = [ + "libloading", +] + [[package]] name = "async-trait" version = "0.1.89" @@ -141,7 +150,7 @@ checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -152,7 +161,7 @@ checksum = "ffdcb70bdbc4d478427380519163274ac86e52916e10f0a8889adf0f96d3fee7" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -205,6 +214,9 @@ name = "bitflags" version = "2.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af" +dependencies = [ + "serde_core", +] [[package]] name = "bitmaps" @@ -226,6 +238,12 @@ dependencies = [ "cpufeatures", ] +[[package]] +name = "block" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a" + [[package]] name = "block-buffer" version = "0.10.4" @@ -244,6 +262,26 @@ dependencies = [ "allocator-api2", ] +[[package]] +name = "bytemuck" +version = "1.25.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc0e56a716f1e132ff6bf4bdac1c944a3fcdc1cae65f70a4a2a1ac3b401d2d1f" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.3", +] + [[package]] name = "byteorder" version = "1.5.0" @@ -389,7 +427,7 @@ dependencies = [ "heck", "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -461,12 +499,33 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + [[package]] name = "core-foundation-sys" version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" +[[package]] +name = "core-graphics-types" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "libc", +] + [[package]] name = "cpp_demangle" version = "0.4.5" @@ -799,7 +858,16 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", +] + +[[package]] +name = "document-features" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61" +dependencies = [ + "litrs", ] [[package]] @@ -925,6 +993,33 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" +[[package]] +name = "foreign-types" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965" +dependencies = [ + "foreign-types-macros", + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-macros" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.3", +] + +[[package]] +name = "foreign-types-shared" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" + [[package]] name = "form_urlencoded" version = "1.2.2" @@ -989,7 +1084,7 @@ checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -1100,6 +1195,45 @@ dependencies = [ "stable_deref_trait", ] +[[package]] +name = "gpu-alloc" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45cf04b2726f02df5508c6de726acdc90cdf97ac771a9a0ffd8ba10a6e696bf9" +dependencies = [ + "bitflags 2.11.0", + "gpu-alloc-types", +] + +[[package]] +name = "gpu-alloc-types" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2bbed164dd10ed526c2e4fe3e721ca4a71c61730e5aafac6844b417b3227058" +dependencies = [ + "bitflags 2.11.0", +] + +[[package]] +name = "gpu-descriptor" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b89c83349105e3732062a895becfc71a8f921bb71ecbbdd8ff99263e3b53a0ca" +dependencies = [ + "bitflags 2.11.0", + "gpu-descriptor-types", + "hashbrown 0.15.5", +] + +[[package]] +name = "gpu-descriptor-types" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91" +dependencies = [ + "bitflags 2.11.0", +] + [[package]] name = "half" version = "2.7.1" @@ -1176,7 +1310,7 @@ dependencies = [ "js-sys", "log", "wasm-bindgen", - "windows-core", + "windows-core 0.62.2", ] [[package]] @@ -1449,6 +1583,16 @@ version = "0.2.182" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112" +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + [[package]] name = "libm" version = "0.2.16" @@ -1484,6 +1628,12 @@ version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77" +[[package]] +name = "litrs" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092" + [[package]] name = "lock_api" version = "0.4.14" @@ -1521,7 +1671,7 @@ dependencies = [ "quote", "regex-syntax", "rustc_version", - "syn", + "syn 2.0.115", ] [[package]] @@ -1567,12 +1717,14 @@ dependencies = [ "insta", "logos", "naga", + "pollster", "serde_json", "tar", "ureq", "uuid", "wasm-encoder 0.227.1", "wasmparser 0.227.1", + "wgpu", ] [[package]] @@ -1619,6 +1771,15 @@ dependencies = [ "libc", ] +[[package]] +name = "malloc_buf" +version = "0.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" +dependencies = [ + "libc", +] + [[package]] name = "maybe-owned" version = "0.3.4" @@ -1640,6 +1801,21 @@ dependencies = [ "rustix 1.1.3", ] +[[package]] +name = "metal" +version = "0.31.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f569fb946490b5743ad69813cb19629130ce9374034abe31614a36402d18f99e" +dependencies = [ + "bitflags 2.11.0", + "block", + "core-graphics-types", + "foreign-types", + "log", + "objc", + "paste", +] + [[package]] name = "miniz_oxide" version = "0.8.9" @@ -1680,6 +1856,7 @@ dependencies = [ "num-traits", "once_cell", "rustc-hash 1.1.0", + "spirv", "strum", "thiserror 2.0.18", "unicode-ident", @@ -1716,6 +1893,15 @@ dependencies = [ "libm", ] +[[package]] +name = "objc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1" +dependencies = [ + "malloc_buf", +] + [[package]] name = "object" version = "0.36.7" @@ -1755,6 +1941,15 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" +[[package]] +name = "ordered-float" +version = "4.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951" +dependencies = [ + "num-traits", +] + [[package]] name = "owo-colors" version = "4.2.3" @@ -1813,7 +2008,7 @@ checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -1828,6 +2023,18 @@ version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" +[[package]] +name = "pollster" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3" + +[[package]] +name = "portable-atomic" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85" + [[package]] name = "postcard" version = "1.1.3" @@ -1865,7 +2072,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" dependencies = [ "proc-macro2", - "syn", + "syn 2.0.115", ] [[package]] @@ -1877,6 +2084,12 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "profiling" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5" + [[package]] name = "psm" version = "0.1.30" @@ -1963,6 +2176,12 @@ dependencies = [ "rand_core", ] +[[package]] +name = "raw-window-handle" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539" + [[package]] name = "rayon" version = "1.11.0" @@ -2055,6 +2274,12 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "renderdoc-sys" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832" + [[package]] name = "ring" version = "0.17.14" @@ -2248,7 +2473,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -2272,7 +2497,7 @@ checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -2357,6 +2582,15 @@ dependencies = [ "windows-sys 0.60.2", ] +[[package]] +name = "spirv" +version = "0.3.0+sdk-1.3.268.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eda41003dc44290527a59b13432d4a0379379fa074b70174882adfbdfd917844" +dependencies = [ + "bitflags 2.11.0", +] + [[package]] name = "sptr" version = "0.3.2" @@ -2369,6 +2603,12 @@ version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + [[package]] name = "str_indices" version = "0.4.4" @@ -2400,7 +2640,7 @@ dependencies = [ "proc-macro2", "quote", "rustversion", - "syn", + "syn 2.0.115", ] [[package]] @@ -2420,6 +2660,17 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "syn" +version = "3.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + [[package]] name = "synstructure" version = "0.13.2" @@ -2428,7 +2679,7 @@ checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -2512,7 +2763,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -2523,7 +2774,7 @@ checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -2561,7 +2812,7 @@ checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -2669,7 +2920,7 @@ checksum = "84fd902d4e0b9a4b27f2f440108dc034e1758628a9b702f8ec61ad66355422fa" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -2697,7 +2948,7 @@ checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -2717,7 +2968,7 @@ checksum = "70977707304198400eb4835a78f6a9f928bf41bba420deb8fdb175cd965d77a7" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -2876,7 +3127,7 @@ dependencies = [ "bumpalo", "proc-macro2", "quote", - "syn", + "syn 2.0.115", "wasm-bindgen-shared", ] @@ -3097,7 +3348,7 @@ dependencies = [ "anyhow", "proc-macro2", "quote", - "syn", + "syn 2.0.115", "wasmtime-component-util", "wasmtime-wit-bindgen", "wit-parser 0.221.3", @@ -3222,7 +3473,7 @@ checksum = "86ff86db216dc0240462de40c8290887a613dddf9685508eb39479037ba97b5b" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -3344,6 +3595,129 @@ dependencies = [ "rustls-pki-types", ] +[[package]] +name = "wgpu" +version = "25.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec8fb398f119472be4d80bc3647339f56eb63b2a331f6a3d16e25d8144197dd9" +dependencies = [ + "arrayvec", + "bitflags 2.11.0", + "cfg_aliases", + "document-features", + "hashbrown 0.15.5", + "js-sys", + "log", + "parking_lot", + "portable-atomic", + "profiling", + "raw-window-handle", + "smallvec", + "static_assertions", + "wasm-bindgen", + "web-sys", + "wgpu-core", + "wgpu-hal", + "wgpu-types", +] + +[[package]] +name = "wgpu-core" +version = "25.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7b882196f8368511d613c6aeec80655160db6646aebddf8328879a88d54e500" +dependencies = [ + "arrayvec", + "bit-set", + "bit-vec", + "bitflags 2.11.0", + "cfg_aliases", + "document-features", + "hashbrown 0.15.5", + "indexmap", + "log", + "naga", + "once_cell", + "parking_lot", + "portable-atomic", + "profiling", + "raw-window-handle", + "rustc-hash 1.1.0", + "smallvec", + "thiserror 2.0.18", + "wgpu-core-deps-apple", + "wgpu-core-deps-windows-linux-android", + "wgpu-hal", + "wgpu-types", +] + +[[package]] +name = "wgpu-core-deps-apple" +version = "25.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfd488b3239b6b7b185c3b045c39ca6bf8af34467a4c5de4e0b1a564135d093d" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-core-deps-windows-linux-android" +version = "25.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cba5fb5f7f9c98baa7c889d444f63ace25574833df56f5b817985f641af58e46" +dependencies = [ + "wgpu-hal", +] + +[[package]] +name = "wgpu-hal" +version = "25.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f968767fe4d3d33747bbd1473ccd55bf0f6451f55d733b5597e67b5deab4ad17" +dependencies = [ + "android_system_properties", + "arrayvec", + "ash", + "bitflags 2.11.0", + "block", + "bytemuck", + "cfg_aliases", + "core-graphics-types", + "gpu-alloc", + "gpu-descriptor", + "hashbrown 0.15.5", + "libc", + "libloading", + "log", + "metal", + "naga", + "objc", + "ordered-float", + "parking_lot", + "portable-atomic", + "profiling", + "raw-window-handle", + "renderdoc-sys", + "smallvec", + "thiserror 2.0.18", + "wgpu-types", + "windows", +] + +[[package]] +name = "wgpu-types" +version = "25.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2aa49460c2a8ee8edba3fca54325540d904dd85b2e086ada762767e17d06e8bc" +dependencies = [ + "bitflags 2.11.0", + "bytemuck", + "js-sys", + "log", + "thiserror 2.0.18", + "web-sys", +] + [[package]] name = "wiggle" version = "29.0.1" @@ -3370,7 +3744,7 @@ dependencies = [ "proc-macro2", "quote", "shellexpand", - "syn", + "syn 2.0.115", "witx", ] @@ -3382,7 +3756,7 @@ checksum = "08c5c473d4198e6c2d377f3809f713ff0c110cab88a0805ae099a82119ee250c" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", "wiggle-generate", ] @@ -3435,17 +3809,51 @@ dependencies = [ "wasmtime-environ", ] +[[package]] +name = "windows" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6" +dependencies = [ + "windows-core 0.58.0", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-core" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99" +dependencies = [ + "windows-implement 0.58.0", + "windows-interface 0.58.0", + "windows-result 0.2.0", + "windows-strings 0.1.0", + "windows-targets 0.52.6", +] + [[package]] name = "windows-core" version = "0.62.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" dependencies = [ - "windows-implement", - "windows-interface", + "windows-implement 0.60.2", + "windows-interface 0.59.3", "windows-link", - "windows-result", - "windows-strings", + "windows-result 0.4.1", + "windows-strings 0.5.1", +] + +[[package]] +name = "windows-implement" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", ] [[package]] @@ -3456,7 +3864,18 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", +] + +[[package]] +name = "windows-interface" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", ] [[package]] @@ -3467,7 +3886,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -3476,6 +3895,15 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" +[[package]] +name = "windows-result" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e" +dependencies = [ + "windows-targets 0.52.6", +] + [[package]] name = "windows-result" version = "0.4.1" @@ -3485,6 +3913,16 @@ dependencies = [ "windows-link", ] +[[package]] +name = "windows-strings" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10" +dependencies = [ + "windows-result 0.2.0", + "windows-targets 0.52.6", +] + [[package]] name = "windows-strings" version = "0.5.1" @@ -3708,7 +4146,7 @@ dependencies = [ "heck", "indexmap", "prettyplease", - "syn", + "syn 2.0.115", "wasm-metadata", "wit-bindgen-core", "wit-component", @@ -3724,7 +4162,7 @@ dependencies = [ "prettyplease", "proc-macro2", "quote", - "syn", + "syn 2.0.115", "wit-bindgen-core", "wit-bindgen-rust", ] @@ -3831,7 +4269,7 @@ checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", "synstructure", ] @@ -3852,7 +4290,7 @@ checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] @@ -3872,7 +4310,7 @@ checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", "synstructure", ] @@ -3912,7 +4350,7 @@ checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.115", ] [[package]] diff --git a/crates/loon-lang/Cargo.toml b/crates/loon-lang/Cargo.toml index 7a05f03..5106c0f 100644 --- a/crates/loon-lang/Cargo.toml +++ b/crates/loon-lang/Cargo.toml @@ -6,6 +6,10 @@ edition.workspace = true [features] default = [] pkg-fetch = ["dep:blake3", "dep:ureq", "dep:flate2", "dep:tar", "dep:uuid"] +# Real GPU execution through wgpu (Metal here, Vulkan/DX12 elsewhere). +# Off by default: it is a large dependency, and every other placement mode +# works without it. +gpu = ["dep:wgpu", "dep:pollster"] native = [ "dep:cranelift-codegen", "dep:cranelift-frontend", @@ -31,6 +35,13 @@ cranelift-frontend = { version = "0.116", optional = true } cranelift-jit = { version = "0.116", optional = true } cranelift-module = { version = "0.116", optional = true } cranelift-native = { version = "0.116", optional = true } +wgpu = { version = "25", optional = true, default-features = false, features = [ + "metal", + "vulkan", + "wgsl", +] } + +pollster = { version = "0.4", optional = true } [dev-dependencies] insta = "1" diff --git a/crates/loon-lang/src/eir/gpu.rs b/crates/loon-lang/src/eir/gpu.rs new file mode 100644 index 0000000..43d2323 --- /dev/null +++ b/crates/loon-lang/src/eir/gpu.rs @@ -0,0 +1,444 @@ +//! Running a kernel on an actual GPU. +//! +//! Everything up to here has been about *where* a kernel could run. This is +//! the part that puts one on hardware: the WGSL from `eir::wgsl` becomes a +//! compute pipeline, buffers become GPU allocations, and a dispatch happens. +//! +//! Through wgpu, so the same kernel reaches Metal on this machine, Vulkan on a +//! Linux box, DX12 on Windows, and WebGPU in a browser tab. That last one is +//! the interesting entry in the list: it is a target a compiler emitting PTX +//! and AMDGCN cannot reach at all, and it comes free from having chosen a +//! portable shading language rather than a vendor's. +//! +//! The device is discovered lazily and its absence is not an error. A machine +//! with no GPU runs the same programs through the CPU path, so nothing in the +//! test suite depends on hardware being present — it only gets *checked* on +//! hardware when hardware is there. + +use super::layout::DType; +use super::vm::{BufData, Buffer}; +use super::wgsl::ArgKind; + +/// A GPU we can dispatch to. +pub struct Gpu { + device: wgpu::Device, + queue: wgpu::Queue, + name: String, +} + +/// What went wrong, in a sentence a person can act on. +#[derive(Debug, Clone)] +pub struct Error(pub String); + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.0) + } +} + +impl std::error::Error for Error {} + +/// One argument, as the GPU will see it. +pub enum GpuArg<'a> { + /// A buffer, uploaded before the dispatch and read back after if written. + Buffer { data: &'a Buffer, writable: bool }, + /// A number, packed into the uniform block. + Scalar(f32), +} + +impl Gpu { + /// Find a GPU, or explain why there isn't one. + /// + /// Called once and cached by the caller: adapter enumeration is slow + /// enough that doing it per launch would dominate any kernel worth + /// offloading. + pub fn open() -> Result { + let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default()); + let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions { + power_preference: wgpu::PowerPreference::HighPerformance, + compatible_surface: None, + force_fallback_adapter: false, + })) + .map_err(|e| Error(format!("no GPU adapter available: {e}")))?; + + let info = adapter.get_info(); + let name = format!("{} ({:?})", info.name, info.backend); + + let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor { + label: Some("loon"), + required_features: wgpu::Features::empty(), + required_limits: wgpu::Limits::downlevel_defaults(), + memory_hints: wgpu::MemoryHints::Performance, + trace: wgpu::Trace::Off, + })) + .map_err(|e| Error(format!("could not open the GPU device: {e}")))?; + + Ok(Gpu { + device, + queue, + name, + }) + } + + /// A human-readable name for the device, for `--place-stats` and errors. + pub fn name(&self) -> &str { + &self.name + } + + /// Run `shader` over `n` work items with `args`. + /// + /// Returns the bytes read back from each writable buffer, paired with the + /// argument position it came from. The caller decides what to do with + /// them — which keeps this function free of any opinion about where the + /// host's copy lives, and makes the transfer itself something a test can + /// look at directly. + /// + /// Blocking: the dispatch is submitted and awaited before returning. A + /// non-blocking form belongs with the scheduler, not here. + pub fn run( + &self, + shader: &str, + entry: &str, + n: u32, + args: &[GpuArg<'_>], + ) -> Result)>, Error> { + let module = self + .device + .create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some(entry), + source: wgpu::ShaderSource::Wgsl(shader.into()), + }); + + // The uniform block is `n` followed by every scalar argument, in order + // — matching what the emitter wrote into `struct Params`. + let mut uniform: Vec = (n as i32).to_le_bytes().to_vec(); + for arg in args.iter() { + if let GpuArg::Scalar(v) = arg { + uniform.extend_from_slice(&v.to_le_bytes()); + } + } + // WGSL requires a uniform buffer to be a multiple of 16 bytes. + while uniform.len() % 16 != 0 { + uniform.push(0); + } + let uniform_buf = self.create_buffer( + "params", + &uniform, + wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + ); + + // Upload every buffer argument, remembering which ones have to come + // back and how big they are. + let mut storage: Vec = Vec::new(); + let mut readback: Vec<(usize, u64)> = Vec::new(); + for (i, arg) in args.iter().enumerate() { + if let GpuArg::Buffer { data, writable } = arg { + let bytes = data.to_bytes(); + let usage = wgpu::BufferUsages::STORAGE + | wgpu::BufferUsages::COPY_DST + | wgpu::BufferUsages::COPY_SRC; + let buf = self.create_buffer(&format!("b{i}"), &bytes, usage); + if *writable { + readback.push((i, bytes.len() as u64)); + } + storage.push(buf); + } + } + + // Bindings: 0 is the uniform block, storage buffers follow in order. + let mut entries: Vec = vec![wgpu::BindGroupEntry { + binding: 0, + resource: uniform_buf.as_entire_binding(), + }]; + for (slot, buf) in storage.iter().enumerate() { + entries.push(wgpu::BindGroupEntry { + binding: slot as u32 + 1, + resource: buf.as_entire_binding(), + }); + } + + let pipeline = self + .device + .create_compute_pipeline(&wgpu::ComputePipelineDescriptor { + label: Some(entry), + layout: None, + module: &module, + entry_point: Some(entry), + compilation_options: Default::default(), + cache: None, + }); + + let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("args"), + layout: &pipeline.get_bind_group_layout(0), + entries: &entries, + }); + + let mut encoder = self + .device + .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("run") }); + { + let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { + label: Some(entry), + timestamp_writes: None, + }); + pass.set_pipeline(&pipeline); + pass.set_bind_group(0, &bind_group, &[]); + // The shader's workgroup size is 64; round up and let the bounds + // check in the shader discard the overshoot. + pass.dispatch_workgroups(n.div_ceil(64).max(1), 1, 1); + } + + // Copy every written buffer into a staging buffer the host can map. + let staging: Vec<(usize, wgpu::Buffer)> = readback + .iter() + .map(|(i, size)| { + let s = self.device.create_buffer(&wgpu::BufferDescriptor { + label: Some("readback"), + size: *size, + usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + (*i, s) + }) + .collect(); + for ((_, size), (slot, dst)) in readback.iter().zip(staging.iter()) { + let src = storage_for(args, *slot, &storage); + encoder.copy_buffer_to_buffer(src, 0, dst, 0, *size); + } + + self.queue.submit(Some(encoder.finish())); + + // Map each staging buffer and collect what came back. + let mut results: Vec<(usize, Vec)> = Vec::new(); + for (slot, dst) in &staging { + let slice = dst.slice(..); + let (tx, rx) = std::sync::mpsc::channel(); + slice.map_async(wgpu::MapMode::Read, move |r| { + let _ = tx.send(r); + }); + self.device + .poll(wgpu::PollType::Wait) + .map_err(|e| Error(format!("waiting for the GPU: {e:?}")))?; + match rx.recv() { + Ok(Ok(())) => {} + Ok(Err(e)) => return Err(Error(format!("mapping results: {e:?}"))), + Err(e) => return Err(Error(format!("the GPU never reported back: {e}"))), + } + let bytes = slice.get_mapped_range().to_vec(); + dst.unmap(); + results.push((*slot, bytes)); + } + + Ok(results) + } + + fn create_buffer(&self, label: &str, bytes: &[u8], usage: wgpu::BufferUsages) -> wgpu::Buffer { + use wgpu::util::DeviceExt as _; + // An empty buffer is invalid in wgpu; give it one padded element. + let padded; + let contents = if bytes.is_empty() { + padded = vec![0u8; 4]; + &padded[..] + } else { + bytes + }; + self.device + .create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: Some(label), + contents, + usage, + }) + } +} + +/// The storage buffer belonging to argument `slot`. +/// +/// Scalars occupy no binding, so the storage list is indexed by *buffer* +/// position rather than argument position — the same numbering the emitter +/// used, kept in one place so the two cannot drift. +fn storage_for<'a>( + args: &[GpuArg<'_>], + slot: usize, + storage: &'a [wgpu::Buffer], +) -> &'a wgpu::Buffer { + let idx = args + .iter() + .take(slot) + .filter(|a| matches!(a, GpuArg::Buffer { .. })) + .count(); + &storage[idx] +} + +/// Copy raw device bytes into a host buffer, converting if the buffer's +/// element type is wider than what the GPU computed. +/// +/// WGSL has no f64 or i64, so a 64-bit Loon buffer is computed in 32 bits on +/// the device. Widening on the way back is the honest completion of that: the +/// values really were f32, and pretending otherwise would hide precision the +/// program did not get. +fn write_back(buf: &mut Buffer, bytes: &[u8]) { + match &mut buf.data { + BufData::F32(v) => { + for (slot, chunk) in v.iter_mut().zip(bytes.chunks_exact(4)) { + *slot = f32::from_le_bytes(chunk.try_into().unwrap()); + } + } + BufData::I32(v) => { + for (slot, chunk) in v.iter_mut().zip(bytes.chunks_exact(4)) { + *slot = i32::from_le_bytes(chunk.try_into().unwrap()); + } + } + BufData::F64(v) => { + for (slot, chunk) in v.iter_mut().zip(bytes.chunks_exact(4)) { + *slot = f32::from_le_bytes(chunk.try_into().unwrap()) as f64; + } + } + BufData::I64(v) => { + for (slot, chunk) in v.iter_mut().zip(bytes.chunks_exact(4)) { + *slot = i32::from_le_bytes(chunk.try_into().unwrap()) as i64; + } + } + } +} + +/// The element type a buffer is given to the GPU as. +/// +/// 64-bit buffers are narrowed, because WGSL core has no 64-bit scalar. This +/// is reported rather than assumed: see `DType::gpu_ok`. +pub fn device_dtype(d: DType) -> DType { + match d { + DType::F64 => DType::F32, + DType::I64 => DType::I32, + other => other, + } +} + +/// Convert a buffer to the 32-bit form the device will hold. +pub fn narrow(buf: &Buffer) -> Buffer { + match &buf.data { + BufData::F64(v) => Buffer { + data: BufData::F32(v.iter().map(|x| *x as f32).collect()), + }, + BufData::I64(v) => Buffer { + data: BufData::I32(v.iter().map(|x| *x as i32).collect()), + }, + _ => buf.clone(), + } +} + +/// Describe an argument for the emitter, given what it actually is. +pub fn arg_kind(arg: &GpuArg<'_>) -> ArgKind { + match arg { + GpuArg::Buffer { data, writable } => ArgKind::Buffer { + dtype: device_dtype(data.dtype()), + writable: *writable, + }, + GpuArg::Scalar(_) => ArgKind::Scalar(DType::F32), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// Open a GPU, or skip. A machine without one is not a failing machine. + fn gpu_or_skip() -> Option { + match Gpu::open() { + Ok(g) => Some(g), + Err(e) => { + println!("SKIPPED: {e}"); + None + } + } + } + + const DOUBLE: &str = r#" +struct Params { n: i32, s0: f32, }; +@group(0) @binding(0) var params: Params; +@group(0) @binding(1) var b0: array; +@compute @workgroup_size(64) +fn main(@builtin(global_invocation_id) gid: vec3) { + let idx: i32 = i32(gid.x); + if (idx >= params.n) { return; } + b0[u32(idx)] = b0[u32(idx)] * params.s0; +} +"#; + + #[test] + fn a_kernel_runs_on_the_gpu_and_the_results_come_back() { + let Some(gpu) = gpu_or_skip() else { return }; + println!("device: {}", gpu.name()); + + let mut buf = Buffer { + data: BufData::F32(vec![1.0, 2.0, 3.0, 4.0]), + }; + let input = buf.clone(); + let args = vec![ + GpuArg::Scalar(3.0), + GpuArg::Buffer { + data: &input, + writable: true, + }, + ]; + let results = gpu.run(DOUBLE, "main", 4, &args).expect("dispatch"); + assert_eq!(results.len(), 1, "one writable buffer comes back"); + write_back(&mut buf, &results[0].1); + assert_eq!(buf.data, BufData::F32(vec![3.0, 6.0, 9.0, 12.0])); + } + + #[test] + fn work_that_does_not_fill_a_workgroup_still_stays_in_bounds() { + // A dispatch rounds up to whole workgroups, so a 3-element buffer runs + // 64 invocations. The bounds check in the shader is what keeps the + // other 61 from writing past the end. + let Some(gpu) = gpu_or_skip() else { return }; + let mut buf = Buffer { + data: BufData::F32(vec![1.0, 1.0, 1.0]), + }; + let input = buf.clone(); + let args = vec![ + GpuArg::Scalar(5.0), + GpuArg::Buffer { + data: &input, + writable: true, + }, + ]; + let results = gpu.run(DOUBLE, "main", 3, &args).expect("dispatch"); + write_back(&mut buf, &results[0].1); + assert_eq!(buf.data, BufData::F32(vec![5.0, 5.0, 5.0])); + } + + #[test] + fn a_read_only_buffer_is_not_copied_back() { + // Only what the kernel writes has to travel home. This is the same + // distinction the ownership pass draws, arriving at the hardware. + let Some(gpu) = gpu_or_skip() else { return }; + let src = Buffer { + data: BufData::F32(vec![1.0, 2.0]), + }; + let args = vec![ + GpuArg::Scalar(2.0), + GpuArg::Buffer { + data: &src, + writable: false, + }, + ]; + // The shader writes b0, but we declared it read-only here, so nothing + // is read back — the accounting follows the declaration. + let results = gpu.run(DOUBLE, "main", 2, &args).expect("dispatch"); + assert!(results.is_empty(), "nothing was declared writable"); + } + + #[test] + fn narrowing_is_explicit_about_what_the_device_can_hold() { + assert_eq!(device_dtype(DType::F64), DType::F32); + assert_eq!(device_dtype(DType::I64), DType::I32); + assert_eq!(device_dtype(DType::F32), DType::F32); + + let wide = Buffer { + data: BufData::F64(vec![1.5, 2.5]), + }; + assert_eq!(narrow(&wide).data, BufData::F32(vec![1.5, 2.5])); + } +} diff --git a/crates/loon-lang/src/eir/mod.rs b/crates/loon-lang/src/eir/mod.rs index 450b7e5..c789698 100644 --- a/crates/loon-lang/src/eir/mod.rs +++ b/crates/loon-lang/src/eir/mod.rs @@ -4,6 +4,8 @@ //! Every backend (Register VM, WASM, Cranelift) lowers from this IR. pub mod backend; +#[cfg(feature = "gpu")] +pub mod gpu; pub mod layout; pub mod lower; #[cfg(feature = "native")] diff --git a/crates/loon-lang/tests/gpu_end_to_end.rs b/crates/loon-lang/tests/gpu_end_to_end.rs new file mode 100644 index 0000000..65d84a5 --- /dev/null +++ b/crates/loon-lang/tests/gpu_end_to_end.rs @@ -0,0 +1,257 @@ +//! A Loon kernel, on a real GPU, agreeing with the CPU. +//! +//! Everything in the chain gets exercised: the `[kernel ...]` form, ownership +//! modes deciding which buffers are inputs, the WGSL emitter, and wgpu putting +//! the shader on whatever hardware this machine has. The result is compared +//! against the same kernel run through the interpreter, because a GPU that +//! computes something *different* quickly is not an optimization. +//! +//! Skipped, loudly, when there is no GPU. A machine without one is not a +//! failing machine, and a test that quietly passed in that case would be +//! worse than no test. + +#![cfg(feature = "gpu")] + +use loon_lang::check::Checker; +use loon_lang::eir::gpu::{self, Gpu, GpuArg}; +use loon_lang::eir::layout::DType; +use loon_lang::eir::lower::lower; +use loon_lang::eir::vm::{eval_eir, BufData, Buffer}; +use loon_lang::eir::wgsl; +use loon_lang::parser::parse; + +fn gpu_or_skip() -> Option { + match Gpu::open() { + Ok(g) => { + println!("device: {}", g.name()); + Some(g) + } + Err(e) => { + println!("SKIPPED — no GPU on this machine: {e}"); + None + } + } +} + +/// Compile the named kernel in `src` to WGSL and run it on the GPU. +fn run_on_gpu( + gpu_dev: &Gpu, + src: &str, + kernel: &str, + n: u32, + scalars: &[f32], + buffers: &[Buffer], +) -> Vec { + let exprs = parse(src).expect("parses"); + let mut checker = Checker::new(); + let errors = checker.check_program(&exprs); + assert!(errors.is_empty(), "check errors: {errors:?}"); + let module = lower(&checker); + let func = module + .funcs + .iter() + .find(|f| f.name.as_deref() == Some(kernel)) + .expect("kernel lowered"); + + let kinds = wgsl::infer_arg_kinds(&module, func.id, DType::F32); + let shader = wgsl::emit(&module, func.id, &kinds).expect("emits WGSL"); + + // Narrow every buffer to what the device can hold, in argument order. + // (WGSL core has no 64-bit scalar, so an f64 buffer is computed in f32.) + let owned: Vec = buffers.iter().map(gpu::narrow).collect(); + + // Then describe each argument: scalars from `scalars`, buffers from + // `owned`, in the order the kernel declared them. + let mut scalar_iter = scalars.iter(); + let mut owned_iter = owned.iter(); + let args: Vec = kinds + .iter() + .map(|kind| match kind { + wgsl::ArgKind::Scalar(_) => { + GpuArg::Scalar(*scalar_iter.next().expect("a scalar argument")) + } + wgsl::ArgKind::Buffer { writable, .. } => GpuArg::Buffer { + data: owned_iter.next().expect("a buffer argument"), + writable: *writable, + }, + }) + .collect(); + + let results = gpu_dev.run(&shader, "main", n, &args).expect("dispatch"); + + let mut out = owned.clone(); + for (slot, bytes) in results { + // `slot` is an argument index; find which buffer that was. + let buffer_index = kinds + .iter() + .take(slot) + .filter(|k| matches!(k, wgsl::ArgKind::Buffer { .. })) + .count(); + let target = &mut out[buffer_index]; + let n = target.len(); + let mut vals: Vec = bytes + .chunks_exact(4) + .map(|c| f32::from_le_bytes(c.try_into().unwrap())) + .collect(); + vals.truncate(n); + target.data = BufData::F32(vals); + } + out +} + +/// The same kernel through the interpreter, as the reference answer. +fn run_on_cpu(src: &str, main: &str) -> Vec { + eval_eir(&format!("{src} {main}")).expect("cpu run").output +} + +const SAXPY: &str = "[kernel saxpy [i a x y out] \ + [put out i [+ [* a [at x i]] [at y i]]]]"; + +#[test] +fn saxpy_agrees_between_the_gpu_and_the_cpu() { + let Some(dev) = gpu_or_skip() else { return }; + + let n = 256usize; + let x: Vec = (0..n).map(|i| i as f32).collect(); + let y: Vec = (0..n).map(|i| (i * 2) as f32).collect(); + let out = vec![0.0f32; n]; + + let results = run_on_gpu( + &dev, + SAXPY, + "saxpy", + n as u32, + &[3.0], + &[ + Buffer { + data: BufData::F32(x.clone()), + }, + Buffer { + data: BufData::F32(y.clone()), + }, + Buffer { + data: BufData::F32(out), + }, + ], + ); + + let BufData::F32(got) = &results[2].data else { + panic!("expected an f32 buffer"); + }; + let expected: Vec = (0..n).map(|i| 3.0 * x[i] + y[i]).collect(); + assert_eq!(got.len(), n); + for (i, (g, e)) in got.iter().zip(expected.iter()).enumerate() { + assert!( + (g - e).abs() < 1e-4, + "element {i}: GPU gave {g}, expected {e}" + ); + } +} + +#[test] +fn the_gpu_result_matches_what_the_interpreter_computes() { + // Not "close to a formula I wrote in Rust" — the same Loon program, run + // both ways. This is the comparison that would catch the emitter and the + // interpreter disagreeing about what a kernel means. + let Some(dev) = gpu_or_skip() else { return }; + + let cpu = run_on_cpu( + SAXPY, + "[fn main [] \ + [let x [buf #[0 1 2 3 4 5 6 7]]] \ + [let y [buf #[0 2 4 6 8 10 12 14]]] \ + [let mut out [buf-zeros 8]] \ + [Place.run saxpy 8 #[3.0 x y out]] \ + [IO.println [Place.read out]]]", + ); + + let results = run_on_gpu( + &dev, + SAXPY, + "saxpy", + 8, + &[3.0], + &[ + Buffer { + data: BufData::F32((0..8).map(|i| i as f32).collect()), + }, + Buffer { + data: BufData::F32((0..8).map(|i| (i * 2) as f32).collect()), + }, + Buffer { + data: BufData::F32(vec![0.0; 8]), + }, + ], + ); + let BufData::F32(got) = &results[2].data else { + panic!("expected an f32 buffer"); + }; + let rendered = format!( + "#[{}]", + got.iter() + .map(|v| { + if v.fract() == 0.0 { + format!("{}", *v as i64) + } else { + format!("{v}") + } + }) + .collect::>() + .join(" ") + ); + assert_eq!(cpu, vec![rendered]); +} + +#[test] +fn a_branching_kernel_runs_on_the_gpu() { + // Control flow goes through the block dispatcher in the emitted shader, + // so this exercises a different path than straight-line arithmetic. + let Some(dev) = gpu_or_skip() else { return }; + + let src = "[kernel clamp [i lo hi b] \ + [let v [at b i]] \ + [put b i [if [< v lo] lo [if [> v hi] hi v]]]]"; + let input: Vec = vec![-5.0, 0.25, 0.5, 9.0]; + let results = run_on_gpu( + &dev, + src, + "clamp", + 4, + &[0.0, 1.0], + &[Buffer { + data: BufData::F32(input), + }], + ); + let BufData::F32(got) = &results[0].data else { + panic!("expected an f32 buffer"); + }; + assert_eq!(got, &vec![0.0, 0.25, 0.5, 1.0]); +} + +#[test] +fn a_large_launch_covers_every_element() { + // Enough work items to span many workgroups, so a mistake in the dispatch + // arithmetic shows up as untouched elements at the end. + let Some(dev) = gpu_or_skip() else { return }; + + let n = 10_000usize; + let results = run_on_gpu( + &dev, + "[kernel fill [i b] [put b i 7.0]]", + "fill", + n as u32, + &[], + &[Buffer { + data: BufData::F32(vec![0.0; n]), + }], + ); + let BufData::F32(got) = &results[0].data else { + panic!("expected an f32 buffer"); + }; + assert_eq!(got.len(), n); + assert!( + got.iter().all(|v| *v == 7.0), + "every element should have been written; {} were not", + got.iter().filter(|v| **v != 7.0).count() + ); +} From 3f55aa4b5edc7662ffe14d90318cfb6b63da3f73 Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 11:21:32 -0400 Subject: [PATCH 06/25] --place gpu: the same program, on Metal MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `Place.run` now dispatches to the GPU when the mode says so. The sample that has been running on the CPU since M1 runs unchanged: loon run samples/place/saxpy.oo --place cpu → #[0 5 10 15 20 25 30 35] loon run samples/place/saxpy.oo --place device → #[0 5 10 15 20 25 30 35] loon run samples/place/saxpy.oo --place gpu → #[0 5 10 15 20 25 30 35] Not one character of the program differs between those, and the residency handler written in M2 against no hardware at all now decides what an Apple M4 Max actually copies: eight launches over one buffer cost eight uploads with no policy and one upload under place/resident, on the GPU, same answer. Residency accounting is shared between the simulated device and the real one, because "how many times did these bytes cross the boundary" is a property of placement rather than of any particular device. That is why the policy did not need rewriting when real hardware arrived. The refusal test found a bug in this integration worth keeping: a buffer passed to a parameter the kernel multiplies by was silently becoming 0.0, because scalars and buffers were drawn from separate lists without checking that each argument matched the shape the kernel body implies. It now says which argument disagrees. A confident wrong answer is the exact failure this design exists to prevent, and it very nearly shipped inside it. Without the `gpu` feature, asking for `--place gpu` says the build has no GPU support rather than quietly running on the CPU. Co-Authored-By: Claude Fable 5 --- crates/loon-cli/Cargo.toml | 5 + crates/loon-lang/src/eir/place.rs | 17 ++- crates/loon-lang/src/eir/vm.rs | 159 ++++++++++++++++++++++- crates/loon-lang/tests/gpu_end_to_end.rs | 106 +++++++++++++++ 4 files changed, 282 insertions(+), 5 deletions(-) diff --git a/crates/loon-cli/Cargo.toml b/crates/loon-cli/Cargo.toml index e4fca5a..e9ad705 100644 --- a/crates/loon-cli/Cargo.toml +++ b/crates/loon-cli/Cargo.toml @@ -7,6 +7,11 @@ edition.workspace = true name = "loon" path = "src/main.rs" +[features] +default = [] +# Real GPU execution for `loon run --place gpu`. +gpu = ["loon-lang/gpu"] + [dependencies] loon-lang = { path = "../loon-lang", features = ["pkg-fetch", "native"] } clap = { version = "4", features = ["derive"] } diff --git a/crates/loon-lang/src/eir/place.rs b/crates/loon-lang/src/eir/place.rs index a3fac36..707e0a0 100644 --- a/crates/loon-lang/src/eir/place.rs +++ b/crates/loon-lang/src/eir/place.rs @@ -143,6 +143,13 @@ pub enum Mode { /// Right here. There is one memory, so nothing is ever transferred. #[default] Cpu, + /// A real GPU, through wgpu. + /// + /// Requires the `gpu` feature; without it, asking for this mode is an + /// error that says so rather than a silent fall back to the CPU. Being + /// told your program did not run where you asked is worth more than a + /// result that arrived by a route you did not choose. + Gpu, /// A discrete device with separate memory. /// /// The arithmetic still happens on the host — this is not a GPU — but the @@ -158,14 +165,22 @@ impl Mode { match s { "cpu" | "serial" | "here" => Some(Mode::Cpu), "device" | "sim" => Some(Mode::Device), + "gpu" | "metal" | "wgpu" => Some(Mode::Gpu), _ => None, } } + /// Whether this mode has a memory separate from the host's, so that + /// transfers are a real cost worth accounting for. + pub fn has_device_memory(self) -> bool { + matches!(self, Mode::Device | Mode::Gpu) + } + pub fn name(self) -> &'static str { match self { Mode::Cpu => "cpu", Mode::Device => "device", + Mode::Gpu => "gpu", } } } @@ -301,7 +316,7 @@ mod tests { #[test] fn mode_names_round_trip() { - for m in [Mode::Cpu, Mode::Device] { + for m in [Mode::Cpu, Mode::Device, Mode::Gpu] { assert_eq!(Mode::parse(m.name()), Some(m)); } assert_eq!(Mode::parse("sim"), Some(Mode::Device)); diff --git a/crates/loon-lang/src/eir/vm.rs b/crates/loon-lang/src/eir/vm.rs index e8c4ccc..2c73b29 100644 --- a/crates/loon-lang/src/eir/vm.rs +++ b/crates/loon-lang/src/eir/vm.rs @@ -426,6 +426,9 @@ pub struct Vm { pub place_mode: crate::eir::place::Mode, /// Device-side residency, when running in device mode. place_device: crate::eir::place::Device, + /// The GPU, opened on first use and kept for the rest of the run. + #[cfg(feature = "gpu")] + gpu: Option>, /// String constants resolved to heap indices. string_cache: HashMap, /// Interns string *objects* by content, so structurally-equal strings share @@ -533,6 +536,8 @@ impl Vm { place_stats: crate::eir::place::PlaceStats::default(), place_mode: crate::eir::place::Mode::default(), place_device: crate::eir::place::Device::default(), + #[cfg(feature = "gpu")] + gpu: None, recorder: None, replay: None, runtime_syms: Vec::new(), @@ -781,7 +786,7 @@ impl Vm { // the kernel can touch it. An argument that is already resident costs // nothing — and counting those hits is what turns a residency policy // from a claim into a measurement. - if self.place_mode == crate::eir::place::Mode::Device { + if self.place_mode.has_device_memory() { for (i, arg) in rest.iter().enumerate() { let Some((id, bytes, dtype)) = self.buffer_info(*arg) else { continue; @@ -811,6 +816,23 @@ impl Vm { } } + // On a GPU the kernel runs there, not here. Everything above — the + // residency bookkeeping, the launch accounting — is the same either + // way, because those are properties of placement rather than of any + // particular device. + if self.place_mode == crate::eir::place::Mode::Gpu { + self.place_run_gpu(func_id, &rest, n)?; + if self.place_mode.has_device_memory() { + for arg in &rest { + if let Some((id, _, _)) = self.buffer_info(*arg) { + self.place_device.mark_dirty(id); + } + } + self.place_device.evict_unpinned(); + } + return Ok(Val::UNIT); + } + let mut call_args = Vec::with_capacity(rest.len() + 1); for i in 0..n { call_args.clear(); @@ -824,7 +846,7 @@ impl Vm { // are the *default* behaviour of a device that has not been told // anything — which is precisely what a residency handler exists to // change, by pinning what it knows will be wanted again. - if self.place_mode == crate::eir::place::Mode::Device { + if self.place_mode.has_device_memory() { for arg in &rest { if let Some((id, _, _)) = self.buffer_info(*arg) { self.place_device.mark_dirty(id); @@ -836,6 +858,133 @@ impl Vm { Ok(Val::UNIT) } + /// Run a kernel on the GPU: emit its shader, ship the arguments, dispatch, + /// and copy back whatever it wrote. + #[cfg(feature = "gpu")] + fn place_run_gpu(&mut self, func_id: FuncId, rest: &[Val], n: i64) -> Result<(), VmError> { + use crate::eir::gpu::{self, GpuArg}; + + let kinds = crate::eir::wgsl::infer_arg_kinds(&self.module, func_id, DType::F32); + if kinds.len() != rest.len() { + return Err(self.place_error(format!( + "the kernel takes {} arguments but {} were given", + kinds.len(), + rest.len() + ))); + } + + let shader = crate::eir::wgsl::emit(&self.module, func_id, &kinds) + .map_err(|e| self.place_error(format!("this kernel cannot run on a GPU: {e}")))?; + + // Buffers travel as their 32-bit form; scalars are packed by value. + // + // Each argument is checked against the shape the kernel body implies. + // A buffer handed to a parameter the kernel multiplies by has no + // sensible reading, and defaulting it to zero would produce a + // confident wrong answer — the exact failure this whole design is + // supposed to make impossible. + let mut owned: Vec = Vec::new(); + let mut scalars: Vec = Vec::new(); + for (i, val) in rest.iter().enumerate() { + let is_buffer = matches!(self.get_obj(*val), Some(Obj::Buffer(_))); + let wants_buffer = matches!(kinds[i], crate::eir::wgsl::ArgKind::Buffer { .. }); + if is_buffer != wants_buffer { + let (given, wanted) = if is_buffer { + ("a buffer", "a number") + } else { + ("a number", "a buffer") + }; + return Err(self.place_error(format!( + "argument {} is {given}, but the kernel uses it as {wanted}", + i + 1 + ))); + } + match self.get_obj(*val) { + Some(Obj::Buffer(b)) => owned.push(gpu::narrow(b)), + _ => { + let x = if val.is_int() { + val.as_int() as f32 + } else if val.is_float() { + val.as_float() as f32 + } else { + return Err(self.place_error(format!( + "argument {} is neither a buffer nor a number", + i + 1 + ))); + }; + scalars.push(x); + } + } + } + + let device = self.gpu_device()?; + let mut scalar_iter = scalars.iter(); + let mut owned_iter = owned.iter(); + let gpu_args: Vec = kinds + .iter() + .map(|k| match k { + crate::eir::wgsl::ArgKind::Scalar(_) => { + GpuArg::Scalar(scalar_iter.next().copied().unwrap_or(0.0)) + } + crate::eir::wgsl::ArgKind::Buffer { writable, .. } => GpuArg::Buffer { + data: owned_iter.next().expect("a buffer argument"), + writable: *writable, + }, + }) + .collect(); + + let results = device + .run(&shader, "main", n.max(0) as u32, &gpu_args) + .map_err(|e| self.place_error(format!("the GPU refused the launch: {e}")))?; + + // Copy results home, into the host buffer each one came from. + for (slot, bytes) in results { + let Some(val) = rest.get(slot) else { continue }; + let ptr = val.as_ptr(); + let Some(Obj::Buffer(buf)) = self.heap.get_mut(ptr) else { + continue; + }; + let len = buf.len(); + let vals: Vec = bytes + .chunks_exact(4) + .map(|c| f32::from_le_bytes(c.try_into().unwrap())) + .take(len) + .collect(); + for (i, v) in vals.into_iter().enumerate() { + buf.set(i, Val::float(v as f64)); + } + } + Ok(()) + } + + /// Without the `gpu` feature there is no GPU, and saying so plainly beats + /// running somewhere the caller did not ask for. + #[cfg(not(feature = "gpu"))] + fn place_run_gpu(&mut self, _func: FuncId, _rest: &[Val], _n: i64) -> Result<(), VmError> { + Err(self.place_error( + "this build has no GPU support; rebuild with `--features gpu`, or use \ + `--place cpu`" + .to_string(), + )) + } + + /// The GPU, opened once and kept. + #[cfg(feature = "gpu")] + fn gpu_device(&mut self) -> Result, VmError> { + if let Some(g) = &self.gpu { + return Ok(g.clone()); + } + let g = std::rc::Rc::new( + crate::eir::gpu::Gpu::open().map_err(|e| self.place_error(e.to_string()))?, + ); + self.gpu = Some(g.clone()); + Ok(g) + } + + fn place_error(&self, message: String) -> VmError { + VmError::new(VmErrorKind::BuiltinType(message)).with_span(self.current_span) + } + /// Heap slot, byte length, and element type of a buffer value. fn buffer_info(&self, val: Val) -> Option<(usize, u64, DType)> { match self.get_obj(val) { @@ -3764,7 +3913,9 @@ impl Vm { // saying so keeps the two modes comparable. let must_transfer = match self.place_mode { crate::eir::place::Mode::Cpu => true, - crate::eir::place::Mode::Device => self.place_device.is_dirty(id), + crate::eir::place::Mode::Device | crate::eir::place::Mode::Gpu => { + self.place_device.is_dirty(id) + } }; if must_transfer { self.place_device.clear_dirty(id); @@ -3798,7 +3949,7 @@ impl Vm { // Accepts a buffer or a vector of them, so a handler can pin a // kernel's entire argument list in one operation. let target = args.first().copied().unwrap_or(Val::UNIT); - if self.place_mode == crate::eir::place::Mode::Device { + if self.place_mode.has_device_memory() { let pinning = op == "pin"; let ids: Vec = match self.get_obj(target) { Some(Obj::Vec(v)) => v diff --git a/crates/loon-lang/tests/gpu_end_to_end.rs b/crates/loon-lang/tests/gpu_end_to_end.rs index 65d84a5..1183304 100644 --- a/crates/loon-lang/tests/gpu_end_to_end.rs +++ b/crates/loon-lang/tests/gpu_end_to_end.rs @@ -255,3 +255,109 @@ fn a_large_launch_covers_every_element() { got.iter().filter(|v| **v != 7.0).count() ); } + +// ── Placement mode: the same program, a different device ──────────────────── + +/// Run a program under a placement mode, returning its output and accounting. +fn run_placed( + src: &str, + mode: loon_lang::eir::place::Mode, +) -> (Vec, loon_lang::eir::place::PlaceStats) { + let dir = std::env::current_dir().expect("cwd"); + let (result, stats) = + loon_lang::eir::vm::eval_eir_placed(src, &dir, mode).expect("program runs"); + (result.output, stats) +} + +const CHAIN: &str = "[kernel step [i b] [put b i [+ 1.0 [at b i]]]] \ + [fn work [] [let mut b [buf #[0 0 0 0]]] \ + [Place.run step 4 #[b]] [Place.run step 4 #[b]] \ + [Place.run step 4 #[b]] [Place.run step 4 #[b]] \ + [Place.read b]] \ + [fn resident [thunk] \ + [handle [thunk] \ + [Place.run k n args] [do [Place.pin args] [resume [Place.run k n args]]] \ + [Place.read b] [resume [Place.read b]]]] \ + [fn main [] [IO.println [work]] [IO.println [resident work]]]"; + +#[test] +fn the_gpu_is_selected_by_a_flag_and_changes_nothing_else() { + // This is the claim in one test. The program is a constant; the mode is a + // parameter. A GPU that produced a different answer would not be a faster + // way to run this program, it would be a different program. + if Gpu::open().is_err() { + println!("SKIPPED — no GPU on this machine"); + return; + } + let (cpu_out, _) = run_placed(CHAIN, loon_lang::eir::place::Mode::Cpu); + let (gpu_out, gpu_stats) = run_placed(CHAIN, loon_lang::eir::place::Mode::Gpu); + + assert_eq!(cpu_out, gpu_out, "the GPU must compute what the CPU does"); + assert_eq!(cpu_out, vec!["#[4 4 4 4]", "#[4 4 4 4]"]); + + // Eight launches: four with no policy, four under the residency handler. + assert_eq!(gpu_stats.launches, 8); +} + +#[test] +fn a_residency_handler_saves_real_transfers_on_real_hardware() { + // The policy was written against an effect, not against a device. Here it + // is deciding what a Metal GPU actually has to copy. + if Gpu::open().is_err() { + println!("SKIPPED — no GPU on this machine"); + return; + } + let naive = "[kernel step [i b] [put b i [+ 1.0 [at b i]]]] \ + [fn work [] [let mut b [buf #[0 0 0 0]]] \ + [Place.run step 4 #[b]] [Place.run step 4 #[b]] \ + [Place.run step 4 #[b]] [Place.run step 4 #[b]] \ + [Place.read b]] \ + [fn main [] [IO.println [work]]]"; + let managed = "[kernel step [i b] [put b i [+ 1.0 [at b i]]]] \ + [fn work [] [let mut b [buf #[0 0 0 0]]] \ + [Place.run step 4 #[b]] [Place.run step 4 #[b]] \ + [Place.run step 4 #[b]] [Place.run step 4 #[b]] \ + [Place.read b]] \ + [fn resident [thunk] \ + [handle [thunk] \ + [Place.run k n args] [do [Place.pin args] [resume [Place.run k n args]]] \ + [Place.read b] [resume [Place.read b]]]] \ + [fn main [] [IO.println [resident work]]]"; + + let (bare, bare_stats) = run_placed(naive, loon_lang::eir::place::Mode::Gpu); + let (wrapped, wrapped_stats) = run_placed(managed, loon_lang::eir::place::Mode::Gpu); + + assert_eq!(bare, wrapped, "same answer either way"); + assert_eq!(bare_stats.uploads, 4); + assert_eq!(wrapped_stats.uploads, 1); + assert_eq!(wrapped_stats.resident_hits, 3); +} + +#[test] +fn asking_for_a_gpu_that_cannot_run_the_kernel_says_so() { + // A kernel outside the GPU subset must be refused by name rather than + // quietly run somewhere else. Being told your program did not run where + // you asked is worth more than a result that arrived by another route. + if Gpu::open().is_err() { + println!("SKIPPED — no GPU on this machine"); + return; + } + let dir = std::env::current_dir().expect("cwd"); + // `s` is a scalar the launch passes, but the kernel indexes `b` — fine. + // Make it impossible instead: pass a buffer where the body wants a number. + let src = "[kernel bad [i a b] [put b i [* a [at b i]]]] \ + [fn main [] \ + [let x [buf #[1 2]]] [let mut o [buf-zeros 2]] \ + [Place.run bad 2 #[x o]]]"; + let result = loon_lang::eir::vm::eval_eir_placed(src, &dir, loon_lang::eir::place::Mode::Gpu); + match result { + Err(e) => { + let msg = format!("{e:?}"); + assert!( + msg.contains("buffer") || msg.contains("GPU"), + "the refusal should explain itself: {msg}" + ); + } + Ok((r, _)) => panic!("expected a refusal, got output {:?}", r.output), + } +} From 3e34eb27a40cf90685ad6c983e4169bd83b0ca12 Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 11:27:21 -0400 Subject: [PATCH 07/25] Record a GPU run, replay it without a GPU MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit loon run samples/place/saxpy.oo --place gpu --record trace.oo loon replay trace.oo samples/place/saxpy.oo # no GPU feature compiled in Both print #[0 5 10 15 20 25 30 35]. Placement joins the recorded effects, so from the program's point of view a kernel launch is an operation that returned nothing and a read is one that produced some numbers. Recording those reproduces the run exactly on a machine with no GPU, in CI, or after the hardware it was written for stopped existing. Nothing about the recording is GPU-specific — a trace made against the simulated device replays the same way. `Place.stats` is deliberately excluded. It reports on the run currently happening, and a replayed run really did move no bytes; feeding back the original transfer counts would be a recording that lies about the execution it is part of. The replayed run reports zero launches, because it performed zero launches. Buffers now print as `#buf` rather than ``. A heap slot in output is unhelpful, and it would have made every recorded trace differ from the last for no reason. Co-Authored-By: Claude Fable 5 --- crates/loon-lang/src/eir/replay.rs | 11 ++ crates/loon-lang/src/eir/vm.rs | 8 ++ crates/loon-lang/tests/place_replay.rs | 137 +++++++++++++++++++++++++ 3 files changed, 156 insertions(+) create mode 100644 crates/loon-lang/tests/place_replay.rs diff --git a/crates/loon-lang/src/eir/replay.rs b/crates/loon-lang/src/eir/replay.rs index ffd6366..d78c605 100644 --- a/crates/loon-lang/src/eir/replay.rs +++ b/crates/loon-lang/src/eir/replay.rs @@ -182,6 +182,17 @@ impl TraceEntry { pub fn is_recorded_op(effect: &str, op: &str) -> bool { match effect { "Net" | "Env" | "Process" | "Rand" => true, + // Placement is recorded so a program that ran on a GPU can be replayed + // on a machine that has none: a launch replays as the unit it returned + // and a read replays as the values it produced, so the recording is a + // faithful account of what the program observed without any hardware + // being involved a second time. + // + // `Place.stats` is excluded. It reports on the run currently + // happening, and a replayed run really did move no bytes — feeding + // back the original transfer counts would be a recording that lies + // about the execution it is part of. + "Place" => op != "stats", "IO" => !matches!(op, "parse-json" | "to-json" | "blake3"), _ => false, } diff --git a/crates/loon-lang/src/eir/vm.rs b/crates/loon-lang/src/eir/vm.rs index 2c73b29..595c171 100644 --- a/crates/loon-lang/src/eir/vm.rs +++ b/crates/loon-lang/src/eir/vm.rs @@ -4123,6 +4123,14 @@ impl Vm { .unwrap_or("anon"); format!("") } + // A buffer prints as its shape, not its contents: it is a + // handle to bulk data that may live on another device, and + // `Place.read` is how a program asks for the values. Printing + // the heap slot instead would leak an allocation number into + // output that is supposed to be reproducible. + Some(Obj::Buffer(b)) => { + format!("#buf<{} x {}>", b.dtype().name(), b.len()) + } _ => format!("", val.as_ptr()), } } else { diff --git a/crates/loon-lang/tests/place_replay.rs b/crates/loon-lang/tests/place_replay.rs new file mode 100644 index 0000000..143dd7e --- /dev/null +++ b/crates/loon-lang/tests/place_replay.rs @@ -0,0 +1,137 @@ +//! A placed program can be recorded once and replayed without the device. +//! +//! This is the half of the story an offload compiler does not tell. A kernel +//! that ran on a GPU is, from the program's point of view, a launch that +//! returned nothing and a read that produced some numbers. Recording those and +//! feeding them back reproduces the run exactly — on a machine with no GPU, in +//! CI, or after the hardware it was written for stopped existing. + +use loon_lang::eir::place::Mode; +use loon_lang::eir::replay::{parse_trace, TraceRecorder}; +use loon_lang::eir::vm::{eval_eir_placed, eval_eir_recorded, eval_eir_replayed}; + +const PROGRAM: &str = "[kernel scale [i s b] [put b i [* s [at b i]]]] \ + [fn main [] \ + [let mut b [buf #[1 2 3 4]]] \ + [Place.run scale 4 #[3.0 b]] \ + [Place.run scale 4 #[2.0 b]] \ + [IO.println [Place.read b]]]"; + +fn temp_trace(name: &str) -> std::path::PathBuf { + let mut p = std::env::temp_dir(); + p.push(format!( + "loon-place-replay-{name}-{}.oo", + std::process::id() + )); + let _ = std::fs::remove_file(&p); + p +} + +fn record(src: &str, path: &std::path::Path) -> Vec { + let dir = std::env::current_dir().expect("cwd"); + let recorder = TraceRecorder::create(path).expect("create trace"); + let result = eval_eir_recorded(src, &dir, recorder).expect("records"); + loon_lang::eir::replay::finalize_trace_file(path).expect("finalize"); + result.output +} + +fn replay(src: &str, path: &std::path::Path) -> Vec { + let dir = std::env::current_dir().expect("cwd"); + let text = std::fs::read_to_string(path).expect("read trace"); + let entries = parse_trace(&text).expect("parse trace"); + eval_eir_replayed(src, &dir, entries) + .expect("replays") + .0 + .output +} + +#[test] +fn a_placed_run_replays_to_the_same_output() { + let path = temp_trace("basic"); + let recorded = record(PROGRAM, &path); + assert_eq!(recorded, vec!["#[6 12 18 24]"]); + + let replayed = replay(PROGRAM, &path); + assert_eq!( + recorded, replayed, + "a replayed run must observe what the recorded run observed" + ); + let _ = std::fs::remove_file(&path); +} + +#[test] +fn the_trace_records_launches_and_reads() { + let path = temp_trace("entries"); + record(PROGRAM, &path); + let text = std::fs::read_to_string(&path).expect("read trace"); + + let runs = text.matches(":op \"run\"").count(); + let reads = text.matches(":op \"read\"").count(); + assert_eq!(runs, 2, "both launches should be in the trace:\n{text}"); + assert_eq!(reads, 1, "the one read should be in the trace:\n{text}"); + let _ = std::fs::remove_file(&path); +} + +#[test] +fn statistics_are_never_replayed() { + // `Place.stats` reports on the run currently happening. A replayed run + // really did move no bytes, so feeding back the original counts would be + // a recording that lies about the execution it is part of. + let src = "[kernel k [i b] [put b i 1.0]] \ + [fn main [] \ + [let mut b [buf-zeros 4]] \ + [Place.run k 4 #[b]] \ + [let _ [Place.read b]] \ + [IO.println [get [Place.stats] :launches]]]"; + let path = temp_trace("stats"); + + let recorded = record(src, &path); + assert_eq!(recorded, vec!["1"], "the recorded run launched once"); + + let text = std::fs::read_to_string(&path).expect("read trace"); + assert!( + !text.contains(":op \"stats\""), + "stats should not be recorded:\n{text}" + ); + + // The replayed run performed no launch of its own, and says so. + let replayed = replay(src, &path); + assert_eq!(replayed, vec!["0"]); + let _ = std::fs::remove_file(&path); +} + +#[test] +fn a_recording_made_on_one_device_replays_anywhere() { + // The recording is of what the *program* observed, not of how the device + // behaved, so where it was made does not constrain where it is replayed. + let path = temp_trace("device"); + let dir = std::env::current_dir().expect("cwd"); + + let recorder = TraceRecorder::create(&path).expect("create trace"); + // Record against the simulated discrete device, which really does move + // bytes and evict buffers. + let recorded = { + let _ = eval_eir_placed(PROGRAM, &dir, Mode::Device); + eval_eir_recorded(PROGRAM, &dir, recorder) + .expect("records") + .output + }; + loon_lang::eir::replay::finalize_trace_file(&path).expect("finalize"); + + let replayed = replay(PROGRAM, &path); + assert_eq!(recorded, replayed); + let _ = std::fs::remove_file(&path); +} + +#[test] +fn a_buffer_prints_as_its_shape_not_its_address() { + // Buffers are handles to bulk data that may live on another device. + // Printing a heap slot would put an allocation number in output that is + // supposed to be reproducible — and would make traces differ run to run. + let out = loon_lang::eir::vm::eval_eir( + "[fn main [] [IO.println [buf #[1 2 3]]] [IO.println [buf-i32 #[1]]]]", + ) + .expect("runs") + .output; + assert_eq!(out, vec!["#buf", "#buf"]); +} From a591d2145574049c0b25ccc7e018752d11034a9f Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 11:36:48 -0400 Subject: [PATCH 08/25] Real GPU residency, and the numbers it produces MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The residency accounting was describing a model, not the hardware. Every launch was creating fresh GPU buffers, uploading, dispatching, and copying results back — so `uploads 1` in the stats sat next to four real uploads on the device. Fixed by giving the GPU a residency map keyed by the host's heap slot: `Place.pin` keeps an allocation alive, a launch uploads only what is not already there, and `Place.read` is the only thing that brings bytes home. An upload counted is now an upload that happened, which makes the benchmark worth reading. A chain of launches over one 4096-element buffer, Apple M4 Max via Metal, identical program in both columns: launches no policy place/resident speedup 8 28.9 ms 9.3 ms 3.1x 32 93.1 ms 15.4 ms 6.0x 128 356.7 ms 18.3 ms 19.5x Two bugs fixed on the way, both of the kind that produce wrong answers rather than slow ones: - Evicting a dirty buffer discarded what the kernel had written. A cache that drops dirty data is not a cache. Eviction now writes back first, which is exactly the cost a policy of keeping nothing resident is choosing to pay. - `Place.read` collected values from the host copy *before* downloading, so it returned stale data and reported a transfer that changed nothing. The transfer now happens first, which is the whole content of the word "synchronization". Compiled shaders are cached, so a loop launching the same kernel does not recompile it every iteration. BENCHMARKS.md records all of this with the framing it needs: the CPU column is Loon's own interpreter, the slowest reasonable baseline, and the ratio says what there is to gain by leaving it — not how a generated shader compares to a hand-written kernel. That comparison is not attempted and not claimed. Co-Authored-By: Claude Fable 5 --- BENCHMARKS.md | 76 +++++++ crates/loon-lang/examples/bench_place.rs | 224 ++++++++++++++++++++ crates/loon-lang/src/eir/gpu.rs | 222 ++++++++++++++++++-- crates/loon-lang/src/eir/vm.rs | 249 +++++++++++++++-------- 4 files changed, 673 insertions(+), 98 deletions(-) create mode 100644 crates/loon-lang/examples/bench_place.rs diff --git a/BENCHMARKS.md b/BENCHMARKS.md index 8335a68..088701a 100644 --- a/BENCHMARKS.md +++ b/BENCHMARKS.md @@ -1,5 +1,81 @@ # Benchmarks +## Placement (v0.9.0) + +Where a kernel runs is decided by a handler, not by the program. These numbers +say what that costs and what a residency policy is worth. + +Harness: `cargo run -q --release -p loon-lang --features gpu --example bench_place` +Machine: Apple M4 Max (Metal, via wgpu). Numbers move a little run to run; +the transfer counts do not move at all. + +### What a residency policy is worth + +A chain of launches over one 4096-element buffer, on the GPU. The program is +identical in both columns — the only difference is whether `place/resident` +(nine lines, in `os/place.oo`) is wrapped around it. + +| launches | no policy | place/resident | speedup | +|---------:|----------:|---------------:|--------:| +| 8 | 28.9 ms | 9.3 ms | 3.1x | +| 32 | 93.1 ms | 15.4 ms | 6.0x | +| 128 | 356.7 ms | 18.3 ms | 19.5x | + +The gap grows with the chain because without a policy every launch uploads its +arguments, computes, and copies its results back; with one, the buffers stay +put and only the final `Place.read` moves anything. A recent Rust GPU-offload +paper measures the same gap at up to 400x between its convenient and explicit +interfaces, and closes it with `Preload`/`PreloadMut` annotations at every call +site plus a transfer-hoisting pass inside LLVM. Here it is a `handle` form. + +### Transfers + +Exact counts — these do not vary between runs. + +| launches | no policy | place/resident | bytes saved | +|---------:|----------:|---------------:|------------:| +| 1 | 2 uploads | 2 uploads | 0 B | +| 4 | 8 uploads | 2 uploads | 96 KB | +| 16 | 32 uploads | 2 uploads | 480 KB | +| 64 | 128 uploads | 2 uploads | 2.0 MB | + +### Kernel time: interpreter vs GPU + +| elements | interpreter | gpu | ratio | +|---------:|------------:|----:|------:| +| 1,024 | 522 µs | 10.0 ms | 0.1x | +| 16,384 | 2.7 ms | 8.7 ms | 0.3x | +| 262,144 | 40.9 ms | 13.4 ms | 3.1x | + +Read this one carefully. The CPU column is **Loon's own interpreter** walking +EIR once per work item — the slowest reasonable baseline, not optimized C. The +ratio says how much there is to gain by leaving the interpreter, not how Loon's +generated shader compares to a hand-written kernel. We have not measured the +latter and do not claim it. + +The GPU loses below ~100k elements, which is the expected shape: a launch is a +submission to another processor and has a fixed cost that small work cannot +amortize. + +### Launch overhead + +| | ns per launch | +|---|---:| +| cpu | ~7,200 | +| gpu, buffers resident | ~110,000 | + +Placement being an effect means every launch is an effect dispatch. That +dispatch is not what you are paying for: an effect operation costs roughly 3x a +function call (see the Effects section), which is nanoseconds, while a GPU +submission is tens of microseconds. + +### What is not measured + +- Any comparison against hand-written CUDA, HIP, or Metal. Not attempted. +- Reductions and atomics — outside the kernel subset for now. +- f64 on the GPU: WGSL core has no 64-bit scalar, so 64-bit buffers are + computed in 32 bits and that narrowing is reported rather than hidden. + ## Collection Benchmarks (v0.5.0) 100,000-element collections using `loop`/`recur` with persistent data structures (imbl). diff --git a/crates/loon-lang/examples/bench_place.rs b/crates/loon-lang/examples/bench_place.rs new file mode 100644 index 0000000..c948348 --- /dev/null +++ b/crates/loon-lang/examples/bench_place.rs @@ -0,0 +1,224 @@ +//! What placement costs, and what a residency policy saves. +//! +//! Dependency-free (no criterion). Run in release for meaningful numbers: +//! +//! cargo run -q --release -p loon-lang --features gpu --example bench_place +//! +//! Without the `gpu` feature the GPU rows are skipped and everything else +//! still reports. +//! +//! Two things are measured, and it is worth being precise about which is which +//! because they answer different questions. +//! +//! **Kernel time** compares running a kernel through Loon's own interpreter +//! against running it on the GPU. That is not a comparison against optimized C +//! — the CPU side here is an interpreter walking EIR one work item at a time, +//! which is the slowest reasonable baseline. The number says how much there is +//! to gain by leaving the interpreter, not how Loon's generated code compares +//! to a hand-written kernel. Anyone quoting it as the latter is quoting it +//! wrong. +//! +//! **Transfer counts** compare a chain of launches with no residency policy +//! against the same chain under a handler that pins what each launch touches. +//! This one is exact rather than statistical: it counts uploads, and the count +//! does not vary between runs. It is the number the offload literature cares +//! about, and the one a policy actually controls. + +use loon_lang::eir::place::{Mode, PlaceStats}; +use loon_lang::eir::vm::eval_eir_placed; +use std::time::{Duration, Instant}; + +/// A kernel with enough arithmetic per element to be worth moving. +const KERNEL: &str = "[kernel heat [i src dst] \ + [let v [at src i]] \ + [put dst i [+ [* 0.25 v] [* 0.75 [sqrt [abs [+ v 1.0]]]]]]]"; + +fn dir() -> std::path::PathBuf { + std::env::current_dir().expect("cwd") +} + +/// Run `src` under `mode`, returning wall time and the placement accounting. +fn timed(src: &str, mode: Mode) -> Option<(Duration, PlaceStats)> { + // Warm once: the first GPU launch pays for adapter discovery and shader + // compilation, which is a real cost but not a per-launch one. + let _ = eval_eir_placed(src, &dir(), mode).ok()?; + let start = Instant::now(); + let (_, stats) = eval_eir_placed(src, &dir(), mode).ok()?; + Some((start.elapsed(), stats)) +} + +/// A program that runs one kernel over `n` elements, `reps` times. +fn workload(n: usize, reps: usize) -> String { + let runs = (0..reps) + .map(|_| format!("[Place.run heat {n} #[src dst]]")) + .collect::>() + .join(" "); + format!( + "{KERNEL} \ + [fn main [] \ + [let src [buf-zeros {n}]] \ + [let mut dst [buf-zeros {n}]] \ + {runs} \ + [let _ [Place.read dst]] \ + []]" + ) +} + +/// The same workload under a residency handler. +fn workload_resident(n: usize, reps: usize) -> String { + let runs = (0..reps) + .map(|_| format!("[Place.run heat {n} #[src dst]]")) + .collect::>() + .join(" "); + format!( + "{KERNEL} \ + [fn work [] \ + [let src [buf-zeros {n}]] \ + [let mut dst [buf-zeros {n}]] \ + {runs} \ + [Place.read dst]] \ + [fn resident [thunk] \ + [handle [thunk] \ + [Place.run k m args] [do [Place.pin args] [resume [Place.run k m args]]] \ + [Place.read b] [resume [Place.read b]]]] \ + [fn main [] [let _ [resident work]] []]" + ) +} + +fn main() { + println!("placement benchmarks"); + println!("machine: {}", std::env::consts::OS); + + // ── Kernel time: interpreter versus GPU ── + // + // The CPU column is Loon's interpreter running the kernel body once per + // element. It is the honest floor, not a tuned baseline. + println!("\nkernel time — one launch, varying size"); + println!( + " {:>10} {:>12} {:>12} {:>8}", + "elements", "interpreter", "gpu", "ratio" + ); + for n in [1_024usize, 16_384, 262_144] { + let src = workload(n, 1); + let cpu = timed(&src, Mode::Cpu).map(|(d, _)| d); + let gpu = timed(&src, Mode::Gpu).map(|(d, _)| d); + let ratio = match (cpu, gpu) { + (Some(c), Some(g)) if g.as_secs_f64() > 0.0 => { + format!("{:.1}x", c.as_secs_f64() / g.as_secs_f64()) + } + _ => "—".to_string(), + }; + println!( + " {:>10} {:>12} {:>12} {:>8}", + n, + cpu.map(fmt).unwrap_or_else(|| "—".into()), + gpu.map(fmt).unwrap_or_else(|| "skipped".into()), + ratio + ); + } + + // ── Transfers: what a policy controls ── + // + // Exact counts, identical every run. This is the gap the offload + // literature reports and the one a handler closes here. + println!("\ntransfers — a chain of launches over one buffer"); + println!( + " {:>8} {:>16} {:>16} {:>10}", + "launches", "no policy", "place/resident", "saved" + ); + for reps in [1usize, 4, 16, 64] { + let naive = timed(&workload(4_096, reps), Mode::Device).map(|(_, s)| s); + let managed = timed(&workload_resident(4_096, reps), Mode::Device).map(|(_, s)| s); + match (naive, managed) { + (Some(a), Some(b)) => { + let saved = a.bytes_in.saturating_sub(b.bytes_in); + println!( + " {:>8} {:>16} {:>16} {:>10}", + reps, + format!("{} uploads", a.uploads), + format!("{} uploads", b.uploads), + loon_lang::eir::place::human_bytes(saved) + ); + } + _ => println!(" {reps:>8} (failed)"), + } + } + + // ── What the policy is worth in time, not just in bytes ── + // + // The transfer counts above are exact but abstract. This is the same + // comparison in wall clock on whatever device is present: a chain of + // launches with no residency policy, where every launch uploads its + // arguments and copies its results back, against the identical program + // under a handler that keeps them in place. + // + // This is the shape of the gap a recent Rust offload paper measures at up + // to 400x between its convenient and explicit interfaces. There it is + // closed by annotations at every call site plus an LLVM pass; here by the + // handler in os/place.oo. + // Only the real device is timed. The modelled one moves no actual bytes, + // so its wall clock would be measuring the interpreter and calling it a + // transfer cost. + for (label, mode) in [("gpu", Mode::Gpu)] { + println!("\nchain of launches on the {label} — 4096 elements"); + println!( + " {:>8} {:>12} {:>16} {:>8}", + "launches", "no policy", "place/resident", "speedup" + ); + let mut any = false; + for reps in [8usize, 32, 128] { + let naive = timed(&workload(4_096, reps), mode).map(|(d, _)| d); + let managed = timed(&workload_resident(4_096, reps), mode).map(|(d, _)| d); + match (naive, managed) { + (Some(a), Some(b)) => { + any = true; + let speedup = if b.as_secs_f64() > 0.0 { + format!("{:.1}x", a.as_secs_f64() / b.as_secs_f64()) + } else { + "—".into() + }; + println!( + " {:>8} {:>12} {:>16} {:>8}", + reps, + fmt(a), + fmt(b), + speedup + ); + } + _ => {} + } + } + if !any { + println!(" skipped — this mode is not available in this build"); + } + } + + // ── Launch overhead ── + // + // Placement is an effect, so every launch is an effect dispatch. This is + // the cost of that decision, measured rather than asserted: a kernel over + // a single element, where the work itself is negligible. On the CPU that + // is dispatch and nothing else. + println!("\nlaunch overhead — one work item, so the cost is dispatch"); + let one = workload(1, 200); + if let Some((d, stats)) = timed(&one, Mode::Cpu) { + let per = d.as_nanos() as f64 / stats.launches.max(1) as f64; + println!(" {per:>10.0} ns per launch (cpu)"); + } + if let Some((d, stats)) = timed(&workload_resident(1, 200), Mode::Gpu) { + let per = d.as_nanos() as f64 / stats.launches.max(1) as f64; + println!(" {per:>10.0} ns per launch (gpu, buffers resident)"); + println!( + " a GPU launch is a submission to another processor; the effect\n dispatch around it is not what you are paying for." + ); + } +} + +fn fmt(d: Duration) -> String { + let ms = d.as_secs_f64() * 1000.0; + if ms >= 1.0 { + format!("{ms:.1} ms") + } else { + format!("{:.0} µs", d.as_micros()) + } +} diff --git a/crates/loon-lang/src/eir/gpu.rs b/crates/loon-lang/src/eir/gpu.rs index 43d2323..e749767 100644 --- a/crates/loon-lang/src/eir/gpu.rs +++ b/crates/loon-lang/src/eir/gpu.rs @@ -24,6 +24,30 @@ pub struct Gpu { device: wgpu::Device, queue: wgpu::Queue, name: String, + /// Buffers that currently live on the device, keyed by the host's heap + /// slot. + /// + /// This is what makes residency real rather than modelled. Without it, + /// every launch would upload its arguments again and copy its results back + /// again, and a residency policy would be describing a saving that did not + /// happen. With it, `Place.pin` keeps an allocation alive across launches + /// and `Place.read` is the only thing that moves bytes home. + resident: std::cell::RefCell>, + /// Compiled pipelines, keyed by shader source. + /// + /// Compiling a shader takes on the order of a millisecond, which is + /// hundreds of times what a small launch costs. Without this cache a loop + /// that launches the same kernel repeatedly — the shape every offload + /// benchmark has, and the shape a residency policy exists to serve — pays + /// to recompile it on every iteration, and the GPU loses to an + /// interpreter for entirely uninteresting reasons. + pipelines: std::cell::RefCell>, +} + +/// A shader that has already been compiled. +struct CachedPipeline { + pipeline: wgpu::ComputePipeline, + layout: wgpu::BindGroupLayout, } /// What went wrong, in a sentence a person can act on. @@ -77,6 +101,8 @@ impl Gpu { device, queue, name, + resident: std::cell::RefCell::new(std::collections::HashMap::new()), + pipelines: std::cell::RefCell::new(std::collections::HashMap::new()), }) } @@ -102,12 +128,7 @@ impl Gpu { n: u32, args: &[GpuArg<'_>], ) -> Result)>, Error> { - let module = self - .device - .create_shader_module(wgpu::ShaderModuleDescriptor { - label: Some(entry), - source: wgpu::ShaderSource::Wgsl(shader.into()), - }); + self.ensure_pipeline(shader, entry); // The uniform block is `n` followed by every scalar argument, in order // — matching what the emitter wrote into `struct Params`. @@ -157,20 +178,12 @@ impl Gpu { }); } - let pipeline = self - .device - .create_compute_pipeline(&wgpu::ComputePipelineDescriptor { - label: Some(entry), - layout: None, - module: &module, - entry_point: Some(entry), - compilation_options: Default::default(), - cache: None, - }); + let cache = self.pipelines.borrow(); + let cached = cache.get(shader).expect("pipeline was just ensured"); let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor { label: Some("args"), - layout: &pipeline.get_bind_group_layout(0), + layout: &cached.layout, entries: &entries, }); @@ -182,7 +195,7 @@ impl Gpu { label: Some(entry), timestamp_writes: None, }); - pass.set_pipeline(&pipeline); + pass.set_pipeline(&cached.pipeline); pass.set_bind_group(0, &bind_group, &[]); // The shader's workgroup size is 64; round up and let the bounds // check in the shader discard the overshoot. @@ -208,6 +221,7 @@ impl Gpu { } self.queue.submit(Some(encoder.finish())); + drop(cache); // Map each staging buffer and collect what came back. let mut results: Vec<(usize, Vec)> = Vec::new(); @@ -233,6 +247,178 @@ impl Gpu { Ok(results) } + /// Ensure `id`'s data is on the device, uploading it if it is not already. + /// + /// Returns whether an upload actually happened, so the caller's accounting + /// reflects what the hardware did rather than what the model predicted. + pub fn ensure_resident(&self, id: usize, buf: &Buffer) -> bool { + if self.resident.borrow().contains_key(&id) { + return false; + } + let bytes = buf.to_bytes(); + let gpu_buf = self.create_buffer( + &format!("buf{id}"), + &bytes, + wgpu::BufferUsages::STORAGE + | wgpu::BufferUsages::COPY_DST + | wgpu::BufferUsages::COPY_SRC, + ); + self.resident.borrow_mut().insert(id, gpu_buf); + true + } + + /// Whether `id` is currently on the device. + pub fn is_resident(&self, id: usize) -> bool { + self.resident.borrow().contains_key(&id) + } + + /// Drop a device allocation. + pub fn evict(&self, id: usize) { + self.resident.borrow_mut().remove(&id); + } + + /// Copy a resident buffer's contents back to the host. + /// + /// This is the only path by which device data becomes visible again, which + /// is exactly what makes `Place.read` the synchronization point a + /// residency handler can reason about. + pub fn download(&self, id: usize, byte_len: usize) -> Result, Error> { + let resident = self.resident.borrow(); + let Some(src) = resident.get(&id) else { + return Err(Error(format!("buffer {id} is not on the device"))); + }; + let staging = self.device.create_buffer(&wgpu::BufferDescriptor { + label: Some("readback"), + size: byte_len.max(4) as u64, + usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST, + mapped_at_creation: false, + }); + let mut encoder = self + .device + .create_command_encoder(&wgpu::CommandEncoderDescriptor { + label: Some("download"), + }); + encoder.copy_buffer_to_buffer(src, 0, &staging, 0, byte_len.max(4) as u64); + self.queue.submit(Some(encoder.finish())); + + let slice = staging.slice(..); + let (tx, rx) = std::sync::mpsc::channel(); + slice.map_async(wgpu::MapMode::Read, move |r| { + let _ = tx.send(r); + }); + self.device + .poll(wgpu::PollType::Wait) + .map_err(|e| Error(format!("waiting for the GPU: {e:?}")))?; + match rx.recv() { + Ok(Ok(())) => {} + Ok(Err(e)) => return Err(Error(format!("mapping results: {e:?}"))), + Err(e) => return Err(Error(format!("the GPU never reported back: {e}"))), + } + let mut bytes = slice.get_mapped_range().to_vec(); + staging.unmap(); + bytes.truncate(byte_len); + Ok(bytes) + } + + /// Dispatch a shader over buffers that are already resident. + /// + /// Nothing is uploaded and nothing is read back: the caller decides when + /// data moves, which is the whole point of making placement a handler's + /// decision rather than a launch's side effect. + pub fn dispatch( + &self, + shader: &str, + entry: &str, + n: u32, + scalars: &[f32], + buffers: &[usize], + ) -> Result<(), Error> { + self.ensure_pipeline(shader, entry); + + let mut uniform: Vec = (n as i32).to_le_bytes().to_vec(); + for v in scalars { + uniform.extend_from_slice(&v.to_le_bytes()); + } + while uniform.len() % 16 != 0 { + uniform.push(0); + } + let uniform_buf = self.create_buffer( + "params", + &uniform, + wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + ); + + let resident = self.resident.borrow(); + let mut entries: Vec = vec![wgpu::BindGroupEntry { + binding: 0, + resource: uniform_buf.as_entire_binding(), + }]; + for (slot, id) in buffers.iter().enumerate() { + let buf = resident + .get(id) + .ok_or_else(|| Error(format!("buffer {id} is not on the device")))?; + entries.push(wgpu::BindGroupEntry { + binding: slot as u32 + 1, + resource: buf.as_entire_binding(), + }); + } + + let cache = self.pipelines.borrow(); + let cached = cache.get(shader).expect("pipeline was just ensured"); + let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("args"), + layout: &cached.layout, + entries: &entries, + }); + + let mut encoder = self + .device + .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("run") }); + { + let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { + label: Some(entry), + timestamp_writes: None, + }); + pass.set_pipeline(&cached.pipeline); + pass.set_bind_group(0, &bind_group, &[]); + pass.dispatch_workgroups(n.div_ceil(64).max(1), 1, 1); + } + self.queue.submit(Some(encoder.finish())); + Ok(()) + } + + /// Compile `shader` if this is the first time we have seen it. + fn ensure_pipeline(&self, shader: &str, entry: &str) { + if self.pipelines.borrow().contains_key(shader) { + return; + } + let module = self + .device + .create_shader_module(wgpu::ShaderModuleDescriptor { + label: Some(entry), + source: wgpu::ShaderSource::Wgsl(shader.into()), + }); + let pipeline = self + .device + .create_compute_pipeline(&wgpu::ComputePipelineDescriptor { + label: Some(entry), + layout: None, + module: &module, + entry_point: Some(entry), + compilation_options: Default::default(), + cache: None, + }); + let layout = pipeline.get_bind_group_layout(0); + self.pipelines + .borrow_mut() + .insert(shader.to_string(), CachedPipeline { pipeline, layout }); + } + + /// How many distinct shaders have been compiled so far. + pub fn compiled_shaders(&self) -> usize { + self.pipelines.borrow().len() + } + fn create_buffer(&self, label: &str, bytes: &[u8], usage: wgpu::BufferUsages) -> wgpu::Buffer { use wgpu::util::DeviceExt as _; // An empty buffer is invalid in wgpu; give it one padded element. diff --git a/crates/loon-lang/src/eir/vm.rs b/crates/loon-lang/src/eir/vm.rs index 595c171..552ae07 100644 --- a/crates/loon-lang/src/eir/vm.rs +++ b/crates/loon-lang/src/eir/vm.rs @@ -786,7 +786,7 @@ impl Vm { // the kernel can touch it. An argument that is already resident costs // nothing — and counting those hits is what turns a residency policy // from a claim into a measurement. - if self.place_mode.has_device_memory() { + if self.place_mode == crate::eir::place::Mode::Device { for (i, arg) in rest.iter().enumerate() { let Some((id, bytes, dtype)) = self.buffer_info(*arg) else { continue; @@ -822,14 +822,48 @@ impl Vm { // particular device. if self.place_mode == crate::eir::place::Mode::Gpu { self.place_run_gpu(func_id, &rest, n)?; - if self.place_mode.has_device_memory() { - for arg in &rest { - if let Some((id, _, _)) = self.buffer_info(*arg) { - self.place_device.mark_dirty(id); - } + for arg in &rest { + if let Some((id, _, _)) = self.buffer_info(*arg) { + self.place_device.mark_resident(id); + self.place_device.mark_dirty(id); } - self.place_device.evict_unpinned(); } + // An unpinned buffer does not survive the launch, and on a GPU + // that means really releasing the allocation — otherwise + // "resident" would be a word the accounting used and the hardware + // ignored. + // + // Evicting something the kernel just wrote has to write it back + // first. A cache that drops dirty data is not a cache, it is a + // bug; and this write-back is exactly the cost a policy of keeping + // nothing resident is choosing to pay, once per launch. + let evicted = self.place_device.evict_unpinned(); + let dirty: Vec = rest + .iter() + .copied() + .filter(|v| { + v.is_ptr() + && evicted.contains(&v.as_ptr()) + && self.place_device.is_dirty(v.as_ptr()) + }) + .collect(); + for val in dirty { + let id = val.as_ptr(); + self.gpu_download_into(id, val)?; + self.place_device.clear_dirty(id); + if let Some((_, bytes, dtype)) = self.buffer_info(val) { + self.place_stats.record(crate::eir::place::PlaceEvent { + kind: crate::eir::place::EventKind::Download, + kernel: None, + arg: None, + dtype: Some(dtype), + bytes, + items: 0, + device: "gpu", + }); + } + } + self.gpu_evict(&evicted); return Ok(Val::UNIT); } @@ -858,11 +892,16 @@ impl Vm { Ok(Val::UNIT) } - /// Run a kernel on the GPU: emit its shader, ship the arguments, dispatch, - /// and copy back whatever it wrote. + /// Run a kernel on the GPU. + /// + /// Arguments are uploaded only if they are not already there, and nothing + /// is copied back — results stay on the device until `Place.read` asks for + /// them. That is what makes the residency accounting describe the hardware + /// rather than a model of it: an upload counted here is an upload that + /// happened. #[cfg(feature = "gpu")] fn place_run_gpu(&mut self, func_id: FuncId, rest: &[Val], n: i64) -> Result<(), VmError> { - use crate::eir::gpu::{self, GpuArg}; + use crate::eir::gpu; let kinds = crate::eir::wgsl::infer_arg_kinds(&self.module, func_id, DType::F32); if kinds.len() != rest.len() { @@ -872,19 +911,16 @@ impl Vm { rest.len() ))); } - let shader = crate::eir::wgsl::emit(&self.module, func_id, &kinds) .map_err(|e| self.place_error(format!("this kernel cannot run on a GPU: {e}")))?; - // Buffers travel as their 32-bit form; scalars are packed by value. - // - // Each argument is checked against the shape the kernel body implies. - // A buffer handed to a parameter the kernel multiplies by has no - // sensible reading, and defaulting it to zero would produce a - // confident wrong answer — the exact failure this whole design is - // supposed to make impossible. - let mut owned: Vec = Vec::new(); + // Check every argument against the shape the kernel body implies. A + // buffer handed to a parameter the kernel multiplies by has no + // sensible reading, and defaulting it to zero would be a confident + // wrong answer. let mut scalars: Vec = Vec::new(); + let mut buffer_ids: Vec = Vec::new(); + let mut to_upload: Vec<(usize, Buffer, u64, DType)> = Vec::new(); for (i, val) in rest.iter().enumerate() { let is_buffer = matches!(self.get_obj(*val), Some(Obj::Buffer(_))); let wants_buffer = matches!(kinds[i], crate::eir::wgsl::ArgKind::Buffer { .. }); @@ -900,7 +936,11 @@ impl Vm { ))); } match self.get_obj(*val) { - Some(Obj::Buffer(b)) => owned.push(gpu::narrow(b)), + Some(Obj::Buffer(b)) => { + let id = val.as_ptr(); + buffer_ids.push(id); + to_upload.push((id, gpu::narrow(b), b.byte_len() as u64, b.dtype())); + } _ => { let x = if val.is_int() { val.as_int() as f32 @@ -918,42 +958,26 @@ impl Vm { } let device = self.gpu_device()?; - let mut scalar_iter = scalars.iter(); - let mut owned_iter = owned.iter(); - let gpu_args: Vec = kinds - .iter() - .map(|k| match k { - crate::eir::wgsl::ArgKind::Scalar(_) => { - GpuArg::Scalar(scalar_iter.next().copied().unwrap_or(0.0)) - } - crate::eir::wgsl::ArgKind::Buffer { writable, .. } => GpuArg::Buffer { - data: owned_iter.next().expect("a buffer argument"), - writable: *writable, + for (i, (id, narrowed, bytes, dtype)) in to_upload.iter().enumerate() { + let uploaded = device.ensure_resident(*id, narrowed); + self.place_stats.record(crate::eir::place::PlaceEvent { + kind: if uploaded { + crate::eir::place::EventKind::Upload + } else { + crate::eir::place::EventKind::ResidentHit }, - }) - .collect(); + kernel: None, + arg: Some(i as u16), + dtype: Some(*dtype), + bytes: if uploaded { *bytes } else { 0 }, + items: 0, + device: "gpu", + }); + } - let results = device - .run(&shader, "main", n.max(0) as u32, &gpu_args) + device + .dispatch(&shader, "main", n.max(0) as u32, &scalars, &buffer_ids) .map_err(|e| self.place_error(format!("the GPU refused the launch: {e}")))?; - - // Copy results home, into the host buffer each one came from. - for (slot, bytes) in results { - let Some(val) = rest.get(slot) else { continue }; - let ptr = val.as_ptr(); - let Some(Obj::Buffer(buf)) = self.heap.get_mut(ptr) else { - continue; - }; - let len = buf.len(); - let vals: Vec = bytes - .chunks_exact(4) - .map(|c| f32::from_le_bytes(c.try_into().unwrap())) - .take(len) - .collect(); - for (i, v) in vals.into_iter().enumerate() { - buf.set(i, Val::float(v as f64)); - } - } Ok(()) } @@ -981,6 +1005,57 @@ impl Vm { Ok(g) } + /// Release device allocations for buffers the model just evicted. + #[cfg(feature = "gpu")] + fn gpu_evict(&mut self, ids: &[usize]) { + if let Some(g) = &self.gpu { + for id in ids { + g.evict(*id); + } + } + } + + #[cfg(not(feature = "gpu"))] + fn gpu_evict(&mut self, _ids: &[usize]) {} + + /// Bring a buffer's device contents home, if it lives on a GPU. + #[cfg(feature = "gpu")] + fn gpu_download_into(&mut self, id: usize, val: Val) -> Result<(), VmError> { + if self.place_mode != crate::eir::place::Mode::Gpu { + return Ok(()); + } + let Some(g) = self.gpu.clone() else { + return Ok(()); + }; + if !g.is_resident(id) { + return Ok(()); + } + let byte_len = match self.get_obj(val) { + Some(Obj::Buffer(b)) => b.byte_len(), + _ => return Ok(()), + }; + let bytes = g + .download(id, byte_len) + .map_err(|e| self.place_error(format!("reading back from the GPU: {e}")))?; + if let Some(Obj::Buffer(buf)) = self.heap.get_mut(id) { + let len = buf.len(); + let vals: Vec = bytes + .chunks_exact(4) + .map(|c| f32::from_le_bytes(c.try_into().unwrap())) + .take(len) + .collect(); + for (i, v) in vals.into_iter().enumerate() { + buf.set(i, Val::float(v as f64)); + } + } + Ok(()) + } + + #[cfg(not(feature = "gpu"))] + fn gpu_download_into(&mut self, _id: usize, _val: Val) -> Result<(), VmError> { + Ok(()) + } + fn place_error(&self, message: String) -> VmError { VmError::new(VmErrorKind::BuiltinType(message)).with_span(self.current_span) } @@ -3900,36 +3975,50 @@ impl Vm { // what the `Preload`/`PreloadMut` types in the Rust offload // work exist to reconstruct. let b = args.first().copied().unwrap_or(Val::UNIT); + let (bytes, dtype) = match self.buffer_info(b) { + Some((_, bytes, dtype)) => (bytes, dtype), + None => { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "Place.read expects a buffer, got {}", + self.val_to_string(b) + ))) + .with_span(self.current_span)) + } + }; + let id = b.as_ptr(); + + // On a device, a read costs a transfer only when the device + // holds something the host has not seen. On the CPU there is + // one memory, so the read is free — and saying so keeps the + // two modes comparable. + let must_transfer = match self.place_mode { + crate::eir::place::Mode::Cpu => true, + crate::eir::place::Mode::Device | crate::eir::place::Mode::Gpu => { + self.place_device.is_dirty(id) + } + }; + // The transfer happens *before* the values are read, which is + // the whole content of the word "synchronization". Reading + // first would return the host's stale copy and report a + // download that changed nothing. + if must_transfer { + self.place_device.clear_dirty(id); + self.gpu_download_into(id, b)?; + self.place_stats.record(crate::eir::place::PlaceEvent { + kind: crate::eir::place::EventKind::Download, + kernel: None, + arg: None, + dtype: Some(dtype), + bytes, + items: 0, + device: self.place_mode.name(), + }); + } + let items: Vec = match self.get_obj(b) { Some(Obj::Buffer(buf)) => { let n = buf.len(); - let bytes = buf.byte_len() as u64; - let dtype = buf.dtype(); - let id = b.as_ptr(); - let vals: Vec = (0..n).filter_map(|i| buf.get(i)).collect(); - // On a device, a read costs a transfer only when the - // device holds something the host has not seen. On the - // CPU there is one memory, so the read is free — and - // saying so keeps the two modes comparable. - let must_transfer = match self.place_mode { - crate::eir::place::Mode::Cpu => true, - crate::eir::place::Mode::Device | crate::eir::place::Mode::Gpu => { - self.place_device.is_dirty(id) - } - }; - if must_transfer { - self.place_device.clear_dirty(id); - self.place_stats.record(crate::eir::place::PlaceEvent { - kind: crate::eir::place::EventKind::Download, - kernel: None, - arg: None, - dtype: Some(dtype), - bytes, - items: 0, - device: self.place_mode.name(), - }); - } - vals + (0..n).filter_map(|i| buf.get(i)).collect() } _ => { return Err(VmError::new(VmErrorKind::BuiltinType(format!( From 9904b9a61fd2df1c1696a1ebbdeb671752eedfe8 Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 11:41:37 -0400 Subject: [PATCH 09/25] Write up v0.9: Placement Is an Effect MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit docs/blog/2026-08-18-placement-is-an-effect.md and the changelog entry. The post's argument, in short: the two facts a GPU offload compiler works hardest to recover — what does this launch touch, and when does the host actually want to look — are both *events*, and we already have a way to spell those. Making Place.run and Place.read effect operations turns the transfer-hoisting pass into a nine-line handler, and turns the "heuristic we did not ship" for the Energy benchmark into an argument the user passes. It is explicit about what is not claimed. No comparison against hand-written CUDA is attempted. The CPU column in the benchmarks is Loon's own interpreter, so the GPU ratio says what there is to gain by leaving the interpreter, not anything about generated code quality. Reductions and atomics are outside the kernel subset, and f64 narrows to f32 on a device that has no 64-bit scalar. And the honest summary of the comparison: they built a compiler and this moved a seam. Those are different kinds of work. The seam is worth writing about because it makes residency, prefetch, eviction, tracing, simulation, and replay stop being compiler features somebody has to ship for you and start being code you can write on a Tuesday. Third in the arc: v0.7 effects end to end, v0.8 the kernel is a handler, v0.9 the GPU is a handler in the middle. Co-Authored-By: Claude Fable 5 --- .../blog/2026-08-18-placement-is-an-effect.md | 189 ++++++++++++++++++ os/demo-place.oo | 14 +- os/demo-residency.oo | 23 ++- os/place.oo | 48 +++-- samples/place/saxpy.oo | 8 +- web/src/pages/blog.loon | 61 ++++++ 6 files changed, 296 insertions(+), 47 deletions(-) create mode 100644 docs/blog/2026-08-18-placement-is-an-effect.md diff --git a/docs/blog/2026-08-18-placement-is-an-effect.md b/docs/blog/2026-08-18-placement-is-an-effect.md new file mode 100644 index 0000000..7f38564 --- /dev/null +++ b/docs/blog/2026-08-18-placement-is-an-effect.md @@ -0,0 +1,189 @@ +# Placement Is an Effect + +*August 2026* + +Last month I wrote that a syscall is an effect, and so the kernel is just the outermost handler. This month someone handed me a paper about running Rust on GPUs, and I spent a week discovering that the same sentence has another half. + +The paper is [GPU Offload in Rust: Portable, Safe, and Fast](https://arxiv.org/abs/2608.13759), by Drehwald, Domínguez, Sala, Aspuru-Guzik, and Doerfert. It is good work and you should read it. They put GPU compilation inside `rustc`, they get data direction out of `&T` versus `&mut T` instead of making you write pragmas, and they measure themselves honestly against hand-written CUDA. My interest is in the part they are candid about not having solved, because it turns out to be a shape I recognized. + +## The 400x + +Their convenient interface looks like this: + +```rust +offload!(vec_add, &a, &b, &mut c); +``` + +You write that, and the compiler transfers `a` and `b` to the GPU, runs the kernel, and copies `c` back. Lovely. Now put it in a loop, and every iteration ships the same two arrays across the bus again. They measure this at **up to 400x slower** than doing the transfers by hand. + +So they add a second interface. You wrap your data in a `Preload` or `PreloadMut`, which pins it on the device and marks the point where it comes home with the value's `drop`. That works, and it costs you an annotation at every site. And then, to make the *convenient* interface fast too, they prototype a transfer-hoisting pass inside LLVM — loop-invariant code motion for `memcpy`s, essentially — which is still future work at the time of writing. + +There is one benchmark they can't fix that way. It's called Energy: six kernels sharing about fifteen arrays, each with a few of its own. Keeping everything resident might blow past the device's memory; keeping nothing resident is the 400x. Deciding needs a heuristic, and they say plainly that they didn't ship one. + +I read that and thought: that isn't a missing optimization. That's a missing *seam*. + +## The seam + +Here's the thing the compiler is trying to recover. It wants to know two facts: + +1. What does this launch touch? +2. When does the host actually want to look? + +And it can't just ask, because in Rust neither fact is written down anywhere. A launch is a function call. A host read is... a host read, some ordinary expression somewhere in the program that happens to name the same variable. So the compiler goes and reconstructs both from dataflow analysis, and where analysis fails, `Preload` makes you write the answer down by hand. + +But both facts are *events*. Things that happen, in an order, that somebody might want to intercept. + +We have a way to spell that. + +``` +[Place.run saxpy n #[3.0 x y out]] +[Place.read out] +``` + +`Place.run` is an effect operation. `Place.read` is an effect operation. Not a function, not a method on a smart pointer — an operation, which floats up until some handler catches it. And once those two are effects, the two questions the LLVM pass was reverse-engineering are just *arguments to a handler clause*. + +## Nine lines + +Here is the residency policy. It is in `os/place.oo`. It is not privileged, it is not in the compiler, and you could have written it. + +``` +[fn place/resident [thunk] + [handle [thunk] + [Place.run k n args] + [do [Place.pin args] + [resume [Place.run k n args]]] + [Place.read b] + [do [let v [Place.read b]] + [Place.unpin b] + [resume v]]]]] +``` + +Read it slowly, because it is doing the whole job. It catches every launch, tells the device to keep whatever that launch touched, and forwards the launch outward unchanged. It catches every read, lets the read happen, and releases the pin. That's it. `Place.pin` is the entire vocabulary — it means "this will be wanted again." + +Wrap it around a program and: + +``` +loon run os/demo-residency.oo --place gpu + +eight launches over one buffer + answer #[8 8 8 8] + no policy: uploads 8, resident hits 0, bytes in 128 + answer #[8 8 8 8] + place/resident: uploads 1, resident hits 7, bytes in 16 +``` + +Same program both times. Same answer both times. Eight uploads became one, because a handler said so. + +On an actual GPU — this is an M4 Max, through Metal, via wgpu — the wall clock follows: + +| launches | no policy | place/resident | speedup | +|---------:|----------:|---------------:|--------:| +| 8 | 28.9 ms | 9.3 ms | 3.1x | +| 32 | 93.1 ms | 15.4 ms | 6.0x | +| 128 | 356.7 ms | 18.3 ms | 19.5x | + +The gap grows with the chain, which is exactly the paper's curve. The difference is where the fix lives. Theirs is an LLVM pass and a type. Mine is a `handle` form you can read in one sitting, change without rebuilding a compiler, and — this is the part I keep coming back to — *replace with a different one* when your program has different needs. + +Which brings us to Energy. + +## The heuristic they didn't ship + +The Energy case is only hard if there's exactly one policy and it has to be right for everybody. When residency is a handler, "keep everything" and "keep these" are two handlers, and choosing between them is a line of code rather than a compiler flag nobody can change: + +``` +[place/resident-only #[e-new p-new q-new] work] +``` + +That's the heuristic. It's an argument. I am not claiming I solved their benchmark — I haven't run RAJAPerf and I'm not going to pretend otherwise. I'm claiming the thing they needed a heuristic *for* is, in this design, a place where the user gets to put one. + +## Nobody wrote `&mut` + +Here's the part I'm smug about. This is a kernel: + +``` +[kernel saxpy [i a x y out] + [put out i [+ [* a [at x i]] [at y i]]]] +``` + +`x` and `y` are inputs. `out` has to come home. Nothing in that source says so. + +Loon already had an ownership pass that figures out, for every function parameter, whether the body reads it, writes through it, or consumes it — the same distinction Rust makes you spell as `&T` / `&mut T` / `T`. It was computing that, using it for error messages, and throwing it away. Now it rides into the IR, and the placement layer reads it: `at` is a read, `put` is a write-through, so `out` is the argument that needs synchronizing back. The paper reads exactly the same fact off exactly the same distinction. They just make you type it. + +The emitted shader gets it right down to the binding: + +```wgsl +@group(0) @binding(1) var b1: array; +@group(0) @binding(2) var b2: array; +@group(0) @binding(3) var b3: array; +``` + +`read` versus `read_write`, decided by whether the kernel body said `at` or `put`. + +## What a kernel isn't + +Kernels are restricted. No closures, no allocation, no strings, no effects. Try it and the compiler names what it found: + +``` +kernel 'k' contains the effect operation 'IO.println' + why: a kernel runs where there is no handler tower to perform effects against +``` + +That restriction is the safety argument, and it's where I think this design earns its keep against theirs. Their kernels can receive a slice and index it however they like, so "threads touch disjoint elements" has to be *promised* — by an `unsafe impl` of a partitioning strategy. Here a kernel receives an index and writes at that index. The unsafe program isn't rejected; it's unwriteable. + +I'll take a restriction over a promise. A promise is a place where someone will eventually be wrong. + +## Testing a GPU program without a GPU + +This is the part the paper doesn't have a section for, and I don't think that's an oversight so much as a consequence: if launches aren't events, there's nothing to record. + +``` +loon run samples/place/saxpy.oo --place gpu --record trace.oo +loon replay trace.oo samples/place/saxpy.oo +``` + +The second command runs on a build with no GPU support compiled into it at all, and prints the same thing. From the program's point of view a kernel launch was an operation that returned nothing and a read was one that produced some numbers, so recording those *is* the run. + +`Place.stats` is deliberately excluded from the recording. It reports on the run currently happening, and a replayed run genuinely moved no bytes — feeding back the original transfer counts would be a recording that lies about the execution it's part of. The replayed run says zero launches, because it performed zero launches. + +And since a handler can decline to forward at all, "run this without a device" is four lines: + +``` +[fn place/dry-run [thunk] + [handle [thunk] + [Place.run k n args] [resume []] + [Place.read b] [resume #[]]]] +``` + +Every accounting number, no execution. And strace-for-GPU is the same shape as strace-for-syscalls was last month — perform the operation you intercepted, print on the way past. + +## Where it runs + +Metal on this laptop. Vulkan on a Linux box. DX12 on Windows. And WebGPU in a browser tab, which is a target you cannot reach at all if you're emitting PTX and AMDGCN. That last one isn't cleverness; it's what you get for free by picking a portable shading language instead of a vendor's, and it's the one place where I think the architecture is straightforwardly better rather than differently-shaped. + +Every kernel in the repo is parsed and type-checked by naga in CI, on machines with no GPU. That's the automated cross-target validation the paper says is still missing — they found a host/device divergence in slice lowering by hand, `(ptr, len)` on two targets and `[i64; 2]` on a third. We have the same class of hazard: NaN-boxing constants that used to be copy-pasted into three backends under a comment asking the next person to keep them in sync. They now live in one file, and a conformance test compiles the same literals on every backend and compares raw bits. + +That test found three real divergences the first time it ran, including one where `loon run --native` silently returned `()` for any program with a `main` function. Which is a good argument for writing the test. + +## What I'm not claiming + +We do not beat hand-written CUDA. We haven't measured against it and we're not going to imply otherwise. The CPU column in our benchmarks is Loon's own interpreter — the slowest honest baseline — so "3.1x faster on the GPU at 262k elements" means *there is a lot to gain by leaving the interpreter*, not anything about generated code quality. + +Reductions and atomics are outside the kernel subset. WGSL core has no 64-bit scalar, so an f64 buffer is computed in f32 on the device and we report the narrowing rather than hiding it. + +And the honest summary of the whole comparison: they built a compiler and I moved a seam. Those are different kinds of work. The reason I think the seam is worth the post is that it makes a class of thing — residency, prefetch, eviction, tracing, simulation, replay — stop being compiler features that someone has to ship for you, and start being ordinary code that you can write on a Tuesday. + +## The arc + +v0.7: effects, end to end. v0.8: syscalls are effects, so the kernel is the outermost handler. v0.9: placement is an effect, so the GPU is a handler in the middle. + +I don't have a fourth one yet. But I've stopped being surprised when something that looked like it needed a compiler pass turns out to need a `handle`. + +--- + +Try it: + +``` +loon run os/demo-place.oo # one program, four handlers +loon run os/demo-residency.oo --place device # the transfer gap +loon run samples/place/saxpy.oo --place gpu # on real hardware +``` diff --git a/os/demo-place.oo b/os/demo-place.oo index ef38c8e..70692bf 100644 --- a/os/demo-place.oo +++ b/os/demo-place.oo @@ -10,11 +10,9 @@ ; A two-kernel chain. Chains are where placement policy earns its keep: the ; intermediate never needs to come back to the host, and only a handler is in ; a position to know that. -[kernel scale [i s src dst] - [put dst i [* s [at src i]]]] +[kernel scale [i s src dst] [put dst i [* s [at src i]]]] -[kernel offset [i d buf] - [put buf i [+ d [at buf i]]]] +[kernel offset [i d buf] [put buf i [+ d [at buf i]]]] [fn work [] [let src [buf #[1 2 3 4 5 6 7 8]]] @@ -26,14 +24,14 @@ [fn main [] [IO.println "no handler — it runs right here:"] [IO.println [str " " [work]]] - + [IO.println "traced — every launch and sync is visible:"] [IO.println [str " " [place/trace work]]] - + [IO.println "dry run — accounted for, nothing executed:"] [IO.println [str " " [place/dry-run work]]] - + [IO.println "resident — buffers stay put between launches:"] [IO.println [str " " [place/resident work]]] - + [IO.println [str "totals: " [Place.stats]]]] diff --git a/os/demo-residency.oo b/os/demo-residency.oo index 30d4a23..28022e7 100644 --- a/os/demo-residency.oo +++ b/os/demo-residency.oo @@ -17,8 +17,7 @@ ; program, the same answer, no transfers at all. [use place] -[kernel step [i b] - [put b i [+ 1.0 [at b i]]]] +[kernel step [i b] [put b i [+ 1.0 [at b i]]]] ; Eight launches over the same buffer. Nothing here mentions residency; the ; question "does this buffer need to travel" is not the program's to answer. @@ -36,21 +35,27 @@ [fn report [label before] [let s [Place.stats]] - [IO.println [str " " label - ": uploads " [- [get s :uploads] [get before :uploads]] - ", resident hits " [- [get s :resident-hits] [get before :resident-hits]] - ", bytes in " [- [get s :bytes-in] [get before :bytes-in]]]] + [IO.println + [str + " " + label + ": uploads " + [- [get s :uploads] [get before :uploads]] + ", resident hits " + [- [get s :resident-hits] [get before :resident-hits]] + ", bytes in " + [- [get s :bytes-in] [get before :bytes-in]]]] s] [fn main [] [IO.println "eight launches over one buffer"] - + [let start [Place.stats]] [IO.println [str " answer " [chain]]] [let after-naive [report "no policy" start]] - + [IO.println [str " answer " [place/resident chain]]] [let _ [report "place/resident" after-naive]] - + [IO.println ""] [IO.println "same program, same answer; the handler decided what had to move"]] diff --git a/os/place.oo b/os/place.oo index 070a566..16cc509 100644 --- a/os/place.oo +++ b/os/place.oo @@ -14,41 +14,41 @@ ; [place/trace work] ; watch what happens ; [place/resident work] ; keep buffers where they are ; [place/dry-run work] ; account for it, run nothing - ; ── Watching ──────────────────────────────────────────────────────────────── - ; strace, for placement. Forwards every operation outward unchanged and prints ; what went past. The whole of "GPU tracing" is a handler that performs the ; same operation it intercepted. [fn place/trace [thunk] - [handle [thunk] + [handle + [thunk] [Place.run k n args] - [do [IO.println [str "place: launch " n " work items, " [len args] " args"]] - [resume [Place.run k n args]]] + [do + [IO.println [str "place: launch " n " work items, " [len args] " args"]] + [resume [Place.run k n args]]] [Place.read b] - [do [IO.println [str "place: sync — reading " [buf-len b] " elements back"]] - [resume [Place.read b]]]]] + [do + [IO.println [str "place: sync — reading " [buf-len b] " elements back"]] + [resume [Place.read b]]]]] ; Count launches and syncs without printing anything. Returns the thunk's ; value; ask `Place.stats` afterwards for the totals. [fn place/counted [thunk] - [handle [thunk] - [Place.run k n args] [resume [Place.run k n args]] - [Place.read b] [resume [Place.read b]]]] + [handle + [thunk] + [Place.run k n args] + [resume [Place.run k n args]] + [Place.read b] + [resume [Place.read b]]]] ; ── Accounting without running ────────────────────────────────────────────── - ; Answer every launch by doing nothing, and every read with an empty vector. ; The program runs to completion and its placement decisions are counted, but ; no kernel executes. This is how you ask "what would this cost" — and how a ; program targeting hardware you do not have can still be exercised. [fn place/dry-run [thunk] - [handle [thunk] - [Place.run k n args] [resume []] - [Place.read b] [resume #[]]]] + [handle [thunk] [Place.run k n args] [resume []] [Place.read b] [resume #[]]]] ; ── Residency ─────────────────────────────────────────────────────────────── - ; Keep buffers on the device across launches, and let the host pay for a ; transfer only when it actually looks. ; @@ -64,23 +64,21 @@ ; is what stops the device from dropping it, so the next launch finds it ; already there. [fn place/resident [thunk] - [handle [thunk] + [handle + [thunk] [Place.run k n args] - [do [Place.pin args] - [resume [Place.run k n args]]] + [do [Place.pin args] [resume [Place.run k n args]]] [Place.read b] - [do [let v [Place.read b]] - [Place.unpin b] - [resume v]]]] + [do [let v [Place.read b]] [Place.unpin b] [resume v]]]] ; The same shape, but only keeping the buffers you name. Useful when the ; working set is larger than the device and residency has to be chosen rather ; than assumed — the case the paper flags as needing a heuristic it did not ; ship. Here the heuristic is an argument. [fn place/resident-only [keep thunk] - [handle [thunk] + [handle + [thunk] [Place.run k n args] - [do [Place.pin keep] - [resume [Place.run k n args]]] + [do [Place.pin keep] [resume [Place.run k n args]]] [Place.read b] - [resume [Place.read b]]]] + [resume [Place.read b]]]] diff --git a/samples/place/saxpy.oo b/samples/place/saxpy.oo index ef5ffe8..54fea5c 100644 --- a/samples/place/saxpy.oo +++ b/samples/place/saxpy.oo @@ -8,17 +8,15 @@ ; which have to come back. Loon infers that. `x` and `y` are only ever read ; (`at`), so they are inputs; `out` is written through (`put`), so it is the ; one that has to be synchronized back. - -[kernel saxpy [i a x y out] - [put out i [+ [* a [at x i]] [at y i]]]] +[kernel saxpy [i a x y out] [put out i [+ [* a [at x i]] [at y i]]]] [fn main [] [let n 8] [let x [buf [range 0 n]]] [let y [buf [map [fn [v] [* 2 v]] [range 0 n]]]] [let mut out [buf-zeros n]] - + [Place.run saxpy n #[3.0 x y out]] - + [IO.println [str "out = " [Place.read out]]] [IO.println [str "stats = " [Place.stats]]]] diff --git a/web/src/pages/blog.loon b/web/src/pages/blog.loon index 5cc5264..07ee94a 100644 --- a/web/src/pages/blog.loon +++ b/web/src/pages/blog.loon @@ -81,6 +81,67 @@ :margin-bottom "3.5rem"}} "Changelog"] + ; ── v0.9.0 — Placement is an effect ──────────────────────────────── + [blog-article + "Placement Is an Effect" + "Aug 18, 2026" + + [p + "A syscall is an effect, so the kernel is the outermost handler. Follow the same sentence one step further and the GPU becomes a handler in the middle. Where a kernel runs is no longer a property of the program — it is a decision somebody makes around it, and the program does not move."] + + [blog-h3 "A kernel, and nothing about where it runs"] + [p + "A kernel is an ordinary function that promised to stay small: no closures, no allocation, no strings, no effects. Nothing in it mentions a device, a queue, or a transfer."] + [blog-code + [str + "[kernel saxpy [i a x y out]\n" + " [put out i [+ [* a [at x i]] [at y i]]]]\n" + "\n" + "[Place.run saxpy n #[3.0 x y out]]\n" + "[Place.read out]"]] + [p + "Which arguments travel to the device and which have to come home is inferred, not annotated. Loon already worked out, for every parameter, whether the body reads it, writes through it, or consumes it — the distinction Rust makes you spell as &T, &mut T, and T. Here `at` is a read and `put` is a write-through, so `out` is the one that needs synchronizing back, and the emitted shader binds it read_write while the inputs bind read."] + + [blog-h3 "Residency is nine lines"] + [p + "Because Place.run and Place.read are operations rather than function calls, a handler sees every launch and every synchronization point. That is enough to write a residency policy as ordinary library code — the transfer-hoisting a GPU compiler implements as an optimization pass."] + [blog-code + [str + "[fn place/resident [thunk]\n" + " [handle [thunk]\n" + " [Place.run k n args]\n" + " [do [Place.pin args]\n" + " [resume [Place.run k n args]]]\n" + " [Place.read b]\n" + " [do [let v [Place.read b]]\n" + " [Place.unpin b]\n" + " [resume v]]]]]"]] + [p + "On an Apple M4 Max through Metal, a chain of 128 launches over one buffer takes 356.7 ms with no policy and 18.3 ms under that handler — 19.5x, from 128 uploads down to 2. Same program, same answer; only the line wrapped around it differs."] + + [blog-h3 "Testing a GPU program without a GPU"] + [p + "Launches are events, so they can go on tape. Record a run on the GPU and replay it on a build with no GPU support compiled in at all — the program observes exactly what it observed the first time. A handler that declines to forward gives you a dry run: every accounting number, no execution."] + [blog-code + [str + "$ loon run samples/place/saxpy.oo --place gpu --record trace.oo\n" + "out = #[0 5 10 15 20 25 30 35]\n" + "\n" + "$ loon replay trace.oo samples/place/saxpy.oo ; no GPU in this build\n" + "out = #[0 5 10 15 20 25 30 35]"]] + + [blog-h3 "Landing alongside"] + [ul-el + {:style {:margin-left "1.5rem" :line-height "1.8"}} + [li-el + "Kernels compile to WGSL and every one in the repo is validated by naga in CI, on machines with no GPU."] + [li-el + "One shared value layout across the VM, WASM, and native backends, with a conformance test that compares raw bits — it found three real divergences the first time it ran."] + [li-el + "--place cpu|device|gpu and --place-stats, reporting launches, transfers, and bytes."] + [li-el + "Buffers: dense, unboxed numeric arrays that can leave the process, which persistent collections cannot."]]] + ; ── Record/replay + capability security ──────────────────────────── [blog-article "Record the Bug, Replay It Forever" From 2108ddae38cfcf13cf38b0c5809fcd6c3cfaec35 Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 11:50:44 -0400 Subject: [PATCH 10/25] A typed kernel executor, and every core MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Kernels were running through the general interpreter: every value NaN-boxed, every buffer access through the heap table, every arithmetic operation checking what it was handed. Right for Loon, wrong for a loop doing the same three floating-point operations a million times. eir/kernel_exec.rs runs the numeric subset against raw slices instead. A kernel outside the subset falls back to the VM, so nothing a kernel was allowed to be has been narrowed — `supported()` is a question asked once before a launch, not a requirement. That makes the CPU baseline fair, which matters because "the GPU beats our interpreter" was never an interesting claim. And because the executor works over an index range on plain slices, `--place par` follows: split the range, give each thread a disjoint piece of the output via split_at_mut, and let the borrow checker be the thing that guarantees they do not overlap. The Rust offload paper needs an `unsafe impl` of a partitioning strategy to promise the same property. A kernel that writes outside its own range fails with a message saying so, rather than racing another thread. The same kernel across four placements (Apple M4 Max): elements cpu par gpu 1024 447 µs 566 µs 10.3 ms 262144 8.9 ms 3.3 ms 12.4 ms 1048576 36.4 ms 11.4 ms 19.2 ms The last row is the interesting one: every core beats the GPU here. A machine with this many fast cores, and a launch that pays submission and transfer before computing anything, land that way. That is not a disappointing result — you found it out by changing one word, because the program does not know where it runs, and where the crossover sits is a property of the machine rather than of the code. Co-Authored-By: Claude Fable 5 --- BENCHMARKS.md | 46 +- crates/loon-lang/examples/bench_place.rs | 29 +- crates/loon-lang/src/eir/kernel_exec.rs | 823 +++++++++++++++++++++++ crates/loon-lang/src/eir/mod.rs | 1 + crates/loon-lang/src/eir/place.rs | 9 +- crates/loon-lang/src/eir/vm.rs | 122 +++- crates/loon-lang/tests/place_effect.rs | 58 ++ 7 files changed, 1049 insertions(+), 39 deletions(-) create mode 100644 crates/loon-lang/src/eir/kernel_exec.rs diff --git a/BENCHMARKS.md b/BENCHMARKS.md index 088701a..7a94db3 100644 --- a/BENCHMARKS.md +++ b/BENCHMARKS.md @@ -17,9 +17,9 @@ identical in both columns — the only difference is whether `place/resident` | launches | no policy | place/resident | speedup | |---------:|----------:|---------------:|--------:| -| 8 | 28.9 ms | 9.3 ms | 3.1x | -| 32 | 93.1 ms | 15.4 ms | 6.0x | -| 128 | 356.7 ms | 18.3 ms | 19.5x | +| 8 | 29.3 ms | 8.4 ms | 3.5x | +| 32 | 94.8 ms | 11.2 ms | 8.4x | +| 128 | 358.8 ms | 18.1 ms | 19.9x | The gap grows with the chain because without a policy every launch uploads its arguments, computes, and copies its results back; with one, the buffers stay @@ -39,30 +39,38 @@ Exact counts — these do not vary between runs. | 16 | 32 uploads | 2 uploads | 480 KB | | 64 | 128 uploads | 2 uploads | 2.0 MB | -### Kernel time: interpreter vs GPU +### Kernel time: where it runs -| elements | interpreter | gpu | ratio | -|---------:|------------:|----:|------:| -| 1,024 | 522 µs | 10.0 ms | 0.1x | -| 16,384 | 2.7 ms | 8.7 ms | 0.3x | -| 262,144 | 40.9 ms | 13.4 ms | 3.1x | +The same kernel, the same program, four placements. The CPU columns go through +the typed executor in `eir::kernel_exec` — raw slices, no boxing — so this is a +fair floor rather than a straw man. -Read this one carefully. The CPU column is **Loon's own interpreter** walking -EIR once per work item — the slowest reasonable baseline, not optimized C. The -ratio says how much there is to gain by leaving the interpreter, not how Loon's -generated shader compares to a hand-written kernel. We have not measured the -latter and do not claim it. +| elements | cpu | par | gpu | +|---------:|----:|----:|----:| +| 1,024 | 447 µs | 566 µs | 10.3 ms | +| 16,384 | 853 µs | 647 µs | 7.2 ms | +| 262,144 | 8.9 ms | 3.3 ms | 12.4 ms | +| 1,048,576 | 36.4 ms | 11.4 ms | 19.2 ms | -The GPU loses below ~100k elements, which is the expected shape: a launch is a -submission to another processor and has a fixed cost that small work cannot -amortize. +The interesting row is the last one: on this machine, **every core beats the +GPU** for this kernel at a million elements. An M4 Max has a lot of fast cores, +and a GPU launch pays submission and transfer before it computes anything. That +is not a disappointing result, it is the point — you find it out by changing one +word on the command line, because the program does not know where it runs. + +The GPU only wins when the work per element is large enough to amortize getting +there, and where that crossover sits is a property of the machine, not of the +program. Which is a good argument for the decision living outside the program. + +This is not a comparison against optimized C or a hand-written kernel. That +comparison is not attempted here and nothing above should be quoted as one. ### Launch overhead | | ns per launch | |---|---:| -| cpu | ~7,200 | -| gpu, buffers resident | ~110,000 | +| cpu | ~6,700 | +| gpu, buffers resident | ~92,000 | Placement being an effect means every launch is an effect dispatch. That dispatch is not what you are paying for: an effect operation costs roughly 3x a diff --git a/crates/loon-lang/examples/bench_place.rs b/crates/loon-lang/examples/bench_place.rs index c948348..7f7d909 100644 --- a/crates/loon-lang/examples/bench_place.rs +++ b/crates/loon-lang/examples/bench_place.rs @@ -10,13 +10,11 @@ //! Two things are measured, and it is worth being precise about which is which //! because they answer different questions. //! -//! **Kernel time** compares running a kernel through Loon's own interpreter -//! against running it on the GPU. That is not a comparison against optimized C -//! — the CPU side here is an interpreter walking EIR one work item at a time, -//! which is the slowest reasonable baseline. The number says how much there is -//! to gain by leaving the interpreter, not how Loon's generated code compares -//! to a hand-written kernel. Anyone quoting it as the latter is quoting it -//! wrong. +//! **Kernel time** compares the same kernel across every place it can run: +//! one core, every core, and the GPU. The CPU columns go through the typed +//! executor in `eir::kernel_exec`, not the general interpreter, so this is a +//! fair floor rather than a straw man. It is still not a comparison against +//! optimized C, and nothing here should be quoted as one. //! //! **Transfer counts** compare a chain of launches with no residency policy //! against the same chain under a handler that pins what each launch touches. @@ -95,25 +93,20 @@ fn main() { // element. It is the honest floor, not a tuned baseline. println!("\nkernel time — one launch, varying size"); println!( - " {:>10} {:>12} {:>12} {:>8}", - "elements", "interpreter", "gpu", "ratio" + " {:>10} {:>10} {:>10} {:>10}", + "elements", "cpu", "par", "gpu" ); - for n in [1_024usize, 16_384, 262_144] { + for n in [1_024usize, 16_384, 262_144, 1_048_576] { let src = workload(n, 1); let cpu = timed(&src, Mode::Cpu).map(|(d, _)| d); + let par = timed(&src, Mode::Par).map(|(d, _)| d); let gpu = timed(&src, Mode::Gpu).map(|(d, _)| d); - let ratio = match (cpu, gpu) { - (Some(c), Some(g)) if g.as_secs_f64() > 0.0 => { - format!("{:.1}x", c.as_secs_f64() / g.as_secs_f64()) - } - _ => "—".to_string(), - }; println!( - " {:>10} {:>12} {:>12} {:>8}", + " {:>10} {:>10} {:>10} {:>10}", n, cpu.map(fmt).unwrap_or_else(|| "—".into()), + par.map(fmt).unwrap_or_else(|| "—".into()), gpu.map(fmt).unwrap_or_else(|| "skipped".into()), - ratio ); } diff --git a/crates/loon-lang/src/eir/kernel_exec.rs b/crates/loon-lang/src/eir/kernel_exec.rs new file mode 100644 index 0000000..e58fbaa --- /dev/null +++ b/crates/loon-lang/src/eir/kernel_exec.rs @@ -0,0 +1,823 @@ +//! Running a kernel on the CPU without going through the general VM. +//! +//! The interpreter is built for a dynamically-typed language: every value is +//! NaN-boxed, every buffer access goes through the heap table, and every +//! arithmetic operation checks what it was handed. That is the right design +//! for Loon and the wrong one for a loop that runs the same three floating +//! point operations a million times. +//! +//! A kernel does not need any of it. The subset is small enough that every +//! register has a knowable type, every buffer is a contiguous slice, and the +//! whole body can be executed against raw `f32`s. This module does that: it +//! type-checks the kernel once, then runs it per work item with no boxing and +//! no heap indirection. +//! +//! Two things follow. The CPU number in a benchmark becomes a fair baseline +//! rather than a straw man — "the GPU is faster than our interpreter" is not +//! an interesting claim. And because the executor works on plain slices over +//! an index range, running work items in parallel is a matter of splitting the +//! range, which is where `Mode::Par` comes from. + +use super::layout::DType; +use super::vm::{BufData, Buffer}; +use super::{BinOp, Built, End, FuncId, Lit, Module, Op, Reg, UnOp}; + +/// A value inside a running kernel. +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum KVal { + F(f64), + I(i64), + B(bool), + Unit, +} + +impl KVal { + fn as_f(self) -> f64 { + match self { + KVal::F(x) => x, + KVal::I(n) => n as f64, + KVal::B(b) => { + if b { + 1.0 + } else { + 0.0 + } + } + KVal::Unit => 0.0, + } + } + + fn as_i(self) -> i64 { + match self { + KVal::I(n) => n, + KVal::F(x) => x as i64, + KVal::B(b) => b as i64, + KVal::Unit => 0, + } + } + + fn truthy(self) -> bool { + match self { + KVal::B(b) => b, + KVal::I(n) => n != 0, + KVal::F(x) => x != 0.0, + KVal::Unit => false, + } + } + + /// Whether either operand is a float, which decides the result's type. + fn either_float(a: KVal, b: KVal) -> bool { + matches!(a, KVal::F(_)) || matches!(b, KVal::F(_)) + } +} + +/// A writable slice of one buffer's elements. +/// +/// Parallel placement hands each thread a different one of these, carved out +/// of the same buffer with `split_at_mut`. That the pieces do not overlap is +/// not a promise anybody makes — it is what `split_at_mut` returns, checked by +/// the compiler. A GPU partitioning strategy has to assert the same property +/// through an `unsafe impl`. +pub enum OutView<'a> { + F32(&'a mut [f32]), + F64(&'a mut [f64]), + I32(&'a mut [i32]), + I64(&'a mut [i64]), +} + +impl OutView<'_> { + fn len(&self) -> usize { + match self { + OutView::F32(v) => v.len(), + OutView::F64(v) => v.len(), + OutView::I32(v) => v.len(), + OutView::I64(v) => v.len(), + } + } +} + +/// An argument to a kernel launch. +pub enum KArg<'a> { + /// A buffer the kernel only reads. + Input(&'a Buffer), + /// A buffer the kernel writes through. + Output(&'a mut Buffer), + /// A slice of a buffer, addressed by absolute index. + /// + /// `base` is the index this view starts at, so a work item writing at its + /// own index lands in the right place. A write outside the view is an + /// error rather than a silent miss: in parallel placement it means the + /// kernel wrote somewhere another thread owns. + OutputView { view: OutView<'a>, base: i64 }, + /// A number. + Scalar(KVal), +} + +/// Why a kernel could not be run this way. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Error(pub String); + +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.0) + } +} + +/// Can this function be run by the fast executor? +/// +/// Checked once before a launch rather than per work item. A kernel that fails +/// here is not wrong — it simply uses something outside the subset, and the +/// general VM runs it instead. +pub fn supported(module: &Module, func: FuncId) -> bool { + let Some(f) = module.funcs.get(func.0 as usize) else { + return false; + }; + f.blocks.iter().all(|b| { + b.ops.iter().all(|op| { + matches!(op, Op::Lit(..) | Op::Mov(..) | Op::Bin(..) | Op::Un(..)) + || matches!(op, Op::Builtin(_, built, ..) if supported_builtin(*built)) + }) && matches!( + b.end, + End::Ret(_) | End::Jmp(..) | End::Br(..) | End::Recur(_) | End::Trap + ) + }) +} + +fn supported_builtin(b: Built) -> bool { + matches!( + b, + Built::BufAt + | Built::BufPut + | Built::BufLen + | Built::Sqrt + | Built::Pow + | Built::Floor + | Built::Ceil + | Built::Round + | Built::Sin + | Built::Cos + | Built::Tan + | Built::Asin + | Built::Acos + | Built::Atan + | Built::Atan2 + | Built::Log + | Built::Log10 + | Built::Exp + | Built::Abs + | Built::Min + | Built::Max + | Built::Not + ) +} + +/// Run `func` for every index in `range`. +/// +/// Buffer arguments are borrowed for the whole call, which is what makes the +/// disjointness argument work: an output buffer is a `&mut` slice, so the type +/// system will not let two ranges write the same one at once. That is the same +/// guarantee a GPU partitioning strategy has to promise by hand. +pub fn run_range( + module: &Module, + func: FuncId, + args: &mut [KArg<'_>], + range: std::ops::Range, +) -> Result<(), Error> { + let f = module + .funcs + .get(func.0 as usize) + .ok_or_else(|| Error(format!("no function {func:?}")))?; + if f.params.len() != args.len() + 1 { + return Err(Error(format!( + "kernel takes {} parameters but {} arguments were given", + f.params.len(), + args.len() + 1 + ))); + } + + let reg_count = f + .blocks + .iter() + .flat_map(|b| { + b.ops + .iter() + .filter_map(dest) + .chain(b.params.iter().copied()) + }) + .map(|r| r.0 as usize + 1) + .max() + .unwrap_or(1) + .max(args.len() + 1); + + let mut regs = vec![KVal::Unit; reg_count]; + for i in range { + run_one(module, f.id, args, &mut regs, i)?; + } + Ok(()) +} + +/// Run a kernel across every core, splitting the index space. +/// +/// Each thread gets a disjoint slice of the single output buffer and the whole +/// of every input. The disjointness is not asserted — it is what +/// `split_at_mut` hands back, and the borrow checker is what enforces it. A +/// kernel that writes outside its own range fails with a message saying so +/// rather than racing another thread. +/// +/// Falls back to sequential execution when the shape does not fit (no output, +/// or more than one), because a wrong answer computed in parallel is not an +/// improvement over a right one computed serially. +pub fn run_parallel( + module: &Module, + func: FuncId, + args: &mut [KArg<'_>], + n: i64, +) -> Result<(), Error> { + let threads = std::thread::available_parallelism() + .map(|p| p.get()) + .unwrap_or(1) + .min(n.max(1) as usize); + + let outputs: Vec = args + .iter() + .enumerate() + .filter(|(_, a)| matches!(a, KArg::Output(_))) + .map(|(i, _)| i) + .collect(); + if threads <= 1 || outputs.len() != 1 || n <= 0 { + return run_range(module, func, args, 0..n); + } + let out_index = outputs[0]; + + // Split the work into contiguous chunks, one per thread. + let chunk = (n as usize).div_ceil(threads); + let mut ranges: Vec<(i64, usize)> = Vec::new(); + let mut start = 0usize; + while start < n as usize { + let len = chunk.min(n as usize - start); + ranges.push((start as i64, len)); + start += len; + } + + // Take the output buffer apart, and everything else by shared reference. + let (before, rest_args) = args.split_at_mut(out_index); + let (out_arg, after) = rest_args.split_first_mut().expect("an output argument"); + let KArg::Output(out_buf) = out_arg else { + return Err(Error("expected an output buffer".into())); + }; + + let shared: Vec<&KArg<'_>> = before.iter().chain(after.iter()).collect(); + + macro_rules! split_and_run { + ($variant:ident, $data:expr) => {{ + let mut remaining: &mut [_] = $data; + let mut pieces: Vec<(i64, &mut [_])> = Vec::new(); + for (base, len) in &ranges { + let (head, tail) = remaining.split_at_mut(*len); + pieces.push((*base, head)); + remaining = tail; + } + std::thread::scope(|scope| { + let mut handles = Vec::new(); + for (base, piece) in pieces { + let shared = &shared; + handles.push(scope.spawn(move || { + let mut local: Vec = Vec::with_capacity(shared.len() + 1); + let mut si = shared.iter(); + for i in 0..=shared.len() { + if i == out_index { + local.push(KArg::OutputView { + view: OutView::$variant(piece), + base, + }); + break; + } + local.push(borrow_arg(si.next().expect("an argument"))); + } + // Anything after the output. + for a in si { + local.push(borrow_arg(a)); + } + let len = match local.get(out_index) { + Some(KArg::OutputView { view, .. }) => view.len() as i64, + _ => 0, + }; + run_range(module, func, &mut local, base..base + len) + })); + } + let mut result = Ok(()); + for h in handles { + match h.join() { + Ok(Ok(())) => {} + Ok(Err(e)) => result = Err(e), + Err(_) => result = Err(Error("a kernel thread panicked".into())), + } + } + result + }) + }}; + } + + match &mut out_buf.data { + BufData::F32(v) => split_and_run!(F32, &mut v[..]), + BufData::F64(v) => split_and_run!(F64, &mut v[..]), + BufData::I32(v) => split_and_run!(I32, &mut v[..]), + BufData::I64(v) => split_and_run!(I64, &mut v[..]), + } +} + +/// Re-borrow a shared argument for one thread. Only inputs and scalars reach +/// here; the single output is split separately. +fn borrow_arg<'a>(a: &'a KArg<'_>) -> KArg<'a> { + match a { + KArg::Input(b) => KArg::Input(b), + KArg::Scalar(v) => KArg::Scalar(*v), + _ => KArg::Scalar(KVal::Unit), + } +} + +fn run_one( + module: &Module, + func: FuncId, + args: &mut [KArg<'_>], + regs: &mut [KVal], + index: i64, +) -> Result<(), Error> { + let f = &module.funcs[func.0 as usize]; + + // Parameters: the work index, then the arguments. Buffers do not occupy a + // register value — they are addressed by argument position. + regs[0] = KVal::I(index); + for (i, arg) in args.iter().enumerate() { + regs[i + 1] = match arg { + KArg::Scalar(v) => *v, + // A buffer's "value" is its own position, so `at`/`put` can find + // it. Nothing else in the subset reads a buffer as a number. + _ => KVal::I(i as i64), + }; + } + + let mut block = 0usize; + let mut steps = 0usize; + loop { + steps += 1; + if steps > 1_000_000 { + return Err(Error("kernel did not terminate".into())); + } + let b = &f.blocks[block]; + for op in &b.ops { + exec_op(op, args, regs)?; + } + match &b.end { + End::Ret(_) | End::Trap => return Ok(()), + End::Jmp(target, jargs) => { + let target_block = &f.blocks[target.0 as usize]; + let vals: Vec = jargs.iter().map(|r| regs[r.0 as usize]).collect(); + for (p, v) in target_block.params.iter().zip(vals) { + regs[p.0 as usize] = v; + } + block = target.0 as usize; + } + End::Br(cond, t, e) => { + block = if regs[cond.0 as usize].truthy() { + t.0 as usize + } else { + e.0 as usize + }; + } + End::Recur(rargs) => { + let vals: Vec = rargs.iter().map(|r| regs[r.0 as usize]).collect(); + let params = b.params.clone(); + for (p, v) in params.iter().zip(vals) { + regs[p.0 as usize] = v; + } + } + other => return Err(Error(format!("{other:?} is outside the kernel subset"))), + } + } +} + +fn exec_op(op: &Op, args: &mut [KArg<'_>], regs: &mut [KVal]) -> Result<(), Error> { + match op { + Op::Lit(d, lit, _) => { + regs[d.0 as usize] = match lit { + Lit::Int(n) => KVal::I(*n), + Lit::Float(x) => KVal::F(*x), + Lit::Bool(b) => KVal::B(*b), + Lit::Unit => KVal::Unit, + other => return Err(Error(format!("{other:?} is outside the kernel subset"))), + }; + } + Op::Mov(d, s, _) => regs[d.0 as usize] = regs[s.0 as usize], + Op::Bin(d, bop, a, b, _) => { + let (x, y) = (regs[a.0 as usize], regs[b.0 as usize]); + regs[d.0 as usize] = binop(*bop, x, y)?; + } + Op::Un(d, uop, a, _) => { + let v = regs[a.0 as usize]; + regs[d.0 as usize] = match uop { + UnOp::Neg => match v { + KVal::I(n) => KVal::I(-n), + other => KVal::F(-other.as_f()), + }, + UnOp::Not => KVal::B(!v.truthy()), + }; + } + Op::Builtin(d, built, bargs, _) => exec_builtin(*d, *built, bargs, args, regs)?, + other => return Err(Error(format!("{other:?} is outside the kernel subset"))), + } + Ok(()) +} + +fn binop(bop: BinOp, x: KVal, y: KVal) -> Result { + let float = KVal::either_float(x, y); + Ok(match bop { + BinOp::Add | BinOp::Sub | BinOp::Mul | BinOp::Div | BinOp::Rem => { + if float { + let (a, b) = (x.as_f(), y.as_f()); + KVal::F(match bop { + BinOp::Add => a + b, + BinOp::Sub => a - b, + BinOp::Mul => a * b, + BinOp::Div => a / b, + _ => a % b, + }) + } else { + let (a, b) = (x.as_i(), y.as_i()); + // Integer division by zero has a decided answer in Loon (it is + // an error, not a silent value); the kernel subset does not get + // to invent a different one, so the executor declines instead. + if matches!(bop, BinOp::Div | BinOp::Rem) && b == 0 { + return Err(Error("integer division by zero in a kernel".into())); + } + KVal::I(match bop { + BinOp::Add => a + b, + BinOp::Sub => a - b, + BinOp::Mul => a * b, + BinOp::Div => a / b, + _ => a % b, + }) + } + } + BinOp::Eq => KVal::B(if float { + x.as_f() == y.as_f() + } else { + x.as_i() == y.as_i() + }), + BinOp::Ne => KVal::B(if float { + x.as_f() != y.as_f() + } else { + x.as_i() != y.as_i() + }), + BinOp::Lt => KVal::B(if float { + x.as_f() < y.as_f() + } else { + x.as_i() < y.as_i() + }), + BinOp::Gt => KVal::B(if float { + x.as_f() > y.as_f() + } else { + x.as_i() > y.as_i() + }), + BinOp::Le => KVal::B(if float { + x.as_f() <= y.as_f() + } else { + x.as_i() <= y.as_i() + }), + BinOp::Ge => KVal::B(if float { + x.as_f() >= y.as_f() + } else { + x.as_i() >= y.as_i() + }), + BinOp::And => KVal::B(x.truthy() && y.truthy()), + BinOp::Or => KVal::B(x.truthy() || y.truthy()), + BinOp::Concat => return Err(Error("a kernel cannot concatenate strings".into())), + }) +} + +fn exec_builtin( + d: Reg, + built: Built, + bargs: &[Reg], + args: &mut [KArg<'_>], + regs: &mut [KVal], +) -> Result<(), Error> { + let slot = |i: usize| -> usize { regs[bargs[i].0 as usize].as_i() as usize }; + + match built { + Built::BufAt => { + let which = slot(0); + let idx = regs[bargs[1].0 as usize].as_i(); + let v = read_buffer(args, which, idx)?; + regs[d.0 as usize] = v; + } + Built::BufPut => { + let which = slot(0); + let idx = regs[bargs[1].0 as usize].as_i(); + let v = regs[bargs[2].0 as usize]; + write_buffer(args, which, idx, v)?; + regs[d.0 as usize] = KVal::Unit; + } + Built::BufLen => { + let which = slot(0); + let len = match args.get(which) { + Some(KArg::Input(b)) => b.len(), + Some(KArg::Output(b)) => b.len(), + Some(KArg::OutputView { view, .. }) => view.len(), + _ => return Err(Error("buf-len needs a buffer".into())), + }; + regs[d.0 as usize] = KVal::I(len as i64); + } + _ => { + let a = |i: usize| regs[bargs.get(i).map(|r| r.0 as usize).unwrap_or(0)].as_f(); + regs[d.0 as usize] = match built { + Built::Sqrt => KVal::F(a(0).sqrt()), + Built::Pow => KVal::F(a(0).powf(a(1))), + Built::Floor => KVal::F(a(0).floor()), + Built::Ceil => KVal::F(a(0).ceil()), + Built::Round => KVal::F(a(0).round()), + Built::Sin => KVal::F(a(0).sin()), + Built::Cos => KVal::F(a(0).cos()), + Built::Tan => KVal::F(a(0).tan()), + Built::Asin => KVal::F(a(0).asin()), + Built::Acos => KVal::F(a(0).acos()), + Built::Atan => KVal::F(a(0).atan()), + Built::Atan2 => KVal::F(a(0).atan2(a(1))), + Built::Log => KVal::F(a(0).ln()), + Built::Log10 => KVal::F(a(0).log10()), + Built::Exp => KVal::F(a(0).exp()), + Built::Abs => match regs[bargs[0].0 as usize] { + KVal::I(n) => KVal::I(n.abs()), + other => KVal::F(other.as_f().abs()), + }, + Built::Min | Built::Max => { + let (x, y) = (regs[bargs[0].0 as usize], regs[bargs[1].0 as usize]); + let take_min = matches!(built, Built::Min); + if KVal::either_float(x, y) { + let (p, q) = (x.as_f(), y.as_f()); + KVal::F(if take_min { p.min(q) } else { p.max(q) }) + } else { + let (p, q) = (x.as_i(), y.as_i()); + KVal::I(if take_min { p.min(q) } else { p.max(q) }) + } + } + Built::Not => KVal::B(!regs[bargs[0].0 as usize].truthy()), + other => return Err(Error(format!("builtin {other:?} is outside the subset"))), + }; + } + } + Ok(()) +} + +fn read_buffer(args: &[KArg<'_>], which: usize, idx: i64) -> Result { + if let Some(KArg::OutputView { view, base }) = args.get(which) { + let rel = idx - base; + let i = usize::try_from(rel).map_err(|_| out_of_view(idx))?; + return match view { + OutView::F32(v) => v.get(i).map(|x| KVal::F(*x as f64)), + OutView::F64(v) => v.get(i).map(|x| KVal::F(*x)), + OutView::I32(v) => v.get(i).map(|x| KVal::I(*x as i64)), + OutView::I64(v) => v.get(i).map(|x| KVal::I(*x)), + } + .ok_or_else(|| out_of_view(idx)); + } + let buf = match args.get(which) { + Some(KArg::Input(b)) => *b, + Some(KArg::Output(b)) => &**b, + _ => return Err(Error(format!("argument {} is not a buffer", which + 1))), + }; + let i = usize::try_from(idx).map_err(|_| out_of_range(idx, buf.len()))?; + match &buf.data { + BufData::F32(v) => v.get(i).map(|x| KVal::F(*x as f64)), + BufData::F64(v) => v.get(i).map(|x| KVal::F(*x)), + BufData::I32(v) => v.get(i).map(|x| KVal::I(*x as i64)), + BufData::I64(v) => v.get(i).map(|x| KVal::I(*x)), + } + .ok_or_else(|| out_of_range(idx, buf.len())) +} + +fn write_buffer(args: &mut [KArg<'_>], which: usize, idx: i64, v: KVal) -> Result<(), Error> { + if let Some(KArg::OutputView { view, base }) = args.get_mut(which) { + let rel = idx - *base; + let i = usize::try_from(rel).map_err(|_| out_of_view(idx))?; + if i >= view.len() { + return Err(out_of_view(idx)); + } + match view { + OutView::F32(b) => b[i] = v.as_f() as f32, + OutView::F64(b) => b[i] = v.as_f(), + OutView::I32(b) => b[i] = v.as_i() as i32, + OutView::I64(b) => b[i] = v.as_i(), + } + return Ok(()); + } + let Some(KArg::Output(buf)) = args.get_mut(which) else { + return Err(Error(format!( + "argument {} is not a buffer this kernel may write", + which + 1 + ))); + }; + let len = buf.len(); + let i = usize::try_from(idx).map_err(|_| out_of_range(idx, len))?; + if i >= len { + return Err(out_of_range(idx, len)); + } + match &mut buf.data { + BufData::F32(b) => b[i] = v.as_f() as f32, + BufData::F64(b) => b[i] = v.as_f(), + BufData::I32(b) => b[i] = v.as_i() as i32, + BufData::I64(b) => b[i] = v.as_i(), + } + Ok(()) +} + +fn out_of_range(idx: i64, len: usize) -> Error { + Error(format!("index {idx} is outside a buffer of length {len}")) +} + +/// A write that left the slice this thread owns. +/// +/// In parallel placement that means the kernel wrote at an index other than +/// its own — a scatter. Saying so is the point: the alternative is threads +/// quietly overwriting each other's elements. +fn out_of_view(idx: i64) -> Error { + Error(format!( + "index {idx} is outside the range this work item owns; a kernel run in \ + parallel must write at its own index" + )) +} + +/// Element type of a buffer, for callers deciding how to narrow it. +pub fn dtype_of(b: &Buffer) -> DType { + b.dtype() +} + +fn dest(op: &Op) -> Option { + match op { + Op::Lit(d, ..) + | Op::Mov(d, ..) + | Op::Bin(d, ..) + | Op::Un(d, ..) + | Op::Builtin(d, ..) + | Op::Upval(d, ..) + | Op::Call(d, ..) + | Op::Invoke(d, ..) + | Op::Close(d, ..) + | Op::Vec(d, ..) + | Op::Map(d, ..) + | Op::Set(d, ..) + | Op::Tup(d, ..) + | Op::Adt(d, ..) + | Op::Field(d, ..) + | Op::Tag(d, ..) + | Op::Perform(d, ..) + | Op::PushHandler(d, ..) => Some(*d), + Op::PopHandler(_) => None, + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::check::Checker; + use crate::eir::lower::lower; + use crate::parser::parse; + + fn lowered(src: &str, name: &str) -> (Module, FuncId) { + let exprs = parse(src).expect("parses"); + let mut checker = Checker::new(); + let errors = checker.check_program(&exprs); + assert!(errors.is_empty(), "check errors: {errors:?}"); + let module = lower(&checker); + let id = module + .funcs + .iter() + .find(|f| f.name.as_deref() == Some(name)) + .expect("kernel lowered") + .id; + (module, id) + } + + fn f32s(b: &Buffer) -> Vec { + match &b.data { + BufData::F32(v) => v.clone(), + other => panic!("expected f32, got {other:?}"), + } + } + + #[test] + fn a_kernel_runs_over_a_range() { + let (m, id) = lowered( + "[kernel saxpy [i a x y out] [put out i [+ [* a [at x i]] [at y i]]]]", + "saxpy", + ); + let x = Buffer { + data: BufData::F32(vec![1.0, 2.0, 3.0, 4.0]), + }; + let y = Buffer { + data: BufData::F32(vec![10.0, 20.0, 30.0, 40.0]), + }; + let mut out = Buffer { + data: BufData::F32(vec![0.0; 4]), + }; + { + let mut args = vec![ + KArg::Scalar(KVal::F(2.0)), + KArg::Input(&x), + KArg::Input(&y), + KArg::Output(&mut out), + ]; + run_range(&m, id, &mut args, 0..4).expect("runs"); + } + assert_eq!(f32s(&out), vec![12.0, 24.0, 36.0, 48.0]); + } + + #[test] + fn a_partial_range_touches_only_its_own_elements() { + // This is the property that makes splitting a range across threads + // sound: a work item writes at its own index and nowhere else. + let (m, id) = lowered("[kernel fill [i b] [put b i 9.0]]", "fill"); + let mut out = Buffer { + data: BufData::F32(vec![0.0; 6]), + }; + { + let mut args = vec![KArg::Output(&mut out)]; + run_range(&m, id, &mut args, 2..4).expect("runs"); + } + assert_eq!(f32s(&out), vec![0.0, 0.0, 9.0, 9.0, 0.0, 0.0]); + } + + #[test] + fn control_flow_inside_a_kernel_works() { + let (m, id) = lowered( + "[kernel clamp [i lo hi b] \ + [let v [at b i]] \ + [put b i [if [< v lo] lo [if [> v hi] hi v]]]]", + "clamp", + ); + let mut b = Buffer { + data: BufData::F32(vec![-5.0, 0.5, 9.0]), + }; + { + let mut args = vec![ + KArg::Scalar(KVal::F(0.0)), + KArg::Scalar(KVal::F(1.0)), + KArg::Output(&mut b), + ]; + run_range(&m, id, &mut args, 0..3).expect("runs"); + } + assert_eq!(f32s(&b), vec![0.0, 0.5, 1.0]); + } + + #[test] + fn math_builtins_agree_with_the_interpreter() { + let src = "[kernel mathy [i b] [put b i [sqrt [abs [at b i]]]]]"; + let (m, id) = lowered(src, "mathy"); + let mut b = Buffer { + data: BufData::F32(vec![-4.0, 9.0, 16.0]), + }; + { + let mut args = vec![KArg::Output(&mut b)]; + run_range(&m, id, &mut args, 0..3).expect("runs"); + } + assert_eq!(f32s(&b), vec![2.0, 3.0, 4.0]); + } + + #[test] + fn reading_past_the_end_is_an_error_here_too() { + // The fast path must not become the path where bounds stop being + // checked. An out-of-range read is a bug in the program whichever + // executor runs it. + let (m, id) = lowered("[kernel bad [i b] [put b i [at b 99]]]", "bad"); + let mut b = Buffer { + data: BufData::F32(vec![0.0; 2]), + }; + let mut args = vec![KArg::Output(&mut b)]; + let e = run_range(&m, id, &mut args, 0..2).expect_err("should fail"); + assert!(e.0.contains("outside a buffer"), "{}", e.0); + } + + #[test] + fn integer_buffers_stay_integers() { + let (m, id) = lowered("[kernel bump [i b] [put b i [+ 1 [at b i]]]]", "bump"); + let mut b = Buffer { + data: BufData::I32(vec![1, 2, 3]), + }; + { + let mut args = vec![KArg::Output(&mut b)]; + run_range(&m, id, &mut args, 0..3).expect("runs"); + } + assert_eq!(b.data, BufData::I32(vec![2, 3, 4])); + } + + #[test] + fn support_is_decided_before_the_launch_not_during_it() { + let (m, id) = lowered("[kernel ok [i b] [put b i 1.0]]", "ok"); + assert!(supported(&m, id)); + + // A function using something outside the subset is declined, so the + // caller can fall back to the general VM rather than fail. + let (m2, id2) = lowered("[fn nope [i] [str i]] [fn main [] []]", "nope"); + assert!(!supported(&m2, id2)); + } +} diff --git a/crates/loon-lang/src/eir/mod.rs b/crates/loon-lang/src/eir/mod.rs index c789698..2677c34 100644 --- a/crates/loon-lang/src/eir/mod.rs +++ b/crates/loon-lang/src/eir/mod.rs @@ -6,6 +6,7 @@ pub mod backend; #[cfg(feature = "gpu")] pub mod gpu; +pub mod kernel_exec; pub mod layout; pub mod lower; #[cfg(feature = "native")] diff --git a/crates/loon-lang/src/eir/place.rs b/crates/loon-lang/src/eir/place.rs index 707e0a0..53fb8c7 100644 --- a/crates/loon-lang/src/eir/place.rs +++ b/crates/loon-lang/src/eir/place.rs @@ -143,6 +143,11 @@ pub enum Mode { /// Right here. There is one memory, so nothing is ever transferred. #[default] Cpu, + /// Every core on this machine, over disjoint slices of the index space. + /// + /// Still one memory, so nothing is transferred — the only thing that + /// changes is how many work items run at once. + Par, /// A real GPU, through wgpu. /// /// Requires the `gpu` feature; without it, asking for this mode is an @@ -165,6 +170,7 @@ impl Mode { match s { "cpu" | "serial" | "here" => Some(Mode::Cpu), "device" | "sim" => Some(Mode::Device), + "par" | "parallel" | "threads" => Some(Mode::Par), "gpu" | "metal" | "wgpu" => Some(Mode::Gpu), _ => None, } @@ -179,6 +185,7 @@ impl Mode { pub fn name(self) -> &'static str { match self { Mode::Cpu => "cpu", + Mode::Par => "par", Mode::Device => "device", Mode::Gpu => "gpu", } @@ -316,7 +323,7 @@ mod tests { #[test] fn mode_names_round_trip() { - for m in [Mode::Cpu, Mode::Device, Mode::Gpu] { + for m in [Mode::Cpu, Mode::Par, Mode::Device, Mode::Gpu] { assert_eq!(Mode::parse(m.name()), Some(m)); } assert_eq!(Mode::parse("sim"), Some(Mode::Device)); diff --git a/crates/loon-lang/src/eir/vm.rs b/crates/loon-lang/src/eir/vm.rs index 552ae07..2dbfda3 100644 --- a/crates/loon-lang/src/eir/vm.rs +++ b/crates/loon-lang/src/eir/vm.rs @@ -867,6 +867,20 @@ impl Vm { return Ok(Val::UNIT); } + // The typed executor handles the numeric subset without boxing every + // value or walking the heap for every element. Kernels outside the + // subset fall through to the general VM below, which is why this is a + // question rather than a requirement. + if matches!( + self.place_mode, + crate::eir::place::Mode::Cpu | crate::eir::place::Mode::Par + ) && crate::eir::kernel_exec::supported(&self.module, func_id) + { + if let Some(result) = self.place_run_fast(func_id, &rest, n)? { + return Ok(result); + } + } + let mut call_args = Vec::with_capacity(rest.len() + 1); for i in 0..n { call_args.clear(); @@ -1060,6 +1074,112 @@ impl Vm { VmError::new(VmErrorKind::BuiltinType(message)).with_span(self.current_span) } + /// Run a kernel through the typed executor, if its arguments allow it. + /// + /// Returns `None` when the shape is not one this path handles (an aliased + /// buffer, say), so the caller falls back rather than failing. Buffers are + /// taken out of the heap for the duration and put back afterwards, which + /// is what lets the executor hold a `&mut` slice — and, in parallel mode, + /// hand disjoint pieces of it to different threads. + fn place_run_fast( + &mut self, + func_id: FuncId, + rest: &[Val], + n: i64, + ) -> Result, VmError> { + use crate::eir::kernel_exec::{KArg, KVal}; + + // Which arguments are buffers, and which of those are written? + let kinds = crate::eir::wgsl::infer_arg_kinds(&self.module, func_id, DType::F32); + if kinds.len() != rest.len() { + return Ok(None); + } + + // A buffer appearing twice would need two borrows of the same slot. + let mut seen: Vec = Vec::new(); + for val in rest { + if val.is_ptr() && matches!(self.heap.get(val.as_ptr()), Some(Obj::Buffer(_))) { + if seen.contains(&val.as_ptr()) { + return Ok(None); + } + seen.push(val.as_ptr()); + } + } + + // Take each buffer out of the heap so it can be borrowed mutably. + let mut taken: Vec<(usize, Buffer, bool)> = Vec::new(); + let mut scalars: Vec<(usize, KVal)> = Vec::new(); + for (i, val) in rest.iter().enumerate() { + let writable = matches!( + kinds[i], + crate::eir::wgsl::ArgKind::Buffer { writable: true, .. } + ); + match self.heap.get(val.as_ptr()) { + Some(Obj::Buffer(b)) if val.is_ptr() => { + taken.push((i, b.clone(), writable)); + } + _ => { + let v = if val.is_int() { + KVal::I(val.as_int()) + } else if val.is_float() { + KVal::F(val.as_float()) + } else { + return Ok(None); + }; + scalars.push((i, v)); + } + } + } + + let parallel = self.place_mode == crate::eir::place::Mode::Par; + let module = self.module.clone(); + let outcome = { + // Assemble the argument list in declaration order. + let mut buffers: Vec<(usize, Buffer, bool)> = taken; + let mut args: Vec = Vec::with_capacity(rest.len()); + { + let mut scalar_iter = scalars.iter(); + let mut buf_iter = buffers.iter_mut(); + for i in 0..rest.len() { + if scalars.iter().any(|(j, _)| *j == i) { + let (_, v) = scalar_iter.next().expect("a scalar"); + args.push(KArg::Scalar(*v)); + } else { + let (_, b, writable) = buf_iter.next().expect("a buffer"); + if *writable { + args.push(KArg::Output(b)); + } else { + args.push(KArg::Input(b)); + } + } + } + } + let r = if parallel { + crate::eir::kernel_exec::run_parallel(&module, func_id, &mut args, n) + } else { + crate::eir::kernel_exec::run_range(&module, func_id, &mut args, 0..n) + }; + drop(args); + r.map(|_| buffers) + }; + + let buffers = match outcome { + Ok(b) => b, + Err(e) => { + return Err(VmError::new(VmErrorKind::BuiltinType(e.0)).with_span(self.current_span)) + } + }; + + // Put the results back where the program can see them. + for (i, buf, _) in buffers { + let val = rest[i]; + if let Some(slot) = self.heap.get_mut(val.as_ptr()) { + *slot = Obj::Buffer(buf); + } + } + Ok(Some(Val::UNIT)) + } + /// Heap slot, byte length, and element type of a buffer value. fn buffer_info(&self, val: Val) -> Option<(usize, u64, DType)> { match self.get_obj(val) { @@ -3992,7 +4112,7 @@ impl Vm { // one memory, so the read is free — and saying so keeps the // two modes comparable. let must_transfer = match self.place_mode { - crate::eir::place::Mode::Cpu => true, + crate::eir::place::Mode::Cpu | crate::eir::place::Mode::Par => true, crate::eir::place::Mode::Device | crate::eir::place::Mode::Gpu => { self.place_device.is_dirty(id) } diff --git a/crates/loon-lang/tests/place_effect.rs b/crates/loon-lang/tests/place_effect.rs index 5e644b4..71274c1 100644 --- a/crates/loon-lang/tests/place_effect.rs +++ b/crates/loon-lang/tests/place_effect.rs @@ -313,3 +313,61 @@ fn on_the_cpu_there_is_nothing_to_transfer() { assert_eq!(stats.uploads, 0); assert_eq!(stats.launches, 8); } + +// ── Every placement gives the same answer ─────────────────────────────────── + +#[test] +fn cpu_and_parallel_agree_on_everything() { + // The property that makes placement a policy rather than a rewrite: the + // answer does not depend on where the work happened. Parallel execution + // hands each thread a disjoint slice of the output, so this is also the + // test that the split is right. + use loon_lang::eir::place::Mode; + let dir = std::env::current_dir().expect("cwd"); + + let programs = [ + "[kernel saxpy [i a x y out] [put out i [+ [* a [at x i]] [at y i]]]] \ + [fn main [] \ + [let x [buf [range 0 1000]]] [let y [buf [range 0 1000]]] \ + [let mut out [buf-zeros 1000]] \ + [Place.run saxpy 1000 #[2.0 x y out]] \ + [IO.println [sum [Place.read out]]]]", + "[kernel clamp [i lo hi b] [let v [at b i]] \ + [put b i [if [< v lo] lo [if [> v hi] hi v]]]] \ + [fn main [] \ + [let mut b [buf [range 0 500]]] \ + [Place.run clamp 500 #[10.0 100.0 b]] \ + [IO.println [sum [Place.read b]]]]", + "[kernel mathy [i b] [put b i [sqrt [abs [at b i]]]]] \ + [fn main [] \ + [let mut b [buf [range 0 777]]] \ + [Place.run mathy 777 #[b]] \ + [IO.println [len [Place.read b]]]]", + ]; + + for src in programs { + let (cpu, _) = loon_lang::eir::vm::eval_eir_placed(src, &dir, Mode::Cpu).expect("cpu"); + let (par, _) = loon_lang::eir::vm::eval_eir_placed(src, &dir, Mode::Par).expect("par"); + assert_eq!( + cpu.output, par.output, + "parallel placement changed the answer for:\n{src}" + ); + assert!(!cpu.output.is_empty()); + } +} + +#[test] +fn a_kernel_outside_the_fast_subset_still_runs() { + // The typed executor covers the numeric subset. Anything else falls back + // to the general VM rather than failing, so adding the fast path cannot + // have narrowed what a kernel is allowed to be. + use loon_lang::eir::place::Mode; + let dir = std::env::current_dir().expect("cwd"); + let src = "[kernel k [i b] [put b i [+ [at b i] 1.0]]] \ + [fn main [] [let mut b [buf-zeros 4]] \ + [Place.run k 4 #[b]] [IO.println [Place.read b]]]"; + for mode in [Mode::Cpu, Mode::Par] { + let (r, _) = loon_lang::eir::vm::eval_eir_placed(src, &dir, mode).expect("runs"); + assert_eq!(r.output, vec!["#[1 1 1 1]"]); + } +} From 834b2f684ee2dc30133182c0a6932669f6881ecf Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 11:53:04 -0400 Subject: [PATCH 11/25] Launches already pipeline, and the browser claim was wrong MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two corrections and a finding. The finding: a GPU dispatch submits to the queue and returns. Nothing waits until the host asks for data, and `Place.read` is the only way to ask — so a handler that defers reads defers every synchronization point in the program. 64 launches take 19.9 ms against 6.9 ms for one; if each blocked on the previous, that would be nearer 440 ms. The offload paper prototypes async transfers as a separate LLVM optimization. Here it is what happens when the synchronization point is something the program says out loud. The correction that matters: the post implied you can run one of these programs in a browser today. You cannot. WGSL is WebGPU's shading language and naga validates every kernel we emit, so the shader half really is portable — but Loon's wasm build still embeds the old tree-walking interpreter rather than the EIR VM, so there is nowhere for the program to run. That gap predates this work and has nothing to do with placement. The post now says the architecture points at a target the alternatives cannot reach, and does not claim to have arrived. Also corrected: Vulkan and DX12 are the same code path through wgpu, but I have not run either, so they are "should" rather than "does". Co-Authored-By: Claude Fable 5 --- crates/loon-lang/tests/gpu_end_to_end.rs | 102 ++++++++++++++++++ .../blog/2026-08-18-placement-is-an-effect.md | 28 ++++- web/src/pages/blog.loon | 2 +- 3 files changed, 127 insertions(+), 5 deletions(-) diff --git a/crates/loon-lang/tests/gpu_end_to_end.rs b/crates/loon-lang/tests/gpu_end_to_end.rs index 1183304..3eb5bed 100644 --- a/crates/loon-lang/tests/gpu_end_to_end.rs +++ b/crates/loon-lang/tests/gpu_end_to_end.rs @@ -361,3 +361,105 @@ fn asking_for_a_gpu_that_cannot_run_the_kernel_says_so() { Ok((r, _)) => panic!("expected a refusal, got output {:?}", r.output), } } + +// ── Launches pipeline; only a read synchronizes ───────────────────────────── + +#[test] +fn launches_do_not_block_on_each_other() { + // A kernel launch submits to the queue and returns. Nothing waits for the + // GPU until the host asks for data — which, since `Place.read` is the only + // way to ask, means a handler that defers reads is also deferring every + // synchronization point in the program. + // + // The observable consequence: N launches under a residency policy cost far + // less than N times a single blocking round trip. If every launch waited, + // the two would be equal. + if Gpu::open().is_err() { + println!("SKIPPED — no GPU on this machine"); + return; + } + + let chain = |reps: usize| { + let runs = (0..reps) + .map(|_| "[Place.run step 4096 #[b]]".to_string()) + .collect::>() + .join(" "); + format!( + "[kernel step [i b] [put b i [+ 1.0 [at b i]]]] \ + [fn work [] [let mut b [buf-zeros 4096]] {runs} [Place.read b]] \ + [fn resident [thunk] \ + [handle [thunk] \ + [Place.run k n args] [do [Place.pin args] [resume [Place.run k n args]]] \ + [Place.read b] [resume [Place.read b]]]] \ + [fn main [] [let _ [resident work]] []]" + ) + }; + + let time = |src: &str| { + let dir = std::env::current_dir().expect("cwd"); + // Warm: the first run pays for adapter discovery and shader compilation. + let _ = loon_lang::eir::vm::eval_eir_placed(src, &dir, loon_lang::eir::place::Mode::Gpu); + let start = std::time::Instant::now(); + loon_lang::eir::vm::eval_eir_placed(src, &dir, loon_lang::eir::place::Mode::Gpu) + .expect("runs"); + start.elapsed() + }; + + let one = time(&chain(1)); + let many = time(&chain(64)); + + println!("1 launch: {one:?}, 64 launches: {many:?}"); + assert!( + many < one * 32, + "64 launches took {many:?} against {one:?} for one — that is the shape of \ + every launch waiting for the previous one" + ); +} + +#[test] +fn a_read_is_what_synchronizes() { + // Reading between every launch forfeits the pipelining, which is precisely + // why `Place.read` being an operation matters: it is the thing a policy + // gets to move. + if Gpu::open().is_err() { + println!("SKIPPED — no GPU on this machine"); + return; + } + let dir = std::env::current_dir().expect("cwd"); + + let deferred = "[kernel step [i b] [put b i [+ 1.0 [at b i]]]] \ + [fn work [] [let mut b [buf-zeros 1024]] \ + [Place.run step 1024 #[b]] [Place.run step 1024 #[b]] \ + [Place.run step 1024 #[b]] [Place.run step 1024 #[b]] \ + [Place.read b]] \ + [fn resident [thunk] \ + [handle [thunk] \ + [Place.run k n args] [do [Place.pin args] [resume [Place.run k n args]]] \ + [Place.read b] [resume [Place.read b]]]] \ + [fn main [] [IO.println [sum [resident work]]]]"; + + let eager = "[kernel step [i b] [put b i [+ 1.0 [at b i]]]] \ + [fn work [] [let mut b [buf-zeros 1024]] \ + [Place.run step 1024 #[b]] [let _ [Place.read b]] \ + [Place.run step 1024 #[b]] [let _ [Place.read b]] \ + [Place.run step 1024 #[b]] [let _ [Place.read b]] \ + [Place.run step 1024 #[b]] \ + [Place.read b]] \ + [fn resident [thunk] \ + [handle [thunk] \ + [Place.run k n args] [do [Place.pin args] [resume [Place.run k n args]]] \ + [Place.read b] [resume [Place.read b]]]] \ + [fn main [] [IO.println [sum [resident work]]]]"; + + let (a, stats_a) = + loon_lang::eir::vm::eval_eir_placed(deferred, &dir, loon_lang::eir::place::Mode::Gpu) + .expect("runs"); + let (b, stats_b) = + loon_lang::eir::vm::eval_eir_placed(eager, &dir, loon_lang::eir::place::Mode::Gpu) + .expect("runs"); + + // Same answer; the reads changed only when data moved, never what it was. + assert_eq!(a.output, b.output); + assert_eq!(stats_a.downloads, 1, "one read, one download"); + assert_eq!(stats_b.downloads, 4, "four reads, four downloads"); +} diff --git a/docs/blog/2026-08-18-placement-is-an-effect.md b/docs/blog/2026-08-18-placement-is-an-effect.md index 7f38564..31a1e7c 100644 --- a/docs/blog/2026-08-18-placement-is-an-effect.md +++ b/docs/blog/2026-08-18-placement-is-an-effect.md @@ -78,9 +78,9 @@ On an actual GPU — this is an M4 Max, through Metal, via wgpu — the wall clo | launches | no policy | place/resident | speedup | |---------:|----------:|---------------:|--------:| -| 8 | 28.9 ms | 9.3 ms | 3.1x | -| 32 | 93.1 ms | 15.4 ms | 6.0x | -| 128 | 356.7 ms | 18.3 ms | 19.5x | +| 8 | 29.3 ms | 8.4 ms | 3.5x | +| 32 | 94.8 ms | 11.2 ms | 8.4x | +| 128 | 358.8 ms | 18.1 ms | 19.9x | The gap grows with the chain, which is exactly the paper's curve. The difference is where the fix lives. Theirs is an LLVM pass and a type. Mine is a `handle` form you can read in one sitting, change without rebuilding a compiler, and — this is the part I keep coming back to — *replace with a different one* when your program has different needs. @@ -158,12 +158,32 @@ Every accounting number, no execution. And strace-for-GPU is the same shape as s ## Where it runs -Metal on this laptop. Vulkan on a Linux box. DX12 on Windows. And WebGPU in a browser tab, which is a target you cannot reach at all if you're emitting PTX and AMDGCN. That last one isn't cleverness; it's what you get for free by picking a portable shading language instead of a vendor's, and it's the one place where I think the architecture is straightforwardly better rather than differently-shaped. +Metal on this laptop, today. Vulkan on a Linux box and DX12 on Windows are the same code path through wgpu, and I have not run either, so take them as "should" rather than "does." + +The one I want to be careful about is the browser. WGSL is WebGPU's shading language, and every kernel we emit is validated by naga — the same front end a browser uses — so the *shader* half is genuinely portable, and PTX and AMDGCN cannot go there at all. But Loon's browser build still runs the old tree-walking interpreter, not the EIR VM, so you cannot actually run one of these programs in a tab yet. That's a pre-existing gap that has nothing to do with placement and everything to do with which interpreter the wasm build embeds. I'm noting the architecture points at a target the alternatives can't reach; I'm not claiming to have arrived. Every kernel in the repo is parsed and type-checked by naga in CI, on machines with no GPU. That's the automated cross-target validation the paper says is still missing — they found a host/device divergence in slice lowering by hand, `(ptr, len)` on two targets and `[i64; 2]` on a third. We have the same class of hazard: NaN-boxing constants that used to be copy-pasted into three backends under a comment asking the next person to keep them in sync. They now live in one file, and a conformance test compiles the same literals on every backend and compares raw bits. That test found three real divergences the first time it ran, including one where `loon run --native` silently returned `()` for any program with a `main` function. Which is a good argument for writing the test. +## The row I didn't expect + +Once kernels stopped going through the interpreter — there's a typed executor now that runs the numeric subset against raw slices — I added `--place par`, which splits the index range across cores. Each thread gets a disjoint piece of the output from `split_at_mut`, so "threads touch disjoint elements" isn't promised by an `unsafe impl`; it's what the borrow checker hands back. + +Then I ran the same kernel four ways: + +| elements | cpu | par | gpu | +|---------:|----:|----:|----:| +| 1,024 | 447 µs | 566 µs | 10.3 ms | +| 262,144 | 8.9 ms | 3.3 ms | 12.4 ms | +| 1,048,576 | 36.4 ms | 11.4 ms | 19.2 ms | + +Every core beats the GPU at a million elements. This machine has a lot of fast ones, and a launch pays submission and transfer before it computes anything. + +I like this result more than I'd like a win. Where the crossover sits is a property of the machine, not of the program — and I found it by changing one word on a command line, because the program genuinely does not know where it runs. If placement were a compile-time decision I'd have had to rebuild something to ask the question, and I probably wouldn't have bothered. + +One more thing falls out of making `Place.read` the only way to get data back: launches don't block on each other. A dispatch submits and returns; nothing waits until the host asks. Sixty-four launches take 19.9 ms against 6.9 ms for one — if each waited, that would be closer to 440. The paper prototypes asynchronous transfers as a separate optimization. Here it's just what happens when the synchronization point is a thing the program says out loud. + ## What I'm not claiming We do not beat hand-written CUDA. We haven't measured against it and we're not going to imply otherwise. The CPU column in our benchmarks is Loon's own interpreter — the slowest honest baseline — so "3.1x faster on the GPU at 262k elements" means *there is a lot to gain by leaving the interpreter*, not anything about generated code quality. diff --git a/web/src/pages/blog.loon b/web/src/pages/blog.loon index 07ee94a..eae2ace 100644 --- a/web/src/pages/blog.loon +++ b/web/src/pages/blog.loon @@ -134,7 +134,7 @@ [ul-el {:style {:margin-left "1.5rem" :line-height "1.8"}} [li-el - "Kernels compile to WGSL and every one in the repo is validated by naga in CI, on machines with no GPU."] + "Kernels compile to WGSL and every one in the repo is validated by naga in CI, on machines with no GPU. WGSL is WebGPU's language, so the shader half is portable to a browser — though the browser build still embeds the old interpreter, so running one there is not possible yet."] [li-el "One shared value layout across the VM, WASM, and native backends, with a conformance test that compares raw bits — it found three real divergences the first time it ran."] [li-el From 28f4f2cfb737bf810b7219534009e19f1b3ca480 Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 11:54:27 -0400 Subject: [PATCH 12/25] Write down the boundary of what placement does MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit docs/plans/2026-08-18-placement-remaining.md, so the next person does not have to infer it from the code: what shipped, and the four things that did not — the browser (blocked on the wasm build embedding the old interpreter, not on anything about placement), reductions, 64-bit on a GPU, and compile-time rejection of scatter kernels. Also records that the placement stack itself compiles for wasm32-unknown-unknown today, which is the checkable half of the portability claim. Co-Authored-By: Claude Fable 5 --- .../blog/2026-08-18-placement-is-an-effect.md | 8 ++- docs/plans/2026-08-18-placement-remaining.md | 67 +++++++++++++++++++ 2 files changed, 74 insertions(+), 1 deletion(-) create mode 100644 docs/plans/2026-08-18-placement-remaining.md diff --git a/docs/blog/2026-08-18-placement-is-an-effect.md b/docs/blog/2026-08-18-placement-is-an-effect.md index 31a1e7c..fac2fc2 100644 --- a/docs/blog/2026-08-18-placement-is-an-effect.md +++ b/docs/blog/2026-08-18-placement-is-an-effect.md @@ -160,7 +160,13 @@ Every accounting number, no execution. And strace-for-GPU is the same shape as s Metal on this laptop, today. Vulkan on a Linux box and DX12 on Windows are the same code path through wgpu, and I have not run either, so take them as "should" rather than "does." -The one I want to be careful about is the browser. WGSL is WebGPU's shading language, and every kernel we emit is validated by naga — the same front end a browser uses — so the *shader* half is genuinely portable, and PTX and AMDGCN cannot go there at all. But Loon's browser build still runs the old tree-walking interpreter, not the EIR VM, so you cannot actually run one of these programs in a tab yet. That's a pre-existing gap that has nothing to do with placement and everything to do with which interpreter the wasm build embeds. I'm noting the architecture points at a target the alternatives can't reach; I'm not claiming to have arrived. +The one I want to be careful about is the browser. WGSL is WebGPU's shading language, and every kernel we emit is validated by naga — the same front end a browser uses — so the *shader* half is genuinely portable, and PTX and AMDGCN cannot go there at all. The whole placement stack also compiles for `wasm32-unknown-unknown`: + +``` +cargo check -p loon-lang --target wasm32-unknown-unknown +``` + +But you still cannot run one of these programs in a tab, because Loon's browser build embeds the old tree-walking interpreter rather than the EIR VM. That gap predates this work and has nothing to do with placement — it is a TODO in `crates/loon-wasm` about the DOM bridge. So: the code is ready to go there, the shaders are known-good there, and nobody has moved the runtime yet. I'm noting the architecture points at a target the alternatives can't reach; I'm not claiming to have arrived. Every kernel in the repo is parsed and type-checked by naga in CI, on machines with no GPU. That's the automated cross-target validation the paper says is still missing — they found a host/device divergence in slice lowering by hand, `(ptr, len)` on two targets and `[i64; 2]` on a third. We have the same class of hazard: NaN-boxing constants that used to be copy-pasted into three backends under a comment asking the next person to keep them in sync. They now live in one file, and a conformance test compiles the same literals on every backend and compares raw bits. diff --git a/docs/plans/2026-08-18-placement-remaining.md b/docs/plans/2026-08-18-placement-remaining.md new file mode 100644 index 0000000..5405604 --- /dev/null +++ b/docs/plans/2026-08-18-placement-remaining.md @@ -0,0 +1,67 @@ +# Placement: what is done and what is not + +*August 2026 — companion to `docs/blog/2026-08-18-placement-is-an-effect.md`* + +Written down so the next person does not have to infer the boundary from the +code. + +## Shipped + +- **Buffers** (`eir::vm::Buffer`) — dense, unboxed numeric arrays, the + representation that can leave the process. +- **The `kernel` form** — desugars to `fn` before anything else looks at it; + `check::kernel` enforces the subset and names what it rejects. +- **The `Place` effect** — `run`, `read`, `pin`, `unpin`, `stats`. Unhandled, + a program runs serially right here. +- **Placement modes** — `--place cpu | par | device | gpu`, all agreeing on + the answer. +- **A typed kernel executor** (`eir::kernel_exec`) — the numeric subset over + raw slices, plus a parallel driver splitting the index range with + `split_at_mut`. +- **WGSL emission** (`eir::wgsl`) — validated by naga in CI on machines with + no GPU. +- **Real GPU execution** (`eir::gpu`, feature `gpu`) — wgpu, with resident + device buffers so the transfer accounting describes the hardware. +- **Record and replay** — a run on the GPU replays on a build with no GPU. +- **Handlers** (`os/place.oo`) — trace, dry-run, counted, resident, + resident-only. + +## Not done + +### The browser + +`crates/loon-wasm` embeds the tree-walking interpreter, not the EIR VM, so +none of the above reaches a tab. The blocker is the DOM bridge (`lib.rs:46`), +which predates placement entirely. The placement code itself compiles for +`wasm32-unknown-unknown` today: + + cargo check -p loon-lang --target wasm32-unknown-unknown + +Moving the wasm build onto the EIR VM is its own project. Once done, wgpu's +WebGPU backend and async device initialization are the remaining pieces. + +### Reductions and atomics + +Kernels are map-shaped: a work item writes at its own index. A reduction needs +workgroup-shared memory and a two-phase dispatch, and the disjointness +argument that makes parallel placement sound stops holding. Host-side +reduction after `Place.read` works today and is what the samples do. + +### 64-bit on a GPU + +WGSL core has no `f64` or 64-bit integer. Buffers of those types are narrowed +to 32-bit on the device, reported rather than hidden (`DType::gpu_ok`). + +### Scatter kernels + +`check::kernel` does not yet enforce that a `put` index is the work index. The +parallel executor catches a violation at runtime — a write outside the slice a +thread owns is an error naming the problem — but catching it at compile time +would be better. + +### Numbers we do not have + +No comparison against hand-written CUDA, HIP, or Metal. No RAJAPerf port. The +benchmark's CPU column is Loon's own typed executor, which is a fair floor but +not an optimized C baseline, and nothing in `BENCHMARKS.md` should be read as +one. From 4ab8e684ba94a1900027bbca1fe17c27e148bd1b Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 13:26:09 -0400 Subject: [PATCH 13/25] Two claims the code was not keeping MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `DType::gpu_ok` existed, was tested, and was never called. So `--place gpu` silently narrowed an f64 buffer to f32 while the docs said the narrowing was "reported rather than hidden". It is now refused: error: argument 1 is a f64 buffer, and a GPU has no 64-bit number; run this with --place cpu or --place par, or build the buffer with `buf` instead of `buf-f64` Handing back numbers of a precision the program never asked for, and has no way to notice, is the confident-wrong-answer failure this design exists to prevent. The same program runs on the CPU, which does have 64-bit numbers. And the disjointness rule is now enforced where it belongs. A kernel may write at its own index and nowhere else — that is what lets the parallel executor hand each thread a slice and what lets a GPU run every work item at once. The parallel executor caught violations at runtime; the checker now rejects them at compile time (E0602), naming the offending index: error: [E0602] kernel 'reverse' writes at an index other than its own why: every work item runs at once, so each may only write element 'i'; writing elsewhere means two of them can reach the same element and the result would depend on which got there first fix: write at 'i', and read whatever else this element needs with `at` Reading anywhere is still fine — gather is safe, scatter is not. The index parameter can be called whatever the kernel calls it. Co-Authored-By: Claude Fable 5 --- crates/loon-lang/src/check/kernel.rs | 81 ++++++++++++++++++++++++ crates/loon-lang/src/eir/vm.rs | 15 +++++ crates/loon-lang/src/errors/codes.rs | 5 +- crates/loon-lang/src/errors/tutorials.rs | 2 +- crates/loon-lang/tests/gpu_end_to_end.rs | 37 +++++++++++ 5 files changed, 138 insertions(+), 2 deletions(-) diff --git a/crates/loon-lang/src/check/kernel.rs b/crates/loon-lang/src/check/kernel.rs index bbc5743..a6bf019 100644 --- a/crates/loon-lang/src/check/kernel.rs +++ b/crates/loon-lang/src/check/kernel.rs @@ -100,6 +100,7 @@ pub fn verify(exprs: &[Expr], names: &HashSet) -> Vec { let mut v = Verifier { kernels: names, errors: Vec::new(), + index_param: None, }; for expr in exprs { v.walk_program(expr); @@ -110,6 +111,9 @@ pub fn verify(exprs: &[Expr], names: &HashSet) -> Vec { struct Verifier<'a> { kernels: &'a HashSet, errors: Vec, + /// The name of the kernel currently being checked's work index — its first + /// parameter. A `put` at any other index is a scatter. + index_param: Option, } impl Verifier<'_> { @@ -122,6 +126,7 @@ impl Verifier<'_> { if is_fn && items.len() >= 3 { if let ExprKind::Symbol(name) = &items[1].kind { if self.kernels.contains(name) { + self.index_param = first_param(&items[2]); self.check_params(name, &items[2]); for body in &items[3..] { self.check_body(name, body); @@ -235,6 +240,41 @@ impl Verifier<'_> { return; } + // A work item may write at its own index and nowhere else. + // + // This is the disjointness rule the whole design rests on: it is what + // lets the parallel executor hand each thread a slice and what lets a + // GPU dispatch run every work item at once. The Rust offload work + // arrives at the same guarantee by having partitioning strategies + // promise it in an `unsafe impl`; here the program that would violate + // it does not compile. + if name == "put" && items.len() >= 3 { + let idx = &items[2]; + let ok = match (&idx.kind, &self.index_param) { + (ExprKind::Symbol(s), Some(p)) => s == p, + _ => false, + }; + if !ok { + let index_name = self.index_param.clone().unwrap_or_else(|| "i".to_string()); + self.errors.push( + LoonDiagnostic::new( + ErrorCode::E0602, + format!("kernel '{kernel}' writes at an index other than its own"), + ) + .with_why(format!( + "every work item runs at once, so each may only write element \ + '{index_name}'; writing elsewhere means two of them can reach the \ + same element and the result would depend on which got there first" + )) + .with_fix(format!( + "write at '{index_name}', and read whatever else this element needs \ + with `at`" + )) + .with_label(idx.span, "not this work item's element", true), + ); + } + } + if name == "fn" || name == "kernel" { self.reject( kernel, @@ -281,6 +321,17 @@ impl Verifier<'_> { } } +/// The name of a parameter list's first entry. +fn first_param(params: &Expr) -> Option { + let ExprKind::List(ps) = ¶ms.kind else { + return None; + }; + match ps.first().map(|p| &p.kind) { + Some(ExprKind::Symbol(name)) => Some(name.clone()), + _ => None, + } +} + /// Operators lower to arithmetic instructions rather than builtin calls. fn is_operator(name: &str) -> bool { matches!( @@ -382,6 +433,36 @@ mod tests { ); } + #[test] + fn writing_at_another_work_items_index_is_rejected() { + // The disjointness rule, enforced. Two work items reaching the same + // element would make the result depend on which arrived first. + for src in [ + "[kernel k [i s d] [put d [- 99 i] [at s i]]]", + "[kernel k [i d] [put d 0 1.0]]", + "[kernel k [i d] [put d [+ i 1] 1.0]]", + ] { + let errors = check(src); + assert!(!errors.is_empty(), "should reject a scatter: {src}"); + assert_eq!(errors[0].code, ErrorCode::E0602, "{src}"); + } + } + + #[test] + fn writing_at_your_own_index_is_the_whole_point() { + let errors = check("[kernel k [i s d] [put d i [+ [at s i] [at s 0]]]]"); + assert!( + errors.is_empty(), + "reading anywhere is fine; only writing is restricted: {errors:?}" + ); + } + + #[test] + fn the_index_parameter_can_be_called_anything() { + let errors = check("[kernel k [row d] [put d row 1.0]]"); + assert!(errors.is_empty(), "unexpected errors: {errors:?}"); + } + #[test] fn a_nullary_kernel_is_rejected() { let errors = check("[kernel k [] 1]"); diff --git a/crates/loon-lang/src/eir/vm.rs b/crates/loon-lang/src/eir/vm.rs index 2dbfda3..779decc 100644 --- a/crates/loon-lang/src/eir/vm.rs +++ b/crates/loon-lang/src/eir/vm.rs @@ -951,6 +951,21 @@ impl Vm { } match self.get_obj(*val) { Some(Obj::Buffer(b)) => { + // WGSL core has no 64-bit scalar. Quietly computing an f64 + // buffer in f32 would hand back numbers of a precision the + // program never asked for and has no way to notice, so the + // launch is refused and the alternative named instead. + if !b.dtype().gpu_ok() { + return Err(self.place_error(format!( + "argument {} is a {} buffer, and a GPU has no {}-bit \ + number; run this with --place cpu or --place par, or \ + build the buffer with `buf` instead of `buf-{}`", + i + 1, + b.dtype().name(), + b.dtype().size() * 8, + b.dtype().name() + ))); + } let id = val.as_ptr(); buffer_ids.push(id); to_upload.push((id, gpu::narrow(b), b.byte_len() as u64, b.dtype())); diff --git a/crates/loon-lang/src/errors/codes.rs b/crates/loon-lang/src/errors/codes.rs index 55243d5..5d62b01 100644 --- a/crates/loon-lang/src/errors/codes.rs +++ b/crates/loon-lang/src/errors/codes.rs @@ -45,6 +45,7 @@ pub enum ErrorCode { // Placement errors E0600, // construct not allowed inside a kernel E0601, // kernel signature is not placeable + E0602, // kernel writes outside its own work item // Warnings W0100, // transparent wildcard @@ -77,6 +78,7 @@ impl ErrorCode { ErrorCode::E0404 => "E0404", ErrorCode::E0600 => "E0600", ErrorCode::E0601 => "E0601", + ErrorCode::E0602 => "E0602", ErrorCode::E0500 => "E0500", ErrorCode::E0501 => "E0501", ErrorCode::E0502 => "E0502", @@ -108,7 +110,7 @@ impl ErrorCode { | ErrorCode::E0403 | ErrorCode::E0404 => "effect", ErrorCode::E0500 | ErrorCode::E0501 | ErrorCode::E0502 => "module", - ErrorCode::E0600 | ErrorCode::E0601 => "placement", + ErrorCode::E0600 | ErrorCode::E0601 | ErrorCode::E0602 => "placement", ErrorCode::W0100 => "warning", } } @@ -139,6 +141,7 @@ impl ErrorCode { ErrorCode::E0404 => "effect not granted", ErrorCode::E0600 => "not allowed inside a kernel", ErrorCode::E0601 => "kernel signature is not placeable", + ErrorCode::E0602 => "kernel writes outside its own work item", ErrorCode::E0500 => "unresolved module", ErrorCode::E0501 => "private symbol", ErrorCode::E0502 => "circular dependency", diff --git a/crates/loon-lang/src/errors/tutorials.rs b/crates/loon-lang/src/errors/tutorials.rs index 8b9c5ed..337775b 100644 --- a/crates/loon-lang/src/errors/tutorials.rs +++ b/crates/loon-lang/src/errors/tutorials.rs @@ -51,7 +51,7 @@ pub fn get_tutorial(code: ErrorCode) -> Option { ErrorCode::E0500 => Some(tutorial_unresolved_module()), ErrorCode::E0501 => Some(tutorial_private_symbol()), ErrorCode::E0502 => Some(tutorial_circular_dependency()), - ErrorCode::E0600 | ErrorCode::E0601 => None, + ErrorCode::E0600 | ErrorCode::E0601 | ErrorCode::E0602 => None, ErrorCode::W0100 => None, // warnings don't need tutorials } } diff --git a/crates/loon-lang/tests/gpu_end_to_end.rs b/crates/loon-lang/tests/gpu_end_to_end.rs index 3eb5bed..d17bdab 100644 --- a/crates/loon-lang/tests/gpu_end_to_end.rs +++ b/crates/loon-lang/tests/gpu_end_to_end.rs @@ -463,3 +463,40 @@ fn a_read_is_what_synchronizes() { assert_eq!(stats_a.downloads, 1, "one read, one download"); assert_eq!(stats_b.downloads, 4, "four reads, four downloads"); } + +#[test] +fn a_sixty_four_bit_buffer_is_refused_rather_than_narrowed() { + // WGSL core has no 64-bit scalar. Quietly computing an f64 buffer in f32 + // would hand back numbers of a precision the program never asked for and + // has no way to notice, so the launch is refused and the alternative + // named. The same program runs fine on the CPU. + if Gpu::open().is_err() { + println!("SKIPPED — no GPU on this machine"); + return; + } + let dir = std::env::current_dir().expect("cwd"); + let src = "[kernel k [i b] [put b i [* 2.0 [at b i]]]] \ + [fn main [] [let mut b [buf-f64 #[1 2 3]]] \ + [Place.run k 3 #[b]] [IO.println [Place.read b]]]"; + + let on_gpu = loon_lang::eir::vm::eval_eir_placed(src, &dir, loon_lang::eir::place::Mode::Gpu); + match on_gpu { + Err(e) => { + let msg = format!("{e:?}"); + assert!( + msg.contains("f64"), + "the message should name the type: {msg}" + ); + assert!( + msg.contains("--place cpu"), + "and say what to do instead: {msg}" + ); + } + Ok((r, _)) => panic!("expected a refusal, got {:?}", r.output), + } + + let (on_cpu, _) = + loon_lang::eir::vm::eval_eir_placed(src, &dir, loon_lang::eir::place::Mode::Cpu) + .expect("the CPU has 64-bit numbers"); + assert_eq!(on_cpu.output, vec!["#[2 4 6]"]); +} From 79b54d487914cb7bcb032bdd596e528ac9a9de40 Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 13:39:43 -0400 Subject: [PATCH 14/25] Reductions, without a special case MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A kernel may write at its own index and nowhere else, which sounds like it rules out summing an array. It doesn't: a reduction is a map followed by a much smaller reduction. Give each work item its own chunk of the input and its own slot in a partials buffer and every item is still writing exactly one element — its own. Combine the sixty-four partials on the host, where sending them to a device would cost more than adding them. So there is no `Place.reduce`, no workgroup-shared memory, and no exception carved out of the disjointness rule. samples/place/reduce.oo sums 0..4096 to 8386560 on cpu, par, device, and gpu alike. Getting there needed `loop` added to the kernel forms — `recur` was already allowed, which is meaningless without the form that introduces it — and turned up four bugs. Two in `sum`, both pre-existing. The registry has always declared it `Vec Num → Num` and the interpreter has always implemented that, but the checker said `Vec Int → Int` with the comment "(approximate)", so summing floats did not type check; and the EIR VM filtered the vector to integers and returned an i64, so a vector of floats summed to 0. That is the worst shape of wrong answer, because it looks like an empty sum rather than a failure. Three in the WGSL emitter, each of which produced a shader that failed validation — the good outcome, but only because the emitter is checked: - The type-inference fixpoint stopped when no *new* register had a type, so a loop-carried value kept whichever type its first predecessor gave it. Types now widen monotonically and iterate until nothing changes. - Branch targets were resolved across every function in the module. `BlockId` is per-function, so a jump found whichever other function happened to have a block with the same number and copied arguments into its parameters. - A unit value reaching a float slot had no conversion, so the emitter wrote a bare i32 register where WGSL wanted an f32. The reduction kernel is now in the naga validation corpus, so all three stay fixed. Co-Authored-By: Claude Fable 5 --- crates/loon-lang/src/check/kernel.rs | 21 +++++- crates/loon-lang/src/check/mod.rs | 40 ++++++++--- crates/loon-lang/src/eir/vm.rs | 47 ++++++++++--- crates/loon-lang/src/eir/wgsl.rs | 93 ++++++++++++++++++++------ crates/loon-lang/tests/place_effect.rs | 72 ++++++++++++++++++++ samples/place/reduce.oo | 45 +++++++++++++ 6 files changed, 278 insertions(+), 40 deletions(-) create mode 100644 samples/place/reduce.oo diff --git a/crates/loon-lang/src/check/kernel.rs b/crates/loon-lang/src/check/kernel.rs index a6bf019..85d32ec 100644 --- a/crates/loon-lang/src/check/kernel.rs +++ b/crates/loon-lang/src/check/kernel.rs @@ -52,7 +52,11 @@ const KERNEL_BUILTINS: &[&str] = &[ // the language pretend to. /// Special forms a kernel body may use. -const KERNEL_FORMS: &[&str] = &["let", "if", "do", "and", "or", "recur", "mut"]; +/// +/// `loop`/`recur` earn their place because a reduction needs them: a work item +/// that sums its own chunk of the input is still writing only its own element, +/// so the disjointness rule holds and no new language feature is required. +const KERNEL_FORMS: &[&str] = &["let", "if", "do", "and", "or", "loop", "recur", "mut"]; /// Rewrite every `[kernel name [params] body...]` into the equivalent `fn`, /// returning the rewritten program and the set of kernel names. @@ -240,6 +244,21 @@ impl Verifier<'_> { return; } + // `[loop [name init ...] body...]` — the binding list is names paired + // with initializers, not a call, so only the initializers and the body + // are expressions to check. + if name == "loop" && items.len() >= 2 { + if let ExprKind::List(bindings) = &items[1].kind { + for init in bindings.iter().skip(1).step_by(2) { + self.check_body(kernel, init); + } + } + for body in &items[2..] { + self.check_body(kernel, body); + } + return; + } + // A work item may write at its own index and nowhere else. // // This is the disjointness rule the whole design rests on: it is what diff --git a/crates/loon-lang/src/check/mod.rs b/crates/loon-lang/src/check/mod.rs index 08cf31b..cf3e2ba 100644 --- a/crates/loon-lang/src/check/mod.rs +++ b/crates/loon-lang/src/check/mod.rs @@ -1751,15 +1751,37 @@ impl Checker { } } - // sum: Vec Int → Int (approximate) - self.env.set_global( - "sum".to_string(), - Scheme::mono(Type::Fn( - vec![Type::Con("Vec".to_string(), vec![Type::Int])], - Box::new(Type::Int), - EffectRow::pure(), - )), - ); + // sum: ∀a:Num. Vec a → a + // + // The builtin registry has always declared this `Vec Num → Num` and the + // interpreter has always implemented it that way. The checker said + // `Vec Int → Int` with the comment "(approximate)", which meant summing + // a vector of floats — the natural last step of any reduction — did not + // type check. + { + let a = self.subst.fresh(); + let tv = match a { + Type::Var(v) => v, + _ => unreachable!("fresh() returns a Var"), + }; + self.env.set_global( + "sum".to_string(), + Scheme { + bounds: vec![( + tv, + vec![TraitBound { + trait_name: "Num".to_string(), + }], + )], + vars: vec![tv], + ty: Type::Fn( + vec![Type::Con("Vec".to_string(), vec![Type::Var(tv)])], + Box::new(Type::Var(tv)), + EffectRow::pure(), + ), + }, + ); + } // str: ∀a. a → Str { diff --git a/crates/loon-lang/src/eir/vm.rs b/crates/loon-lang/src/eir/vm.rs index 779decc..7302973 100644 --- a/crates/loon-lang/src/eir/vm.rs +++ b/crates/loon-lang/src/eir/vm.rs @@ -2507,17 +2507,46 @@ impl Vm { } } Built::Sum => { + // Ints stay ints; any float promotes the whole sum, matching + // the interpreter and the `Vec Num → Num` the registry + // declares. This used to filter to integers and silently drop + // everything else, so summing a vector of floats answered 0 — + // which is the shape of wrong answer that is worst, because it + // looks like an empty sum rather than a failure. let coll = args.first().copied().unwrap_or(Val::UNIT); - match self.get_obj(coll) { - Some(Obj::Vec(items)) => { - let sum: i64 = items - .iter() - .filter(|v| v.is_int()) - .map(|v| v.as_int()) - .sum(); - Ok(Val::int(sum)) + let Some(Obj::Vec(items)) = self.get_obj(coll) else { + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "sum requires a vector, got {}", + self.val_to_string(coll) + ))) + .with_span(self.current_span)); + }; + let items: Vec = items.iter().copied().collect(); + let any_float = items.iter().any(|v| v.is_float()); + for v in &items { + if !v.is_int() && !v.is_float() { + let shown = self.val_to_string(*v); + return Err(VmError::new(VmErrorKind::BuiltinType(format!( + "sum requires a vector of numbers; found {shown}" + ))) + .with_span(self.current_span)); } - _ => Ok(Val::int(0)), + } + if any_float { + let total: f64 = items + .iter() + .map(|v| { + if v.is_float() { + v.as_float() + } else { + v.as_int() as f64 + } + }) + .sum(); + Ok(Val::float(total)) + } else { + let total: i64 = items.iter().map(|v| v.as_int()).sum(); + Ok(Val::int(total)) } } Built::Min | Built::Max => { diff --git a/crates/loon-lang/src/eir/wgsl.rs b/crates/loon-lang/src/eir/wgsl.rs index 25db583..56081e2 100644 --- a/crates/loon-lang/src/eir/wgsl.rs +++ b/crates/loon-lang/src/eir/wgsl.rs @@ -222,14 +222,14 @@ pub fn emit(module: &Module, func: FuncId, args: &[ArgKind]) -> Result { /// Repeats until stable so a register defined in a later block — a loop /// back-edge carrying a value — still gets a type before it is used. fn infer(&mut self, blocks: &[Block]) -> Result<(), Error> { - for _ in 0..blocks.len().max(1) + 1 { - let before = self.types.len(); + // Iterate until nothing changes, not merely until nothing new appears. + // + // A loop-carried value is the case that makes the difference. Its type + // is set by whichever predecessor is visited first, and a later one may + // demand a wider type; stopping as soon as every register *had* a type + // left the earlier, narrower answer in place. The result was a shader + // that assigned an i32 register to an f32 one and failed validation — + // which is at least a loud failure, but only because something checks. + let limit = blocks.len().max(1) * 4 + 4; + for _ in 0..limit { + let snapshot = self.types.clone(); for block in blocks { for op in &block.ops { self.infer_op(op)?; } - // Block parameters take the type of whatever is passed in. - if let End::Jmp(_, args) | End::Recur(args) = &block.end { - for (i, a) in args.iter().enumerate() { - if let (Some(t), Some(p)) = (self.ty_opt(*a), block.params.get(i)) { - self.types.insert(p.0, t); + // Block parameters take the widest type any predecessor passes. + if let End::Jmp(_, args) = &block.end { + // A jump's arguments land in the *target* block's params. + if let Some(target) = self.block_by_id(blocks, block) { + for (i, a) in args.iter().enumerate() { + if let (Some(t), Some(p)) = (self.ty_opt(*a), target.params.get(i)) { + self.widen(p.0, t); + } + } + } + } + if let End::Recur(args) = &block.end { + // `recur` re-enters the function's entry block. + if let (Some(entry), true) = (blocks.first(), true) { + for (i, a) in args.iter().enumerate() { + if let (Some(t), Some(p)) = (self.ty_opt(*a), entry.params.get(i)) { + self.widen(p.0, t); + } } } } } - if self.types.len() == before { + if self.types == snapshot { break; } } Ok(()) } + /// The block a terminator jumps to. + fn block_by_id<'b>(&self, blocks: &'b [Block], from: &Block) -> Option<&'b Block> { + let End::Jmp(target, _) = &from.end else { + return None; + }; + blocks.iter().find(|b| b.id == *target) + } + + /// Record a register's type, widening rather than replacing. + /// + /// WGSL will not mix i32 and f32, so when predecessors disagree the wider + /// type has to win everywhere — otherwise the declaration and the + /// assignments describe different types. + fn widen(&mut self, reg: u32, t: Ty) { + let merged = match self.types.get(®).copied() { + Some(existing) if existing != t => Ty::join(existing, t), + Some(existing) => existing, + None => t, + }; + self.types.insert(reg, merged); + } + fn infer_op(&mut self, op: &Op) -> Result<(), Error> { match op { Op::Lit(d, lit, _) => { @@ -381,7 +425,7 @@ impl Emitter<'_> { } Op::Mov(d, s, _) => { if let Some(t) = self.ty_opt(*s) { - self.types.insert(d.0, t); + self.widen(d.0, t); } } Op::Bin(d, bop, a, b, _) => { @@ -513,6 +557,7 @@ impl Emitter<'_> { fn emit_block( &self, out: &mut String, + blocks: &[Block], block: &Block, pad: &str, dispatched: bool, @@ -530,7 +575,7 @@ impl Emitter<'_> { writeln!(out, "{pad}return;").unwrap(); } End::Jmp(target, args) => { - self.emit_branch_args(out, block, *target, args, pad); + self.emit_branch_args(out, blocks, *target, args, pad); if dispatched { writeln!(out, "{pad}blk = {}; continue;", target.0).unwrap(); } else { @@ -567,7 +612,7 @@ impl Emitter<'_> { if !dispatched { return err("a loop needs the block dispatcher"); } - self.emit_branch_args(out, block, block.id, args, pad); + self.emit_branch_args(out, blocks, block.id, args, pad); writeln!(out, "{pad}blk = {}; continue;", block.id.0).unwrap(); } End::Tail(..) | End::TailInvoke(..) => { @@ -581,18 +626,17 @@ impl Emitter<'_> { fn emit_branch_args( &self, out: &mut String, - _from: &Block, + blocks: &[Block], target: super::BlockId, args: &[Reg], pad: &str, ) { - let Some(block) = self - .module - .funcs - .iter() - .flat_map(|f| f.blocks.iter()) - .find(|b| b.id == target) - else { + // Within this function's blocks only. `BlockId` is per-function, so + // searching the whole module found whichever function happened to have + // a block with the same number — and copied jump arguments into its + // parameters, with its types. The shader that came out assigned an i32 + // register to an f32 one. + let Some(block) = blocks.iter().find(|b| b.id == target) else { return; }; for (p, a) in block.params.iter().zip(args.iter()) { @@ -616,6 +660,13 @@ impl Emitter<'_> { (Ty::Bool, Ty::F32) => format!("select(0.0, 1.0, {text})"), (Ty::I32, Ty::Bool) => format!("({text} != 0)"), (Ty::F32, Ty::Bool) => format!("({text} != 0.0)"), + // A unit value reaching a numeric slot is zero, which is how the + // CPU executor already reads it. It happens on a control-flow path + // that produces no value — the fallthrough of a loop, say — and + // leaving it unconverted emitted a bare i32 register where WGSL + // wanted an f32, which is a shader that does not compile. + (Ty::Unit, Ty::F32) => format!("f32({text})"), + (Ty::Unit, Ty::Bool) => format!("({text} != 0)"), _ => text, } } diff --git a/crates/loon-lang/tests/place_effect.rs b/crates/loon-lang/tests/place_effect.rs index 71274c1..aefe2c6 100644 --- a/crates/loon-lang/tests/place_effect.rs +++ b/crates/loon-lang/tests/place_effect.rs @@ -371,3 +371,75 @@ fn a_kernel_outside_the_fast_subset_still_runs() { assert_eq!(r.output, vec!["#[1 1 1 1]"]); } } + +// ── Reductions, within the rules ──────────────────────────────────────────── + +/// A reduction expressed as chunked partials plus a host-side combine. +const REDUCE: &str = "[kernel sum-chunk [c width src partials] \ + [let start [* c width]] \ + [let total [loop [k 0 acc 0.0] \ + [if [>= k width] acc [recur [+ k 1] [+ acc [at src [+ start k]]]]]]] \ + [put partials c total]] \ + [fn main [] \ + [let src [buf [range 0 256]]] \ + [let mut partials [buf-zeros 16]] \ + [Place.run sum-chunk 16 #[16 src partials]] \ + [IO.println [sum [Place.read partials]]]]"; + +#[test] +fn a_reduction_needs_no_new_language_feature() { + // Each work item sums its own chunk and writes its own partial, so the + // disjointness rule holds throughout. There is no `Place.reduce`, no + // workgroup-shared memory, and no exception carved out. + let out = run(REDUCE); + // 0 + 1 + ... + 255 + assert_eq!(out, vec!["32640"]); +} + +#[test] +fn a_reduction_agrees_across_every_placement() { + use loon_lang::eir::place::Mode; + let dir = std::env::current_dir().expect("cwd"); + for mode in [Mode::Cpu, Mode::Par, Mode::Device] { + let (r, _) = loon_lang::eir::vm::eval_eir_placed(REDUCE, &dir, mode) + .unwrap_or_else(|e| panic!("{mode:?} failed: {e:?}")); + assert_eq!(r.output, vec!["32640"], "{mode:?} disagreed"); + } +} + +#[test] +fn a_loop_carried_float_survives_the_shader() { + // The reduction's accumulator starts at 0.0 and is carried around a loop. + // Emitting that to WGSL exercised three separate bugs: a type-inference + // fixpoint that stopped before a loop-carried type settled, a branch target + // resolved across the whole module rather than one function, and a unit + // value reaching a float slot with no conversion. Each produced a shader + // that failed validation, which is the good outcome — but only because the + // emitter is checked. + use loon_lang::check::Checker; + use loon_lang::eir::layout::DType; + use loon_lang::eir::lower::lower; + use loon_lang::eir::wgsl; + + let exprs = loon_lang::parser::parse(REDUCE).expect("parses"); + let mut checker = Checker::new(); + assert!(checker.check_program(&exprs).is_empty()); + let module = lower(&checker); + let f = module + .funcs + .iter() + .find(|f| f.name.as_deref() == Some("sum-chunk")) + .expect("kernel lowered"); + let kinds = wgsl::infer_arg_kinds(&module, f.id, DType::F32); + let shader = wgsl::emit(&module, f.id, &kinds).expect("emits"); + + let parsed = naga::front::wgsl::parse_str(&shader) + .unwrap_or_else(|e| panic!("WGSL did not parse: {e}\n\n{shader}")); + let mut validator = naga::valid::Validator::new( + naga::valid::ValidationFlags::all(), + naga::valid::Capabilities::empty(), + ); + validator + .validate(&parsed) + .unwrap_or_else(|e| panic!("WGSL did not validate: {e:?}\n\n{shader}")); +} diff --git a/samples/place/reduce.oo b/samples/place/reduce.oo new file mode 100644 index 0000000..bad609d --- /dev/null +++ b/samples/place/reduce.oo @@ -0,0 +1,45 @@ +; Reduction, without leaving the rules. +; +; A kernel may write at its own index and nowhere else. That sounds like it +; rules out summing an array — a sum has one destination and every element +; wants to reach it. +; +; It doesn't, because a reduction is a map followed by a much smaller +; reduction. Give each work item its own chunk of the input and its own slot in +; a partials buffer, and every item is still writing exactly one element: its +; own. Combine the handful of partials afterwards. +; +; So there is no `Place.reduce` operation and no workgroup-shared memory here. +; The two-phase shape is what the disjointness rule already permits, which is a +; better outcome than a special case would have been. +; +; loon run samples/place/reduce.oo --place cpu | par | device | gpu +; Phase one: work item `c` sums the `width` elements starting at `c * width`. +; It reads all over the input — gather is safe — and writes only `partials[c]`. +[kernel + sum-chunk + [c width src partials] + [let start [* c width]] + [let total + [loop + [k 0 acc 0.0] + [if [>= k width] acc [recur [+ k 1] [+ acc [at src [+ start k]]]]]]] + [put partials c total]] + +[fn main [] + [let n 4096] + [let chunks 64] + [let width [/ n chunks]] + + [let src [buf [range 0 n]]] + [let mut partials [buf-zeros chunks]] + + [Place.run sum-chunk chunks #[width src partials]] + + ; Phase two: sixty-four numbers, added on the host. Sending this to a device + ; would cost more than doing it. + [let total [sum [Place.read partials]]] + + [IO.println [str "sum of 0.." n " = " total]] + [IO.println [str "expected = " [/ [* [- n 1] n] 2]]] + [IO.println [str "stats: " [Place.stats]]]] From 6f13fc6a57f2da3fbe63e5d40285f3edf40a26c3 Mon Sep 17 00:00:00 2001 From: Cam Pedersen Date: Tue, 18 Aug 2026 13:47:59 -0400 Subject: [PATCH 15/25] Placed programs run in a browser MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `crates/loon-wasm` gains an `eval_placed` export that runs on the EIR VM, and `web/public/place.html` exercises it: pick a placement in a tab, see what crossed the boundary. placed on device: 4 launches over 32 work items; 9 uploads (288 B), 2 downloads (64 B), 3 resident hits That is the residency handler — written in M2 against no hardware at all — deciding what a browser copies. Verified in a real tab, not inferred from the fact that it compiles. Kernels and buffers exist only on the EIR VM, which is why a new export was needed rather than a migration. The DOM-driving exports stay on the legacy interpreter: its bridge is written against `Value`/`InterpError` rather than the EIR's `Val`/`VmResult`, and the guide's examples use builtins such as `push!` that the EIR VM does not implement. Adding an entry point beats breaking documented pages. WebGPU remains the missing half, and now for a precise reason rather than a vague one: wgpu's device setup returns futures a browser resolves on its event loop, and `eir::gpu` blocks on them with pollster, which cannot block on wasm. `--place gpu` in a tab refuses and says why. The shaders are validated by naga in CI, so both ends are known-good; the wire between them is what is absent. Co-Authored-By: Claude Fable 5 --- crates/loon-wasm/src/lib.rs | 42 ++++++- .../blog/2026-08-18-placement-is-an-effect.md | 11 +- docs/plans/2026-08-18-placement-remaining.md | 45 +++++--- web/public/pkg/loon_wasm.d.ts | 19 +++ web/public/pkg/loon_wasm.js | 42 +++++++ web/public/pkg/loon_wasm_bg.wasm | Bin 1022844 -> 1459917 bytes web/public/pkg/loon_wasm_bg.wasm.d.ts | 1 + web/public/place.html | 108 ++++++++++++++++++ web/src/pages/blog.loon | 6 +- 9 files changed, 246 insertions(+), 28 deletions(-) create mode 100644 web/public/place.html diff --git a/crates/loon-wasm/src/lib.rs b/crates/loon-wasm/src/lib.rs index d9568d6..e6f821b 100644 --- a/crates/loon-wasm/src/lib.rs +++ b/crates/loon-wasm/src/lib.rs @@ -42,12 +42,44 @@ fn call_js_bridge(op: &str, args: &[Value]) -> Result Result { + let mode = loon_lang::eir::place::Mode::parse(place) + .ok_or_else(|| format!("unknown placement mode '{place}'"))?; + let (result, stats) = + loon_lang::eir::vm::eval_eir_placed(source, std::path::Path::new("."), mode) + .map_err(|e| e.to_string())?; + + let mut out = result.output.join("\n"); + if !out.is_empty() { + out.push('\n'); + } + out.push_str("\u{2014}\n"); + out.push_str(&format!("placed on {}: {}", mode.name(), stats.summary())); + Ok(out) +} + /// Evaluate a Loon program and return the result as a string. -// TODO: migrate to `loon_lang::eir::vm::eval_eir` once the EIR VM supports -// the DOM bridge (init_dom_bridge / eval_ui / invoke_callback). The WASM crate -// still uses the legacy tree-walking interpreter because the DOM bridge depends -// on `Value` and `InterpError`, which differ from the EIR's NaN-boxed `Val` / -// `VmResult`. A conversion layer or EIR-native DOM bridge is needed first. +// The DOM-driving exports (`eval_ui`, `invoke_callback`) stay on the legacy +// tree-walking interpreter: the DOM bridge is written against `Value` and +// `InterpError`, which differ from the EIR's NaN-boxed `Val` and `VmResult`. +// `eval_program` and `eval_with_output` stay with them so the guide's examples +// keep working — several use builtins such as `push!` that the EIR VM does not +// implement. Programs that need the EIR VM call `eval_placed` above. #[wasm_bindgen] pub fn eval_program(source: &str) -> Result { let exprs = loon_lang::parser::parse(source).map_err(|e| format!("{e}"))?; diff --git a/docs/blog/2026-08-18-placement-is-an-effect.md b/docs/blog/2026-08-18-placement-is-an-effect.md index fac2fc2..e9e2bb5 100644 --- a/docs/blog/2026-08-18-placement-is-an-effect.md +++ b/docs/blog/2026-08-18-placement-is-an-effect.md @@ -160,13 +160,18 @@ Every accounting number, no execution. And strace-for-GPU is the same shape as s Metal on this laptop, today. Vulkan on a Linux box and DX12 on Windows are the same code path through wgpu, and I have not run either, so take them as "should" rather than "does." -The one I want to be careful about is the browser. WGSL is WebGPU's shading language, and every kernel we emit is validated by naga — the same front end a browser uses — so the *shader* half is genuinely portable, and PTX and AMDGCN cannot go there at all. The whole placement stack also compiles for `wasm32-unknown-unknown`: +The browser needs care, because there are two halves to it and they are in different states. + +Programs do run in a tab. `web/public/place.html` loads the wasm build, and the buttons pick a placement: ``` -cargo check -p loon-lang --target wasm32-unknown-unknown +placed on device: 4 launches over 32 work items; + 9 uploads (288 B), 2 downloads (64 B), 3 resident hits ``` -But you still cannot run one of these programs in a tab, because Loon's browser build embeds the old tree-walking interpreter rather than the EIR VM. That gap predates this work and has nothing to do with placement — it is a TODO in `crates/loon-wasm` about the DOM bridge. So: the code is ready to go there, the shaders are known-good there, and nobody has moved the runtime yet. I'm noting the architecture points at a target the alternatives can't reach; I'm not claiming to have arrived. +That is the residency handler, written against no hardware at all, deciding what a browser copies. Kernels and buffers only exist on the EIR VM, so the wasm crate grew an `eval_placed` export that runs on it; the DOM-driving exports stay on the old tree-walking interpreter, because the guide's examples use builtins the EIR VM doesn't implement and I would rather add an entry point than break documented pages. + +WebGPU is the half that isn't done. WGSL is its shading language and naga validates every kernel we emit, so the shaders are known-good there — but reaching an actual GPU from a tab needs wgpu's asynchronous device setup, which this build doesn't do. `--place gpu` in the browser refuses and says why. So: the programs run, the shaders would run, and the wire between them is missing. Every kernel in the repo is parsed and type-checked by naga in CI, on machines with no GPU. That's the automated cross-target validation the paper says is still missing — they found a host/device divergence in slice lowering by hand, `(ptr, len)` on two targets and `[i64; 2]` on a third. We have the same class of hazard: NaN-boxing constants that used to be copy-pasted into three backends under a comment asking the next person to keep them in sync. They now live in one file, and a conformance test compiles the same literals on every backend and compares raw bits. diff --git a/docs/plans/2026-08-18-placement-remaining.md b/docs/plans/2026-08-18-placement-remaining.md index 5405604..f76b739 100644 --- a/docs/plans/2026-08-18-placement-remaining.md +++ b/docs/plans/2026-08-18-placement-remaining.md @@ -28,36 +28,43 @@ code. ## Not done -### The browser +### WebGPU from a browser -`crates/loon-wasm` embeds the tree-walking interpreter, not the EIR VM, so -none of the above reaches a tab. The blocker is the DOM bridge (`lib.rs:46`), -which predates placement entirely. The placement code itself compiles for -`wasm32-unknown-unknown` today: +Placed programs *do* run in a browser: `crates/loon-wasm` exports `eval_placed`, +which runs on the EIR VM, and `web/public/place.html` exercises cpu, par, and +device placement in a tab with transfer accounting. The residency handler works +there. - cargo check -p loon-lang --target wasm32-unknown-unknown +What is missing is the GPU behind it. wgpu's WebGPU backend needs asynchronous +device initialization (`request_adapter`/`request_device` return futures that a +browser resolves on its event loop), and `eir::gpu` uses `pollster::block_on`, +which cannot block on wasm. `--place gpu` in a browser refuses and says so. -Moving the wasm build onto the EIR VM is its own project. Once done, wgpu's -WebGPU backend and async device initialization are the remaining pieces. +The DOM-driving exports (`eval_ui`, `invoke_callback`) remain on the legacy +interpreter. The bridge is written against `Value`/`InterpError` rather than the +EIR's `Val`/`VmResult`, and the guide's examples use builtins such as `push!` +that the EIR VM does not implement — so `eval_program` and `eval_with_output` +were left alone rather than regressing documented pages. -### Reductions and atomics +### Atomics -Kernels are map-shaped: a work item writes at its own index. A reduction needs -workgroup-shared memory and a two-phase dispatch, and the disjointness -argument that makes parallel placement sound stops holding. Host-side -reduction after `Place.read` works today and is what the samples do. +Reductions are done — see `samples/place/reduce.oo`. They needed no new feature: +each work item sums its own chunk into its own slot of a partials buffer, which +is still "write at your own index", and the handful of partials is combined on +the host. Anything genuinely needing atomics (a histogram, a scatter-add) is +still out, and that is the same restriction as the scatter rule below. ### 64-bit on a GPU -WGSL core has no `f64` or 64-bit integer. Buffers of those types are narrowed -to 32-bit on the device, reported rather than hidden (`DType::gpu_ok`). +WGSL core has no `f64` or 64-bit integer, so a launch with such a buffer is +refused with a message naming the type and the alternative. It is not narrowed +silently — handing back a precision the program never asked for, and cannot +detect, is the failure this design exists to avoid. ### Scatter kernels -`check::kernel` does not yet enforce that a `put` index is the work index. The -parallel executor catches a violation at runtime — a write outside the slice a -thread owns is an error naming the problem — but catching it at compile time -would be better. +Rejected at compile time now (E0602), naming the offending index. Reading +anywhere is still allowed: gather is safe, scatter is not. ### Numbers we do not have diff --git a/web/public/pkg/loon_wasm.d.ts b/web/public/pkg/loon_wasm.d.ts index a71b9c6..c81628e 100644 --- a/web/public/pkg/loon_wasm.d.ts +++ b/web/public/pkg/loon_wasm.d.ts @@ -16,6 +16,24 @@ export function clear_effect_log(): void; */ export function enable_effect_log(enabled: boolean): void; +/** + * Run a Loon program on the EIR VM, with a placement mode. + * + * This is the entry point a browser needs for placed programs: kernels, + * buffers, and the `Place` effect exist only on the EIR VM, so the + * interpreter-backed exports below cannot run them at all. + * + * `place` is `cpu`, `par`, `device`, or `gpu`. In a browser, `cpu` is the + * real answer and `device` models a discrete memory so transfer counts can + * be shown; `par` has no threads to use here and behaves as `cpu`; `gpu` + * reports that this build has no GPU support, because reaching WebGPU needs + * wgpu's async device initialization, which this crate does not do yet. + * + * Returns the program's printed output followed by its placement accounting, + * so a page can show what crossed the boundary. + */ +export function eval_placed(source: string, place: string): string; + /** * Evaluate a Loon program and return the result as a string. */ @@ -71,6 +89,7 @@ export interface InitOutput { readonly memory: WebAssembly.Memory; readonly check_program: (a: number, b: number) => [number, number, number, number]; readonly enable_effect_log: (a: number) => void; + readonly eval_placed: (a: number, b: number, c: number, d: number) => [number, number, number, number]; readonly eval_program: (a: number, b: number) => [number, number, number, number]; readonly eval_ui: (a: number, b: number) => [number, number]; readonly eval_ui_checked: (a: number, b: number) => [number, number]; diff --git a/web/public/pkg/loon_wasm.js b/web/public/pkg/loon_wasm.js index cec6a62..326c29b 100644 --- a/web/public/pkg/loon_wasm.js +++ b/web/public/pkg/loon_wasm.js @@ -41,6 +41,48 @@ export function enable_effect_log(enabled) { wasm.enable_effect_log(enabled); } +/** + * Run a Loon program on the EIR VM, with a placement mode. + * + * This is the entry point a browser needs for placed programs: kernels, + * buffers, and the `Place` effect exist only on the EIR VM, so the + * interpreter-backed exports below cannot run them at all. + * + * `place` is `cpu`, `par`, `device`, or `gpu`. In a browser, `cpu` is the + * real answer and `device` models a discrete memory so transfer counts can + * be shown; `par` has no threads to use here and behaves as `cpu`; `gpu` + * reports that this build has no GPU support, because reaching WebGPU needs + * wgpu's async device initialization, which this crate does not do yet. + * + * Returns the program's printed output followed by its placement accounting, + * so a page can show what crossed the boundary. + * @param {string} source + * @param {string} place + * @returns {string} + */ +export function eval_placed(source, place) { + let deferred4_0; + let deferred4_1; + try { + const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(place, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.eval_placed(ptr0, len0, ptr1, len1); + var ptr3 = ret[0]; + var len3 = ret[1]; + if (ret[3]) { + ptr3 = 0; len3 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred4_0 = ptr3; + deferred4_1 = len3; + return getStringFromWasm0(ptr3, len3); + } finally { + wasm.__wbindgen_free(deferred4_0, deferred4_1, 1); + } +} + /** * Evaluate a Loon program and return the result as a string. * @param {string} source diff --git a/web/public/pkg/loon_wasm_bg.wasm b/web/public/pkg/loon_wasm_bg.wasm index ff123f6778c56a6dae6324eff4b5f339951e9a6d..0340fb0f69667b5f7a7ac76d8e5d0cf8902ffa9d 100644 GIT binary patch literal 1459917 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ⅈ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 @)sQPyQ8?9pFV<=@*(;FGnJ#REc z&U^PHPsY3C+B-1B4Ywb$>x_Sz)C z%*${J@t0MVw?Z1qb9xNl!`?dQAxk(FrRb)IdI11WfC)(^qolw@`rv9!SI=k;_=2_3 z(8lODyv5qnYiO;;jIwp4YDT}YG5S4{Y3C+ksjH}a?qw-w1o7$K-=o=N)rCRv0)*wD z_A+cjYE3oCV>J8uY{O*KydY|-W&RgQP}$F`m2Oi@zb02fLzBrit)+$xEV1S)E!Z}A zx3P%Ze&4F!p+5VamC_Ub`__$VThw!ovMY;(%^vOLsnRV;{LWm#8fWW+0Ib4O-xPeLU;$qy_-dW5!>0wNbWNGlU2WQN?r7(nWGXvX$^QbA@OYN_ z+UG8}I@BHISQF5Ux@Y7+Bj_$_O4dfrjnO&YVg-EW%SX;t-)eJUe*+*YCFxv6fTHYN zky0i~QY$(KLIP*)9i5IqD|&gJkd~dtgSMpXoGnBiSy4f^IaeHx9!_@Ol>Ne+$tLEI zA1Xsh{Ia?WA-|clUk>?8G1pt&b56_6qxqj}arFecf0OVNFkL@`}|Eot}M*O+!8wIT^x3439Ml1SMWR*5=K zn&ga~>hnm>XM(y;a@~^T)aoNSR(b8{o@0z+-W!M=#`!4@Hd*-jUF9>Y^ZoJwF>$2MX8%XQ zAUb=gILjmc9V*T~{(q&*ZcJ{7wUTi<#U-?8)KrhAPc|Sc`H^)I9ngiX;!sQLLX}Tz z%X#bX%76N^UoeGF01wYyYkMg?BB)vFdOe4fh5Fs`jR^|R@Y*#L@y*%HCvnb`{BagA3}xe=?2J`C0rf z)ElQwoO;U2@fFl5O0=Z!7Cz#}3E5aP)Hjwot|<)8LKbFlSPr4J+`T?2l`he82KycQ zxc62h$o;m?a5@GM806io>f~^JH$?*JR&|7QFQN2aoc^X>HZc0tP{HgE6?*yfZ;_Ueg(L1lxeR%Mln$V#~ zvizS36%K7D4tdHck<4$FC2kp8spF)LQSpV9DvD!YuvYlO^RtyNJf|1e?n?@a*r+7Q0cL_-QjKZwW`3eH})o)_bzL) z7Q=Gz3cO#+v@>ws5_eWOR-sXTn+an#lThy!i#y?iF(|fTV0}?y4?2bD&K*luM*U*S* zCZRk>c;*&*u-~p~Q1i^qH45LH*&8kf@IH3*(g5=A{XEg?4I=2Ih>19_y%4ToPO;+$ z#BjFPj$sE_YDE0_|1GThy_nNFRcQGC&75wM^ZP1#8W>1DJy7ZC!9hKJLtjr1^m=;m zmG<=Jlj;gbjKmxDiAb>iAn67F5bu^$=cU6(= zzvLu%h=m->DSy>Nkp;j12qiHIyy|{8loZ*WbZV&Dns)K5nF8Z=cu%PrdE7d~t+ubA z$?Vkk^R(~`;2erV`GfuEQT{-3#`O1BKfGUqByms0g%Tp^Tfk}Z)c|2a8q zAb=_dx)2u^SV>|RlHx)dE~LeUTDVXvF4V(?dU2rh0!fK{+z9yvEOCC>Gz!+b^o-Eu*AFlHcUN@1b%k0%X-Z$_Q3q<_QT;#6 zNYva5u65Em1Ifn5_>7bqyC)mIXLI)6o#+rVtoRf=I=zbzHD%YOotoS>W>B~DwWbQB zElZ~gb%VxT$#3j;Ji!4y-R3|~r5#pC@t}J6ioi;kd|dNuk&2*-+nBCPRQ!SI@j(Ljrw)p4IQ6PZ>RDPIs9Wg)Wo-!|0j|a0H>{ z!5+imbjj)T1?`1JipbarUb3^tOAEe)oC%=art(GNuVn>&UCHPge=&X-q~b3Nh(KIo1uj5j zVmNk$2^S!6zhL~u9mb2g!}yB}_OLD(e{lha!yhsJ;sOy;E;xTRsWr(s)&hS~sVMLl zB{ne0J1HL7VdfdBFiFicn5bAUjzJB1*`=}3khbP5Y7+K{Td|EsQy0{$v zx;~O$qZJe?+SRfP(1YDr&zHZ8(A=@;TD?6jpYfN~wvR%UR9eb9OCh!f)34pSJWXC~ z<;Ip8l{X0M;28GP0e2YR^7ObDy=#e0RUpqSc&=0B&J6ew)uN+@qTsyAsRe%5ckx78 zw6FjtIIu);oCEd$RE~{N;{#w@NY6Aqz^uO7>w4H;18ONMCFTT)8qh`ne>!HR3HCTn zEuER3uDyAcj_o&hM^-tw6WP)oawye1ik$K}c>PaEgaIzrC2r?)HSm>B-*_F1_rdh9 zYeW>gqt>6|%PKXyKfVrwoE%9$O+`ln4vqx9QZMX(WmeP8vBtWVw|*TtRxiGw5>8ZR z(Qw=AsqLB7{VOB+VgE|12klp6uzuA|BjF8xZ!KT`>-jYX6QS3oATX1li91XFwNf9P zEnj@`A&g#5`4lS9pH3B|h?8oQ-Fb{g;M*g;x^`h4v4+WxVd>{1#H z|9CN@XCFvJP#O`{xvY+!{hIo(x~V#Pg1I_+XbME~xaB;V_XIeElcIuW?ay+m|AD6FGwy|Yi)u;6x_60^6{-zQ^14|k9SR04G?c5 zCf-1{A}M?xfhSYOE>J0!nxXn>N?X3uqFl!XNET}72Fa!Y5xVQHy18MELI;>Js3W5C z%u;T0`@_u7IUUbUc%n5F;^a=>)90m+1v`HO%HmjYGRetoaguRzxHy^MHk$7e6+s@Zt+GWNBJAlN*{=0QQrgt}$Vf{d~W68#Pv+`eBwBw@Dtd%Vq zNpTWU@r8Fp`G(8J*kHo8TL`BOPRUX(ex-1?GB1i#d{;TGekzxvJh==i$w~8<31|io zjzN-7T|UOk5?Q&^ah4QL#r2GPf+V6h>@hrSa~JZ}RkanLq9&iB@MO)WP^89v3UFjT zgL+ely% zDo`!vrdj1FxvM>^oHMh^IbxL$$tqWbAzNnFUDN8@7WT6~Vum=zkEXGfX|q*6Dw7-; z6XWqNmASQKj#~TdL!iTgYOR&f7-NZ}WqFVxDsurF7 ziUxFhT)+Ao9GtYzqFaVQgOn(u?RBr9;&+2A4%gEW4%0DVH7u?z5P4DkHOXfaVlxoD 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

7Qhh|u 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 z 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

KbO7?sbR5&#EQn_cS+|QKPX~b^66%!qYY_e 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

0wKx0B@UPfB4~I_++#F3sDoY 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 ceitn(ru}?rf}w3*=FtCX-H)~(E?0B*!xb#x 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㚠^FgP#gr$2T@M~@?rIC;RG&9T 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

6~Zna$}^7;Rdk*>Z6$jZk(U+w$S#yG%4h4l&Mh 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 UZ%F-(2b%ru2U2ID)T8|W0sX5@xc~qF literal 1022844 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%0AjZbV!mUsuJs%5 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 iXfzL5|1AaZd9Fv_Jb(Iik&6>2xRkE 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