Experiment with a new worker pool bench

Author: FrancescAlted

bench/js-transpiler/README.md

@@ -50,3 +50,37 @@ python3 -m http.server          # from the repo root
 
 Serve from the repo root (not `file://`): the page fetches `/src/blosc2/dsl_js.py` (the
 local transpiler, newer than the PyPI wheel) at a server-root-absolute path.
+
+## Multithreading ceiling — `worker-pool-bench.mjs`
+
+Throwaway exploration of *how fast the transpiled kernel could go* with real JS
+multithreading: pure Node (`worker_threads` + `SharedArrayBuffer`), **no Pyodide, no
+blosc2**. Same Newton kernel, partitioned across a persistent worker pool with an Atomics
+barrier; reports speedup vs single-thread for 1/2/4/N workers.
+
+```sh
+node bench/js-transpiler/worker-pool-bench.mjs
+```
+
+Findings (Apple M2, 4 performance + 4 efficiency cores; laptop numbers vary ±10–15% with
+thermal/P-vs-E scheduling, so treat these as representative, not exact):
+
+| workers | ms/frame | speedup |
+|---|---|---|
+| single-thread | ~11.3 | 1.0× |
+| ×2 | ~5.9 | ~1.9× (~94% eff) |
+| ×4 | ~3.1 | ~3.5× (~88% eff) |
+| ×8 | ~2.3 | ~4.8× (~60% eff — E-cores) |
+
+- The worker mechanism is ~free (×1 ≈ 1.0×); scaling is near-linear up to the performance
+  core count. The ×8 drop-off is the M2's efficiency cores, not overhead.
+- **Load balancing is essential.** Contiguous row-bands regress badly (×4 fell to 1.48×)
+  because the per-pixel early-`break` makes some bands all-max-iter and others trivial.
+  **Striped** rows (worker `i` → rows `i, i+nw, …`) fix it — that's what the bench uses.
+
+Why this stays a *headroom* result, not a shipped feature: it measures **pure compute**.
+The real `jit_backend="js"` path also pays ~8 ms/frame of blosc2 decompress/compress that
+does not parallelize this way, plus Pyodide orchestration is single-threaded — so realistic
+end-to-end gain is a fraction of 5×. And a browser integration needs pure-JS workers (not the
+Pyodide bridge), a SharedArrayBuffer, COOP/COEP cross-origin isolation, and a path to get
+decompressed chunks into shared memory. See "Deferred" in [`plans/dsl-js.md`](../../plans/dsl-js.md).

bench/js-transpiler/worker-pool-bench.mjs

