Seam-inlining not firing on the gust hot path (mix/transition survive as calls)

[avrabe]

Proposal for pulseengine/loom: seam-inlining is not firing on the gust hot path

Context. Benchmarked loom v1.1.14 as the wasm→wasm stage in the gust dissolve pipeline
(meld → loom → synth → cortex-m3). Honest finding up front: the loom output is already
good at the wasm level. The 3.9× gust_poll size gap vs native LLVM is overwhelmingly
synth's ARM-lowering problem (separate proposal), not loom's. This proposal is the smaller,
loom-scoped opportunity.

What loom did well (so we don't regress it)

The $gust_poll body loom emitted is compact and competitive with the LLVM IR shape:

• 8 wasm locals, no obvious redundant locals.
• Branch-free wrap via select — matches LLVM's it ne; movne if-conversion:

  local.get 5  i32.const 1  i32.add  local.tee 5
  local.get 5  i32.const 6  i32.eq   select        ;; (idx+1 == 6) ? 0 : idx+1

• Offset loads preserved: i32.load offset=52, i32.load16_u offset=4,
  i32.load8_u offset=4 — the structure synth should fold into addressing modes.
• i32.rem_u left intact (LLVM strength-reduces it; that's a synth lowering choice).

No dead code, no obvious local bloat. Good.

The loom-scoped gap: the two call seams are NOT inlined

$gust_poll still contains three real calls that survived loom:

call $_ZN10kiln_async4task18TaskTable$LT$_$GT$10transition…   ;; called TWICE (id=1, id=2)
call $_ZN15gust_wasm_scout3mix…                               ;; the failsafe mixer

(confirmed by wasm-tools print of gust.loom.wasm: transition, mix,
panic_bounds_check, and panic_fmt are all still separate functions, and the
corresponding relocations R_ARM_THM_CALL func_0/func_1/func_4/func_5 survive into the
final .o.)

This matters two ways:

1. mix is #[inline] in the source and is tiny (a few adds, a shift, two clamps).
   LLVM inlined it into gust_poll (the native gust_poll has no call to a separate
   mixer — it's the bl at 0x64/0xb0/0xc2 region that LLVM turned into inlined arithmetic

   • the closure). In the dissolved path it stays an out-of-line call, which (a) keeps a
     second function body alive in the kernel .text and (b) blocks synth from regalloc-ing
     across the seam.

2. The two transition calls are the scheduler closure seam — exactly the
   "seam-dissolve / full inlining" loom#219 is meant to handle. Until they inline, synth
   has to set up a full call frame (spill live values around the bl) at each site, which
   amplifies synth's already-poor spill behavior.

Evidence — the call frames synth is forced to build around the un-inlined seams

Because the mix/transition calls survive, synth materializes ABI argument shuffles and
spills at each site, e.g. around the second transition call (dissolved 0x49c–0x4c4):

add.w  r2, r8, #0x4
ldr.w  r1, [sp, #0xc]
ldr.w  r4, [sp, #0x1c]
ldr.w  r5, [sp, #0x20]
movw   r6, #0x2
str.w  r6, [sp]          ; 5th arg via stack
str.w  r0, [sp, #0x28]   ; caller-save spill across the call
mov    r0, r2  / mov r1,r1 / mov r2,r4 / mov r3,r5
bl     <transition>

If mix were inlined by loom, synth would never emit the gust_mix-style 44 B wrapper
frame inside the hot path, and the cross-seam values could stay in registers.

Recommendation

1. Make seam-inlining actually fire for #[inline]-annotated and small-leaf callees on
   the hot path (loom#219). At minimum, inline mix — it's #[inline], single-caller
   from gust_poll, and trivially small. The size win in the .o is the whole mix
   body's duplicated-call overhead plus the wrapper frame synth builds for it.
2. Inline the two transition closure-seam calls so synth sees a single straight-line
   loop body — this is the prerequisite that lets synth's (future) regalloc keep loop
   state in registers across what are currently call boundaries.
3. Add a dissolve-pipeline check / report that flags surviving calls to
   #[inline]-marked or single-use small functions on exported hot-path entries, so this
   regression is visible in CI rather than only in a hand-run compare-codegen.sh.

Honest sizing caveat: because the dominant 3.9× cost is synth-side spilling, inlining
alone will not close the gap — but it is the necessary enabler. With synth's regalloc
fix (separate proposal) plus seam inlining, the cross-seam register pressure relief
compounds: the single biggest synth win (eliminating per-call spill/reload of loop-live
values) is only reachable once loom removes the call boundaries inside the loop.

---

Filed from gale's gust dissolve benchmark (benches/gust/compare-codegen.sh). Reproduce: build native thumbv7m vs wasm→loom→synth→cortex-m3, disassemble with llvm-objdump -d --triple=thumbv7m. Measured on synth v0.11.50 / loom v1.1.14.

[avrabe]

Triage — root-caused, with a minimal repro. The fix already exists; it's unreleased.

You benchmarked v1.1.14. I confirmed the gap: v1.1.14 / main has only the straight-line inline-modelability gate. mix isn't straight-line — its bounds check is if (idx >= len) { call panic_bounds_check; unreachable }, i.e. acyclic control flow + a no-return call. The straight-line gate rejects it, so it stays an opaque call. Exactly what you saw.

The acyclic gate (Regime B) + the precise acyclic Z3 executor (PR-C) that do admit this shape were built for #219 but are not on main — they're in the 19 unmerged commits on feat/219-seam-sroa.

Minimal repro (mix's shape: bounds-check if+panic + load + arithmetic, single-caller):

(func $mix (param i32 i32) (result i32)
  local.get 0  local.get 1  i32.ge_u
  if  i32.const 0  call $panic  unreachable  end   ;; bounds check → no-return panic
  local.get 0  i32.const 4  i32.mul  i32.load  local.get 0  i32.add  i32.const 2  i32.shl)
(func $gust_poll (param i32) (result i32)  local.get 0  i32.const 6  call $mix)

• on main/v1.1.14: mix stays a call (straight-line gate rejects the if+call).
• on feat/219-seam-sroa: loom optimize --passes inline → gust_poll has zero call $mix (the if/load/arithmetic are inlined; Regime B admits if { call <noreturn>; unreachable }). Validates.

So point 1 (inline mix) is already fixed by the acyclic inliner — it just needs to reach a release. That subset (PR-C + Regime B, commits up to 01f3042) is separable from the still-unproven #219 seam-teardown (186d236→6299d76, awaiting your G474RE dual-flash), and it's Z3-gated (verify-or-revert), so I can cut it as v1.1.15 independently of the teardown.

Point 2 (the two transition closure-seam calls): I need the actual shape to confirm. Regime B currently excludes call_indirect and loop back-edges (Phase 1 scope). If transition is a closure via call_indirect, or has a loop, it stays opaque until Phase 2. Could you attach gust.loom.wasm (or the transition/mix function bodies from wasm-tools print)? That lets me validate end-to-end on the real path and size the Phase-2 gap precisely rather than guess.

Point 3 (dissolve-report flagging surviving calls to single-use small callees on exported hot-path entries): independently actionable, additive, doesn't touch correctness — I'll add it so this regresses loudly in CI. Note: the #[inline] attribute doesn't survive to wasm, so the report keys on single-use + small + still-called-from-an-exported-entry (a sound proxy).

Plan: (a) cut v1.1.15 from main + the acyclic inliner (fixes point 1) so you can re-bench; (b) add the dissolve-report (point 3); (c) Phase-2 transition once I have the fixture. Will ping when v1.1.15 is up.

[avrabe]

v1.1.15 is up as PR #229 — brings the acyclic inliner (PR-C + Regime B) to a release, so mix inlines (point 1). Bundled with #228 (multi-site small leaves + whole-function DCE). Merge-gated on CI; I'll ping when it's released so you can re-bench. Point 2 (transition) still needs the gust.loom.wasm fixture to confirm whether it's call_indirect/loop (Phase 2); point 3 (dissolve-report) is queued.

[avrabe]

v1.1.15 is released — PR #229 merged to main (squash af438fc), tag v1.1.15 pushed, release workflow running. The acyclic inliner (PR-C + Regime B) is now in a release, so the mix-shaped seam (if oob { call panic; unreachable } + load + arith) inlines. Please re-bench the gust hot path on v1.1.15 when the binaries land. Point 2 (transition) still needs the gust.loom.wasm fixture to confirm whether it's call_indirect/loop (Phase 2). The redundant inline arg-copy + CF-fragile simplify_locals are the next feature-loop item.