perf(bb/msm): stream-walker l0 load-reuse — portable Adreno+Mali win; register-budget boundary mapped (fused overshoots Adreno)

[AztecBot]

Stream-walker l0 load-reuse — a portable, register-safe memory-latency win

TL;DR

The stream-walker is memory-bandwidth-bound on real mobile hardware. Caching each slot's packed l0_index handle once in the forward pass and reusing it (instead of re-issuing the dependent gather 3–4× per point) is a real, cross-vendor win — proven on both Adreno and Mali with drift-controlled in-session A/Bs. This PR ships that (reuseLoads, default on) and maps the exact register-budget boundary: pushing the reuse one step further (fusePeel — merge the inverse + backward-peel passes to also cut a point_x gather) overshoots Adreno's per-thread register file and is catastrophic there, while Mali tolerates it. So reuseLoads is the maximum register-safe reuse; fusePeel stays gated off.

reuseLoads caches only the 4-byte handle and re-reads point_x from the resolved index (a cache hit) — it adds zero net live per-thread state, which is why it stays under the occupancy cliff. Bit-identical arithmetic; neutral-to-positive everywhere measured.

Real-hardware A/B — Adreno (Galaxy S25 Ultra · Adreno 830 · Chrome 145), GPU wall time

Drift-controlled interleaved A/B (both variants in one page load, shared thermal state). Win grows with size — the memory-bound signature (reducing the dependent l0_index gather pays off once the working set exceeds cache):

logn	reuse	base	speedup
14	119.3 ms	132.5 ms	+9.5 %
16	232.9 ms	277.9 ms	+16.2 %

Re-confirmed this session with single-variant solo runs (n=20): reuse logn14 = 117.8 ms, logn16 = 231.2 ms — matches the interleaved numbers.

Real-hardware A/B — Mali (Pixel 9 Pro XL · Tensor G4 · Chrome 145), GPU wall time — the portability proof

Same harness, interleaved reuse,base,fused, n=12/variant, logn16. Wall is the trustworthy metric on Android (uncalibrated timestamp-query); stream_walker phase delta is shown as corroboration and agrees in direction:

variant	median wall	Δ vs base (wall)	Δ vs base (stream_walker)
base	377.2 ms	—	—
reuse	368.7 ms	−2.3 %	−3.9 %
fused	364.3 ms	−3.4 %	−4.8 %

The load-reuse win generalizes to Mali (smaller magnitude than Adreno — different memory hierarchy/cache, but real and directionally consistent across both wall and the stream_walker phase). This was the missing portability proof.

The register-budget boundary — how far the reuse can be pushed (gap closed)

fusePeel extends the idea: merge the inverse pass into the backward peel so each slot's point_x is gathered 2× instead of 3×, and the per-slot inv_dx scratch round-trip vanishes. Expected: a small further win on top of reuse. On Mali it delivers exactly that and is the best variant (fused−reuse = −1.2 % wall). On Adreno it is catastrophic:

logn	reuse	fused	result
14	117.8 ms	1137.9 ms	~9.7× slower (n=20, tight 1122–1151 ms)
16	231.2 ms	—	GPU device lost (reproduced in 3 independent runs)

Why: the merged backward loop holds inv_dx + both points' x/y + lambda + the result point live simultaneously (~8 field elements ≈ 64 registers/thread). That overshoots Adreno's small per-thread register file → register spill / occupancy collapse (the deterministic, low-variance ~10× slowdown at logn14) → at logn16 the pressure loses the device entirely. This is the same register-file-competition failure mode that makes this PR non-composable with #23726, and the same class as the earlier x-coord value-cache dead-end (~4×). Mali's larger budget hides all of it.

Boundary, stated precisely: caching only the 4-byte handle and re-reading point_x (reuseLoads) adds +0 net live per-thread registers → at/under Adreno's budget → the maximum register-safe reuse. Any extension that adds live per-thread field-element state — the x-coord value cache (4×) or the fusePeel merge (≈10× / device-loss) — exceeds Adreno's budget. The lever is exhausted at reuseLoads; fusePeel is kept as an A/B knob, default-off, documented Adreno-unsafe in MsmConfig.

Correctness (SwiftShader, headless, WASM-free Noble cross-check) — PASS

All three variants (base, reuse, fused) agree with @noble/curves at logn 10 and 12 (autorun=msm-ref-check; the in-tree bb wasm is a 213-byte stub, so Noble is the oracle). _generated/shaders.ts regenerated and in sync.

Harness notes

• Adreno can't run the 3-variant interleaved A/B: the bench destroys+rebuilds the whole MsmV2 on every variant switch, and on Adreno the rebuild churn following a fused pipeline build reproducibly loses the device. The fused-on-Adreno characterization above therefore uses single-variant solo runs (one build, no rebuild). A proper fix (cache pipelines per variant — the ~49 MB SRS pool is shared, per-MsmV2 state is tiny) would enable interleaved A/B on Adreno too.
• q-param URL workaround + page-load beacon (prior commits) are what make the runtime A/B drivable on real Android at all.

Recommendation

• Ship reuseLoads (this PR's default). Proven win on Adreno (~10–16 %) and Mali (~2–4 %), register-safe on both, bit-identical.
• Keep fusePeel off. Adreno-unsafe (≈10× / device-loss); on Mali it's only ~1 % better than reuseLoads — not worth a vendor-specific gate.
• Do not compose with perf(bb/msm): stream-walker pref_scratch → private memory (frees workgroup occupancy limiter), TPB 64→128 #23726's private pref_scratch on mobile (separate register strategy; ~4× regression).

Base: stream-walker-impl.