@@ -0,0 +1,126 @@
+// Throwaway: how fast can the transpiled Newton kernel go with real JS multithreading?
+// Pure Node (worker_threads + SharedArrayBuffer), no Pyodide, no blosc2 -- isolates the
+// compute ceiling and per-dispatch overhead a Web Worker pool would hit in a browser.
+// The kernel is the same scalar loop dsl_js emits; hand-written here to avoid Pyodide.
+//
+//   node bench/js-transpiler/worker-pool-bench.mjs
+import { Worker, isMainThread, workerData } from "node:worker_threads";
+import os from "node:os";
+import { performance } from "node:perf_hooks";
+
+const WIDTH = 320, HEIGHT = 213, MAXITER = 48, NFRAMES = 24, SPANX = 3.4;
+const ASPECT = HEIGHT / WIDTH;
+const N = WIDTH * HEIGHT;
+
+// Striped rows (rowStart, rowStep): worker i does rows i, i+nw, ... so the per-pixel
+// early-exit work spreads evenly across workers instead of clumping in contiguous bands.
+function newtonBand(A, B, OUT, rowStart, rowStep, H, W, maxIter, relax) {
+  for (let row = rowStart; row < H; row += rowStep) {
+    for (let col = 0; col < W; col++) {
+      const i = row * W + col;
+      let za = A[i], zb = B[i], it = maxIter;
+      for (let k = 0; k < maxIter; k++) {
+        const a2 = za * za, b2 = zb * zb;
+        const fr = za * a2 - 3 * za * b2 - 1, fi = 3 * a2 * zb - zb * b2;
+        const dr = 3 * (a2 - b2), di = 6 * za * zb, den = dr * dr + di * di + 1e-12;
+        const qr = relax * (fr * dr + fi * di) / den, qi = relax * (fi * dr - fr * di) / den;
+        za -= qr; zb -= qi;
+        if (qr * qr + qi * qi < 1e-6) { it = k; break; }
+      }
+      const d0 = (za - 1) * (za - 1) + zb * zb;
+      const d1 = (za + 0.5) * (za + 0.5) + (zb - 0.8660254) * (zb - 0.8660254);
+      const d2 = (za + 0.5) * (za + 0.5) + (zb + 0.8660254) * (zb + 0.8660254);
+      let root = 0, md = d0;
+      if (d1 < md) { md = d1; root = 1; }
+      if (d2 < md) { root = 2; }
+      OUT[i] = root + 0.9 * (it / maxIter);
+    }
+  }
+}
+
+// ctrl: Int32[ gen, done ].  params: Float64[ relax, maxIter ].
+if (!isMainThread) {
+  const { ctrlSab, paramsSab, aSab, bSab, outSab, rowStart, rowStep, W } = workerData;
+  const ctrl = new Int32Array(ctrlSab), params = new Float64Array(paramsSab);
+  const A = new Float64Array(aSab), B = new Float64Array(bSab), OUT = new Float64Array(outSab);
+  let gen = 0;
+  for (;;) {
+    Atomics.wait(ctrl, 0, gen);          // block until main bumps the generation
+    gen = Atomics.load(ctrl, 0);
+    if (gen < 0) break;                  // shutdown
+    newtonBand(A, B, OUT, rowStart, rowStep, HEIGHT, W, params[1] | 0, params[0]);
+    Atomics.add(ctrl, 1, 1);             // signal this band done
+    Atomics.notify(ctrl, 1);
+  }
+} else {
+  main();
+}
+
+function buildGrid() {
+  const aSab = new SharedArrayBuffer(N * 8), bSab = new SharedArrayBuffer(N * 8),
+        outSab = new SharedArrayBuffer(N * 8);
+  const A = new Float64Array(aSab), B = new Float64Array(bSab);
+  const x0 = -SPANX / 2, dx = SPANX / (WIDTH - 1);
+  const y0 = -SPANX * ASPECT / 2, dy = SPANX * ASPECT / (HEIGHT - 1);
+  for (let r = 0; r < HEIGHT; r++)
+    for (let c = 0; c < WIDTH; c++) { A[r * WIDTH + c] = x0 + dx * c; B[r * WIDTH + c] = y0 + dy * r; }
+  return { aSab, bSab, outSab };
+}
+
+function timeBest(fn, runs) {
+  for (let w = 0; w < 2; w++) fn();      // warm V8 / workers
+  let best = Infinity;
+  for (let r = 0; r < runs; r++) { const t = performance.now(); fn(); best = Math.min(best, performance.now() - t); }
+  return best;
+}
+
+async function benchPool(nw, sabs, relaxes) {
+  const ctrlSab = new SharedArrayBuffer(8), paramsSab = new SharedArrayBuffer(16);
+  const ctrl = new Int32Array(ctrlSab), params = new Float64Array(paramsSab);
+  params[1] = MAXITER;
+  const workers = [];
+  for (let i = 0; i < nw; i++) {
+    workers.push(new Worker(new URL(import.meta.url), {
+      workerData: { ...sabs, ctrlSab, paramsSab, rowStart: i, rowStep: nw, W: WIDTH },
+    }));
+  }
+  const frame = (relax) => {
+    Atomics.store(ctrl, 1, 0);
+    params[0] = relax;
+    Atomics.add(ctrl, 0, 1);
+    Atomics.notify(ctrl, 0, nw);
+    let d;                               // barrier: wait until all bands reported done
+    while ((d = Atomics.load(ctrl, 1)) < nw) Atomics.wait(ctrl, 1, d);
+  };
+  const sweep = () => { for (const rx of relaxes) frame(rx); };
+  const best = timeBest(sweep, 5);
+  Atomics.store(ctrl, 0, -1); Atomics.notify(ctrl, 0, nw);   // shutdown
+  await Promise.all(workers.map((w) => w.terminate()));
+  return best;
+}
+
+async function main() {
+  const cores = os.cpus().length;
+  const sabs = buildGrid();
+  const OUT = new Float64Array(sabs.outSab);
+  const relaxes = Array.from({ length: NFRAMES }, (_, i) => 1.0 + (1.85 - 1.0) * i / (NFRAMES - 1));
+
+  // Single-thread baseline on the main thread (no worker overhead at all).
+  const A = new Float64Array(sabs.aSab), B = new Float64Array(sabs.bSab);
+  const tSingle = timeBest(() => { for (const rx of relaxes) newtonBand(A, B, OUT, 0, 1, HEIGHT, WIDTH, MAXITER, rx); }, 5);
+  const ref = Float64Array.from(OUT);    // last frame (relax=1.85), for correctness check
+
+  console.log(`Newton ${WIDTH}x${HEIGHT}, max_iter=${MAXITER}, ${NFRAMES}-frame sweep | cores=${cores}`);
+  const per = (ms) => `${ms.toFixed(0)} ms total (${(ms / NFRAMES).toFixed(2)} ms/frame)`;
+  console.log(`\nsingle-thread (main): ${per(tSingle)}`);
+
+  const counts = [...new Set([1, 2, 4, cores])].filter((n) => n >= 1 && n <= cores * 2).sort((a, b) => a - b);
+  for (const nw of counts) {
+    const t = await benchPool(nw, sabs, relaxes);
+    let maxdiff = 0;
+    for (let i = 0; i < N; i++) maxdiff = Math.max(maxdiff, Math.abs(OUT[i] - ref[i]));
+    const sp = tSingle / t;
+    console.log(`pool x${String(nw).padStart(2)} : ${per(t)}  | speedup ${sp.toFixed(2)}x` +
+                `  eff ${(100 * sp / nw).toFixed(0)}%  | maxdiff ${maxdiff.toExponential(1)}`);
+  }
+}