webgpu-bench 0.1.0

package/dist/sampling.d.ts

@@ -0,0 +1,96 @@
+import type { SamplingStopReason, Stats, SuiteProgressEvent } from './types.ts';
+/** Knobs for the round-robin, best-of-N sampling scheduler. */
+export interface SamplingConfig {
+    /** Fewest kept measurements per benchmark before it can converge. Default 3. */
+    minRounds?: number;
+    /** Most kept measurements per benchmark. Default 10. */
+    maxRounds?: number;
+    /** Converged once the best run hasn't improved (by more than `improvementTolerance`) over this many kept measurements. Default 2. */
+    stableRounds?: number;
+    /** Relative improvement that counts as "still improving". Default 0.01. */
+    improvementTolerance?: number;
+    /** A measurement this fraction slower than the best is throttled and discarded. Default 0.20. */
+    throttleThreshold?: number;
+    /** Idle gap between consecutive measurements, in ms. Default 100. */
+    idleMs?: number;
+    /** Suite-wide pause when throttling is detected, in ms. Default 3000. */
+    cooldownMs?: number;
+    /** Cooldown pauses before giving up on still-unconverged benchmarks. Default 3. */
+    maxCooldowns?: number;
+    /** Fraction of a round's measurements (and at least two) that must be throttled to trigger a cooldown. Default 0.5. */
+    throttledFraction?: number;
+}
+export declare const DEFAULT_SAMPLING: Required<SamplingConfig>;
+/** What the scheduler needs from a benchmark: something it can measure repeatedly. */
+export interface Sampleable {
+    id: string;
+    /** One-time setup (calibration, warmups). Called before the first `sample()`. */
+    calibrate(): Promise<void>;
+    /** One timed measurement: per-op time in ms. */
+    sample(): Promise<number>;
+}
+/** Running state of one benchmark inside the scheduler; surfaced after every measurement via `onUpdate`. */
+export interface SampleState {
+    id: string;
+    /** Kept measurements, in order taken. */
+    timesMs: number[];
+    /** Measurements discarded as throttled, in order taken. */
+    throttledMs: number[];
+    /** Best kept measurement so far; Infinity before the first. */
+    bestMs: number;
+    stopReason?: SamplingStopReason;
+    /** Set if calibration or a measurement threw; the benchmark is retired. */
+    error?: unknown;
+}
+export interface SampleStateSnapshot extends SampleState {
+    stats?: Stats;
+}
+export interface RunSamplingOptions extends SamplingConfig {
+    /** Called after every measurement (and when a benchmark is retired) with that benchmark's state. */
+    onUpdate?: (state: SampleStateSnapshot) => void | Promise<void>;
+    onProgress?: (event: SuiteProgressEvent) => void;
+    /** Injectable for tests; defaults to a real `setTimeout` sleep. */
+    sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * Classifies one measurement against the benchmark's best-so-far and folds it
+ * into the state. Pure apart from mutating `state`.
+ *
+ * Returns whether the sample was kept. A throttled sample (more than
+ * `throttleThreshold` slower than the best) is recorded in `throttledMs` and
+ * doesn't count toward convergence — it says something about the device's
+ * temperature, not the kernel.
+ */
+export declare function recordSample(state: SampleState, ms: number, cfg: Required<SamplingConfig>): boolean;
+/**
+ * Whether the measurements taken in one round add up to "the device is
+ * throttled". Thermal throttling slows every kernel, so the signal is
+ * agreement across benchmarks: at least two of them, and at least
+ * `throttledFraction` of the round. One benchmark repeatedly coming in slow
+ * while the rest are fine is that benchmark's own noise (Safari's
+ * wall-clock timing of the write-bandwidth kernel jitters 15–40%), not
+ * heat — pausing the suite for it would just waste time.
+ */
+export declare function roundIsThrottled(roundThrottled: readonly boolean[], cfg: Required<SamplingConfig>): boolean;
+/**
+ * Round-robin, best-of-N sampling across many benchmarks.
+ *
+ * Rather than running each benchmark to convergence before starting the
+ * next (which heats a phone up in seconds and leaves every later benchmark
+ * measuring a throttled GPU), every round takes one short measurement of
+ * every still-active benchmark, with an idle gap between measurements so
+ * the GPU duty-cycles. Benchmarks retire as soon as their best run has
+ * stopped improving (`isBestStable`). Measurements that come in well slower
+ * than a benchmark's best are discarded as throttled; when a round shows
+ * the device throttled overall — half the benchmarks slow, or any one slow
+ * twice running — the whole suite pauses for `cooldownMs` and tries again,
+ * up to `maxCooldowns` times, after which whatever is still unconverged is
+ * reported with `stopReason: 'throttled'` alongside its best run so far.
+ *
+ * Only the best run is the headline number: every noise source makes runs
+ * slower, never faster, so the minimum is the most robust estimate of what
+ * the device can do.
+ */
+export declare function runSampling(benchmarks: readonly Sampleable[], options?: RunSamplingOptions): Promise<Map<string, SampleStateSnapshot>>;
+export declare function resolveSamplingConfig(cfg: SamplingConfig): Required<SamplingConfig>;
+//# sourceMappingURL=sampling.d.ts.map

package/dist/sampling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.d.ts","sourceRoot":"","sources":["../src/sampling.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhF,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAC7B,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qIAAqI;IACrI,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iGAAiG;IACjG,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mFAAmF;IACnF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uHAAuH;IACvH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,cAAc,CAUrD,CAAC;AAEF,sFAAsF;AACtF,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,iFAAiF;IACjF,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,gDAAgD;IAChD,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3B;AAED,4GAA4G;AAC5G,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,yCAAyC;IACzC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,2DAA2D;IAC3D,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,kBAAkB,CAAC;IAChC,2EAA2E;IAC3E,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IACxD,oGAAoG;IACpG,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChE,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAC;IACjD,mEAAmE;IACnE,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAmDD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,CAAC,cAAc,CAAC,GAAG,OAAO,CAsBnG;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,SAAS,OAAO,EAAE,EAAE,GAAG,EAAE,QAAQ,CAAC,cAAc,CAAC,GAAG,OAAO,CAG3G;AAoBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,WAAW,CAC/B,UAAU,EAAE,SAAS,UAAU,EAAE,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAqF3C;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,cAAc,GAAG,QAAQ,CAAC,cAAc,CAAC,CAanF"}

package/dist/sampling.js

@@ -0,0 +1,239 @@
+import { computeStats, isBestStable, isThrottled } from "./stats.js";
+export const DEFAULT_SAMPLING = {
+    minRounds: 3,
+    maxRounds: 10,
+    stableRounds: 2,
+    improvementTolerance: 0.01,
+    throttleThreshold: 0.2,
+    idleMs: 100,
+    cooldownMs: 3000,
+    maxCooldowns: 3,
+    throttledFraction: 0.5,
+};
+const isActive = (s) => s.stopReason === undefined && s.error === undefined;
+/**
+ * The idle gap doubles as the UI's render window: after the timer, wait for
+ * the main thread to go idle (table re-render committed, its paint queued)
+ * so the compositor's GPU work lands here rather than inside the next
+ * measurement. Falls back to a plain timer where `requestIdleCallback` is
+ * missing; the timeout bounds the wait on a busy page.
+ */
+const realSleep = (ms) => new Promise((resolve) => setTimeout(() => {
+    if (typeof requestIdleCallback === 'function')
+        requestIdleCallback(() => resolve(), { timeout: 1000 });
+    else
+        resolve();
+}, ms));
+/**
+ * A backgrounded tab gets a throttled event loop and a lower-priority GPU
+ * queue, so nothing measured while hidden is a property of the device.
+ * `waitVisible` blocks until the page is showing; `hiddenSince` reports
+ * whether it went hidden at any point after the last `mark()`.
+ */
+function visibilityGuard() {
+    const doc = typeof document === 'undefined' ? undefined : document;
+    let hidden = false;
+    const onChange = () => {
+        if (doc?.hidden)
+            hidden = true;
+    };
+    doc?.addEventListener('visibilitychange', onChange);
+    return {
+        mark: () => {
+            hidden = Boolean(doc?.hidden);
+        },
+        hiddenSince: () => hidden || Boolean(doc?.hidden),
+        waitVisible: () => new Promise((resolve) => {
+            if (!doc?.hidden)
+                return resolve();
+            const onVisible = () => {
+                if (doc.hidden)
+                    return;
+                doc.removeEventListener('visibilitychange', onVisible);
+                resolve();
+            };
+            doc.addEventListener('visibilitychange', onVisible);
+        }),
+        dispose: () => doc?.removeEventListener('visibilitychange', onChange),
+    };
+}
+/**
+ * Classifies one measurement against the benchmark's best-so-far and folds it
+ * into the state. Pure apart from mutating `state`.
+ *
+ * Returns whether the sample was kept. A throttled sample (more than
+ * `throttleThreshold` slower than the best) is recorded in `throttledMs` and
+ * doesn't count toward convergence — it says something about the device's
+ * temperature, not the kernel.
+ */
+export function recordSample(state, ms, cfg) {
+    if (isThrottled(ms, state.bestMs, cfg.throttleThreshold)) {
+        state.throttledMs.push(ms);
+        // A benchmark that keeps coming back throttled while the rest of the
+        // suite is fine (so no cooldown fires) must still terminate.
+        if (state.timesMs.length + state.throttledMs.length >= 2 * cfg.maxRounds)
+            state.stopReason = 'max-rounds';
+        return false;
+    }
+    state.timesMs.push(ms);
+    if (ms < state.bestMs)
+        state.bestMs = ms;
+    if (isBestStable(state.timesMs, {
+        minRuns: cfg.minRounds,
+        stableRuns: cfg.stableRounds,
+        tolerance: cfg.improvementTolerance,
+    })) {
+        state.stopReason = 'converged';
+    }
+    else if (state.timesMs.length >= cfg.maxRounds) {
+        state.stopReason = 'max-rounds';
+    }
+    return true;
+}
+/**
+ * Whether the measurements taken in one round add up to "the device is
+ * throttled". Thermal throttling slows every kernel, so the signal is
+ * agreement across benchmarks: at least two of them, and at least
+ * `throttledFraction` of the round. One benchmark repeatedly coming in slow
+ * while the rest are fine is that benchmark's own noise (Safari's
+ * wall-clock timing of the write-bandwidth kernel jitters 15–40%), not
+ * heat — pausing the suite for it would just waste time.
+ */
+export function roundIsThrottled(roundThrottled, cfg) {
+    const throttledCount = roundThrottled.filter(Boolean).length;
+    return throttledCount >= 2 && throttledCount / roundThrottled.length >= cfg.throttledFraction;
+}
+/** In-place Fisher-Yates. */
+function shuffle(items) {
+    for (let i = items.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [items[i], items[j]] = [items[j], items[i]];
+    }
+    return items;
+}
+function snapshot(state) {
+    return {
+        ...state,
+        timesMs: [...state.timesMs],
+        throttledMs: [...state.throttledMs],
+        stats: state.timesMs.length > 0 ? computeStats(state.timesMs) : undefined,
+    };
+}
+/**
+ * Round-robin, best-of-N sampling across many benchmarks.
+ *
+ * Rather than running each benchmark to convergence before starting the
+ * next (which heats a phone up in seconds and leaves every later benchmark
+ * measuring a throttled GPU), every round takes one short measurement of
+ * every still-active benchmark, with an idle gap between measurements so
+ * the GPU duty-cycles. Benchmarks retire as soon as their best run has
+ * stopped improving (`isBestStable`). Measurements that come in well slower
+ * than a benchmark's best are discarded as throttled; when a round shows
+ * the device throttled overall — half the benchmarks slow, or any one slow
+ * twice running — the whole suite pauses for `cooldownMs` and tries again,
+ * up to `maxCooldowns` times, after which whatever is still unconverged is
+ * reported with `stopReason: 'throttled'` alongside its best run so far.
+ *
+ * Only the best run is the headline number: every noise source makes runs
+ * slower, never faster, so the minimum is the most robust estimate of what
+ * the device can do.
+ */
+export async function runSampling(benchmarks, options = {}) {
+    const cfg = resolveSamplingConfig(options);
+    const sleep = options.sleep ?? realSleep;
+    const onUpdate = options.onUpdate ?? (() => { });
+    const onProgress = options.onProgress ?? (() => { });
+    const states = new Map();
+    const samplers = new Map();
+    for (const b of benchmarks) {
+        states.set(b.id, { id: b.id, timesMs: [], throttledMs: [], bestMs: Number.POSITIVE_INFINITY });
+        samplers.set(b.id, b);
+    }
+    const visibility = visibilityGuard();
+    let cooldowns = 0;
+    let calibrated = false;
+    try {
+        for (let round = 1;; round++) {
+            // Fresh order every round: a fixed order would hand the same kernels
+            // the cool GPU every time and leave the rest measuring a warm one.
+            const active = shuffle([...states.values()].filter(isActive));
+            if (active.length === 0)
+                break;
+            onProgress({ type: 'round', round, active: active.length });
+            const roundStates = [];
+            const roundThrottled = [];
+            let first = true;
+            for (const state of active) {
+                const sampler = samplers.get(state.id);
+                try {
+                    if (!first && cfg.idleMs > 0)
+                        await sleep(cfg.idleMs);
+                    first = false;
+                    await visibility.waitVisible();
+                    visibility.mark();
+                    if (!calibrated)
+                        await sampler.calibrate();
+                    const ms = await sampler.sample();
+                    // Hidden at any point during the measurement: not a device number. Drop it and retry next round.
+                    if (visibility.hiddenSince())
+                        continue;
+                    if (!Number.isFinite(ms) || ms <= 0) {
+                        throw new Error(`measured a per-op time of ${ms}ms — the GPU pass likely did no work (check for an 'uncapturederror' in the console).`);
+                    }
+                    const kept = recordSample(state, ms, cfg);
+                    roundStates.push(state);
+                    roundThrottled.push(!kept);
+                }
+                catch (error) {
+                    state.error = error;
+                }
+                await onUpdate(snapshot(state));
+            }
+            calibrated = true;
+            if (roundStates.length > 0 && roundIsThrottled(roundThrottled, cfg)) {
+                const throttledIds = roundStates.filter((_, i) => roundThrottled[i]).map((s) => s.id);
+                if (cooldowns >= cfg.maxCooldowns) {
+                    onProgress({ type: 'throttle-abort', throttledIds });
+                    for (const s of states.values()) {
+                        if (isActive(s)) {
+                            s.stopReason = s.timesMs.length > 0 ? 'throttled' : undefined;
+                            if (s.timesMs.length === 0) {
+                                s.error = new Error('Every measurement was discarded as throttled and the cooldown budget is exhausted.');
+                            }
+                            await onUpdate(snapshot(s));
+                        }
+                    }
+                    break;
+                }
+                cooldowns += 1;
+                onProgress({
+                    type: 'cooldown',
+                    attempt: cooldowns,
+                    maxAttempts: cfg.maxCooldowns,
+                    ms: cfg.cooldownMs,
+                    throttledIds,
+                });
+                await sleep(cfg.cooldownMs);
+            }
+        }
+    }
+    finally {
+        visibility.dispose();
+    }
+    return new Map([...states].map(([id, s]) => [id, snapshot(s)]));
+}
+export function resolveSamplingConfig(cfg) {
+    const minRounds = Math.max(1, cfg.minRounds ?? DEFAULT_SAMPLING.minRounds);
+    return {
+        minRounds,
+        maxRounds: Math.max(minRounds, cfg.maxRounds ?? DEFAULT_SAMPLING.maxRounds),
+        stableRounds: Math.max(1, cfg.stableRounds ?? DEFAULT_SAMPLING.stableRounds),
+        improvementTolerance: cfg.improvementTolerance ?? DEFAULT_SAMPLING.improvementTolerance,
+        throttleThreshold: cfg.throttleThreshold ?? DEFAULT_SAMPLING.throttleThreshold,
+        idleMs: cfg.idleMs ?? DEFAULT_SAMPLING.idleMs,
+        cooldownMs: cfg.cooldownMs ?? DEFAULT_SAMPLING.cooldownMs,
+        maxCooldowns: cfg.maxCooldowns ?? DEFAULT_SAMPLING.maxCooldowns,
+        throttledFraction: cfg.throttledFraction ?? DEFAULT_SAMPLING.throttledFraction,
+    };
+}
+//# sourceMappingURL=sampling.js.map

package/dist/sampling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.js","sourceRoot":"","sources":["../src/sampling.ts"],"names":[],"mappings":"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"}

package/dist/shaders/flopsF16Mat4.d.ts

@@ -0,0 +1,7 @@
+/**
+ * fp16 mat4 FLOPS probe — {@link flopsF32Mat4Wgsl}'s bounded
+ * `x = m * x + c` recurrence, but `m`, `c`, and `x` are all `f16`, so the
+ * mat4x4 * vec4 multiply runs entirely in half precision.
+ */
+export declare const flopsF16Mat4Wgsl = "\nenable f16;\n\nstruct Params {\n  threads: u32,\n  iterations: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read_write> out: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= params.threads) {\n    return;\n  }\n  let s: f16 = f16(idx & 15u) * f16(0.001) + f16(0.001);\n  let one: f16 = f16(1.0);\n  let three_s: f16 = f16(3.0) * s;\n  let m: mat4x4<f16> = mat4x4<f16>(\n    vec4<f16>(one - three_s, s, s, s),\n    vec4<f16>(s, one - three_s, s, s),\n    vec4<f16>(s, s, one - three_s, s),\n    vec4<f16>(s, s, s, one - three_s),\n  );\n  let c: vec4<f16> = vec4<f16>(s, s, s, s);\n  var x: vec4<f16> = vec4<f16>(f16(idx & 255u) * f16(0.0001));\n  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {\n    x = m * x + c;\n  }\n  out[idx] = f32(x.x + x.y + x.z + x.w);\n}\n";
+//# sourceMappingURL=flopsF16Mat4.d.ts.map

package/dist/shaders/flopsF16Mat4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF16Mat4.d.ts","sourceRoot":"","sources":["../../src/shaders/flopsF16Mat4.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,65BAiC5B,CAAC"}

package/dist/shaders/flopsF16Mat4.js

@@ -0,0 +1,40 @@
+/**
+ * fp16 mat4 FLOPS probe — {@link flopsF32Mat4Wgsl}'s bounded
+ * `x = m * x + c` recurrence, but `m`, `c`, and `x` are all `f16`, so the
+ * mat4x4 * vec4 multiply runs entirely in half precision.
+ */
+export const flopsF16Mat4Wgsl = /* wgsl */ `
+enable f16;
+
+struct Params {
+  threads: u32,
+  iterations: u32,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.threads) {
+    return;
+  }
+  let s: f16 = f16(idx & 15u) * f16(0.001) + f16(0.001);
+  let one: f16 = f16(1.0);
+  let three_s: f16 = f16(3.0) * s;
+  let m: mat4x4<f16> = mat4x4<f16>(
+    vec4<f16>(one - three_s, s, s, s),
+    vec4<f16>(s, one - three_s, s, s),
+    vec4<f16>(s, s, one - three_s, s),
+    vec4<f16>(s, s, s, one - three_s),
+  );
+  let c: vec4<f16> = vec4<f16>(s, s, s, s);
+  var x: vec4<f16> = vec4<f16>(f16(idx & 255u) * f16(0.0001));
+  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {
+    x = m * x + c;
+  }
+  out[idx] = f32(x.x + x.y + x.z + x.w);
+}
+`;
+//# sourceMappingURL=flopsF16Mat4.js.map

package/dist/shaders/flopsF16Mat4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF16Mat4.js","sourceRoot":"","sources":["../../src/shaders/flopsF16Mat4.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC1C,CAAC"}

package/dist/shaders/flopsF16Matvec.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Register-resident matvec tile, entirely in fp16: a 4-row x 8-column weight tile held in
+ * registers (8 x vec4<f16>, hashed from the thread id so every thread has a
+ * different tile), applied to an 8-wide input vector every iteration. Each
+ * output row is two 4-wide dot() calls; the 4 outputs then become the next
+ * 4 input lanes (the other 4 shift over), so the loop is genuinely
+ * loop-carried and can't be hoisted. This is the same dot-product-and-
+ * accumulate shape as a real matvec/GEMV inner loop, but with no storage
+ * buffer traffic at all: it isolates how fast this dtype's dot products run
+ * on the ALU once bandwidth is out of the picture. 32 MACs (64 FLOPs) per
+ * loop iteration.
+ */
+export declare const flopsF16MatvecWgsl = "\nenable f16;\n\nstruct Params {\n  threads: u32,\n  iterations: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read_write> out: array<f32>;\n\n// Same weight hash as the fp32 kernel, but producing vec4<f16>.\nfn weights(seed: u32) -> vec4<f16> {\n  let h = seed * 0x9e3779b1u;\n  let bytes = vec4<u32>(h & 0xffu, (h >> 8u) & 0xffu, (h >> 16u) & 0xffu, h >> 24u);\n  return (vec4<f16>(bytes) - vec4<f16>(127.5)) * f16(1.0 / 4096.0);\n}\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= params.threads) {\n    return;\n  }\n  let w00: vec4<f16> = weights(idx * 8u + 1u);\n  let w01: vec4<f16> = weights(idx * 8u + 2u);\n  let w10: vec4<f16> = weights(idx * 8u + 3u);\n  let w11: vec4<f16> = weights(idx * 8u + 4u);\n  let w20: vec4<f16> = weights(idx * 8u + 5u);\n  let w21: vec4<f16> = weights(idx * 8u + 6u);\n  let w30: vec4<f16> = weights(idx * 8u + 7u);\n  let w31: vec4<f16> = weights(idx * 8u + 8u);\n  var x0: vec4<f16> = vec4<f16>(f16(idx & 255u) * f16(0.001) + f16(0.1), f16(0.2), f16(0.3), f16(0.4));\n  var x1: vec4<f16> = vec4<f16>(f16(idx & 255u) * f16(0.001) + f16(0.2), f16(0.4), f16(0.6), f16(0.8));\n  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {\n    let o0 = dot(w00, x0) + dot(w01, x1);\n    let o1 = dot(w10, x0) + dot(w11, x1);\n    let o2 = dot(w20, x0) + dot(w21, x1);\n    let o3 = dot(w30, x0) + dot(w31, x1);\n    x0 = x1;\n    x1 = vec4<f16>(o0, o1, o2, o3);\n  }\n  out[idx] = f32(x0.x + x0.y + x0.z + x0.w + x1.x + x1.y + x1.z + x1.w);\n}\n";
+//# sourceMappingURL=flopsF16Matvec.d.ts.map

package/dist/shaders/flopsF16Matvec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF16Matvec.d.ts","sourceRoot":"","sources":["../../src/shaders/flopsF16Matvec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,+kDA4C9B,CAAC"}

package/dist/shaders/flopsF16Matvec.js

@@ -0,0 +1,58 @@
+/**
+ * Register-resident matvec tile, entirely in fp16: a 4-row x 8-column weight tile held in
+ * registers (8 x vec4<f16>, hashed from the thread id so every thread has a
+ * different tile), applied to an 8-wide input vector every iteration. Each
+ * output row is two 4-wide dot() calls; the 4 outputs then become the next
+ * 4 input lanes (the other 4 shift over), so the loop is genuinely
+ * loop-carried and can't be hoisted. This is the same dot-product-and-
+ * accumulate shape as a real matvec/GEMV inner loop, but with no storage
+ * buffer traffic at all: it isolates how fast this dtype's dot products run
+ * on the ALU once bandwidth is out of the picture. 32 MACs (64 FLOPs) per
+ * loop iteration.
+ */
+export const flopsF16MatvecWgsl = /* wgsl */ `
+enable f16;
+
+struct Params {
+  threads: u32,
+  iterations: u32,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+// Same weight hash as the fp32 kernel, but producing vec4<f16>.
+fn weights(seed: u32) -> vec4<f16> {
+  let h = seed * 0x9e3779b1u;
+  let bytes = vec4<u32>(h & 0xffu, (h >> 8u) & 0xffu, (h >> 16u) & 0xffu, h >> 24u);
+  return (vec4<f16>(bytes) - vec4<f16>(127.5)) * f16(1.0 / 4096.0);
+}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.threads) {
+    return;
+  }
+  let w00: vec4<f16> = weights(idx * 8u + 1u);
+  let w01: vec4<f16> = weights(idx * 8u + 2u);
+  let w10: vec4<f16> = weights(idx * 8u + 3u);
+  let w11: vec4<f16> = weights(idx * 8u + 4u);
+  let w20: vec4<f16> = weights(idx * 8u + 5u);
+  let w21: vec4<f16> = weights(idx * 8u + 6u);
+  let w30: vec4<f16> = weights(idx * 8u + 7u);
+  let w31: vec4<f16> = weights(idx * 8u + 8u);
+  var x0: vec4<f16> = vec4<f16>(f16(idx & 255u) * f16(0.001) + f16(0.1), f16(0.2), f16(0.3), f16(0.4));
+  var x1: vec4<f16> = vec4<f16>(f16(idx & 255u) * f16(0.001) + f16(0.2), f16(0.4), f16(0.6), f16(0.8));
+  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {
+    let o0 = dot(w00, x0) + dot(w01, x1);
+    let o1 = dot(w10, x0) + dot(w11, x1);
+    let o2 = dot(w20, x0) + dot(w21, x1);
+    let o3 = dot(w30, x0) + dot(w31, x1);
+    x0 = x1;
+    x1 = vec4<f16>(o0, o1, o2, o3);
+  }
+  out[idx] = f32(x0.x + x0.y + x0.z + x0.w + x1.x + x1.y + x1.z + x1.w);
+}
+`;
+//# sourceMappingURL=flopsF16Matvec.js.map

package/dist/shaders/flopsF16Matvec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF16Matvec.js","sourceRoot":"","sources":["../../src/shaders/flopsF16Matvec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4C5C,CAAC"}

package/dist/shaders/flopsF16Scalar.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Raw fp16 FLOPS probe — same shape as {@link flopsF32ScalarWgsl} (eight
+ * independent chains, unrolled 4x), but every operand and accumulator is
+ * `f16`, so the FMA chains run entirely in half precision (only the final
+ * store converts back to f32). 64 FLOPs per loop iteration.
+ */
+export declare const flopsF16ScalarWgsl = "\nenable f16;\n\nstruct Params {\n  threads: u32,\n  iterations: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read_write> out: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= params.threads) {\n    return;\n  }\n  let a: f16 = f16(1.0) - f16(idx & 15u) * f16(0.001);\n  let b: f16 = f16(0.5) + f16(idx & 7u) * f16(0.001);\n  var x0: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.01);\n  var x1: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.02);\n  var x2: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.03);\n  var x3: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.04);\n  var x4: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.05);\n  var x5: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.06);\n  var x6: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.07);\n  var x7: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.08);\n  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {\n    x0 = x0 * a + b;\n    x1 = x1 * a + b;\n    x2 = x2 * a + b;\n    x3 = x3 * a + b;\n    x4 = x4 * a + b;\n    x5 = x5 * a + b;\n    x6 = x6 * a + b;\n    x7 = x7 * a + b;\n    x0 = x0 * a + b;\n    x1 = x1 * a + b;\n    x2 = x2 * a + b;\n    x3 = x3 * a + b;\n    x4 = x4 * a + b;\n    x5 = x5 * a + b;\n    x6 = x6 * a + b;\n    x7 = x7 * a + b;\n    x0 = x0 * a + b;\n    x1 = x1 * a + b;\n    x2 = x2 * a + b;\n    x3 = x3 * a + b;\n    x4 = x4 * a + b;\n    x5 = x5 * a + b;\n    x6 = x6 * a + b;\n    x7 = x7 * a + b;\n    x0 = x0 * a + b;\n    x1 = x1 * a + b;\n    x2 = x2 * a + b;\n    x3 = x3 * a + b;\n    x4 = x4 * a + b;\n    x5 = x5 * a + b;\n    x6 = x6 * a + b;\n    x7 = x7 * a + b;\n  }\n  out[idx] = f32(x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7);\n}\n";
+//# sourceMappingURL=flopsF16Scalar.d.ts.map

package/dist/shaders/flopsF16Scalar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF16Scalar.d.ts","sourceRoot":"","sources":["../../src/shaders/flopsF16Scalar.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,svDA+D9B,CAAC"}

package/dist/shaders/flopsF16Scalar.js

@@ -0,0 +1,71 @@
+/**
+ * Raw fp16 FLOPS probe — same shape as {@link flopsF32ScalarWgsl} (eight
+ * independent chains, unrolled 4x), but every operand and accumulator is
+ * `f16`, so the FMA chains run entirely in half precision (only the final
+ * store converts back to f32). 64 FLOPs per loop iteration.
+ */
+export const flopsF16ScalarWgsl = /* wgsl */ `
+enable f16;
+
+struct Params {
+  threads: u32,
+  iterations: u32,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.threads) {
+    return;
+  }
+  let a: f16 = f16(1.0) - f16(idx & 15u) * f16(0.001);
+  let b: f16 = f16(0.5) + f16(idx & 7u) * f16(0.001);
+  var x0: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.01);
+  var x1: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.02);
+  var x2: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.03);
+  var x3: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.04);
+  var x4: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.05);
+  var x5: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.06);
+  var x6: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.07);
+  var x7: f16 = f16(idx & 255u) * f16(0.0001) + f16(0.08);
+  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {
+    x0 = x0 * a + b;
+    x1 = x1 * a + b;
+    x2 = x2 * a + b;
+    x3 = x3 * a + b;
+    x4 = x4 * a + b;
+    x5 = x5 * a + b;
+    x6 = x6 * a + b;
+    x7 = x7 * a + b;
+    x0 = x0 * a + b;
+    x1 = x1 * a + b;
+    x2 = x2 * a + b;
+    x3 = x3 * a + b;
+    x4 = x4 * a + b;
+    x5 = x5 * a + b;
+    x6 = x6 * a + b;
+    x7 = x7 * a + b;
+    x0 = x0 * a + b;
+    x1 = x1 * a + b;
+    x2 = x2 * a + b;
+    x3 = x3 * a + b;
+    x4 = x4 * a + b;
+    x5 = x5 * a + b;
+    x6 = x6 * a + b;
+    x7 = x7 * a + b;
+    x0 = x0 * a + b;
+    x1 = x1 * a + b;
+    x2 = x2 * a + b;
+    x3 = x3 * a + b;
+    x4 = x4 * a + b;
+    x5 = x5 * a + b;
+    x6 = x6 * a + b;
+    x7 = x7 * a + b;
+  }
+  out[idx] = f32(x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7);
+}
+`;
+//# sourceMappingURL=flopsF16Scalar.js.map

package/dist/shaders/flopsF16Scalar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF16Scalar.js","sourceRoot":"","sources":["../../src/shaders/flopsF16Scalar.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+D5C,CAAC"}

package/dist/shaders/flopsF16Vec4.d.ts

@@ -0,0 +1,7 @@
+/**
+ * fp16 vec4 FLOPS probe — a single FMA chain held in a `vec4<f16>` register
+ * (4 independent half-precision lanes per step; only GPUs with packed-half
+ * ALUs run this faster than the fp32 vec4 probe).
+ */
+export declare const flopsF16Vec4Wgsl = "\nenable f16;\n\nstruct Params {\n  threads: u32,\n  iterations: u32,\n};\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read_write> out: array<f32>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  if (idx >= params.threads) {\n    return;\n  }\n  let s: f16 = f16(idx & 15u) * f16(0.001);\n  let half: f16 = f16(0.5);\n  let one: f16 = f16(1.0);\n  let a: vec4<f16> = vec4<f16>(one - s, one - f16(2.0) * s, one - f16(3.0) * s, one - f16(4.0) * s);\n  let b: vec4<f16> = vec4<f16>(half + s, half + f16(2.0) * s, half + f16(3.0) * s, half + f16(4.0) * s);\n  var x: vec4<f16> = vec4<f16>(f16(idx & 255u) * f16(0.0001));\n  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {\n    x = x * a + b;\n  }\n  out[idx] = f32(x.x + x.y + x.z + x.w);\n}\n";
+//# sourceMappingURL=flopsF16Vec4.d.ts.map

package/dist/shaders/flopsF16Vec4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF16Vec4.d.ts","sourceRoot":"","sources":["../../src/shaders/flopsF16Vec4.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,i2BA4B5B,CAAC"}

package/dist/shaders/flopsF16Vec4.js

@@ -0,0 +1,35 @@
+/**
+ * fp16 vec4 FLOPS probe — a single FMA chain held in a `vec4<f16>` register
+ * (4 independent half-precision lanes per step; only GPUs with packed-half
+ * ALUs run this faster than the fp32 vec4 probe).
+ */
+export const flopsF16Vec4Wgsl = /* wgsl */ `
+enable f16;
+
+struct Params {
+  threads: u32,
+  iterations: u32,
+};
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read_write> out: array<f32>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.threads) {
+    return;
+  }
+  let s: f16 = f16(idx & 15u) * f16(0.001);
+  let half: f16 = f16(0.5);
+  let one: f16 = f16(1.0);
+  let a: vec4<f16> = vec4<f16>(one - s, one - f16(2.0) * s, one - f16(3.0) * s, one - f16(4.0) * s);
+  let b: vec4<f16> = vec4<f16>(half + s, half + f16(2.0) * s, half + f16(3.0) * s, half + f16(4.0) * s);
+  var x: vec4<f16> = vec4<f16>(f16(idx & 255u) * f16(0.0001));
+  for (var i: u32 = 0u; i < params.iterations; i = i + 1u) {
+    x = x * a + b;
+  }
+  out[idx] = f32(x.x + x.y + x.z + x.w);
+}
+`;
+//# sourceMappingURL=flopsF16Vec4.js.map

package/dist/shaders/flopsF16Vec4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF16Vec4.js","sourceRoot":"","sources":["../../src/shaders/flopsF16Vec4.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4B1C,CAAC"}