webgpu-bench 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ben Houston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# webgpu-profiler
+
+A focused benchmark suite for the raw ceilings of a WebGPU device: memory **bandwidth** (read and write)
+and **FLOPS** (fp32, fp16, and int8, at scalar / vec4 / mat4 / register-resident-matvec granularity), run head to head in the
+browser, built on [`vgpu`](https://github.com/vercel-labs/vgpu).
+
+Run it live: click **Run benchmark suite** on the website (`packages/website`) and watch results stream
+into a table as each kernel finishes.
+
+## What it measures
+
+Every benchmark deliberately isolates a single resource — memory read, memory write, or ALU throughput —
+by keeping the other two as close to zero as the WebGPU compute model allows, rather than modeling a
+specific real-world op. That makes each number directly comparable to the device's published
+bandwidth/FLOPS specs.
+
+| Benchmark                                          | What it tests                                                                                                                                                                                                                                           |
+| -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `read-bandwidth`                                   | Streams a large buffer in via `vec4<f32>` loads folded with addition only (no multiply, one scalar written per thread) — a read-bandwidth-bound probe of peak storage-buffer read throughput                                                            |
+| `write-bandwidth`                                  | Streams computed `vec4<f32>` values out into a large buffer with no buffer reads at all — a write-bandwidth-bound probe of peak storage-buffer write throughput                                                                                         |
+| `flops-f32-scalar`                                 | Raw fp32 FLOPS: eight _independent_ scalar FMA chains per thread, unrolled 4x, so the ALU always has work in flight (a single dependent chain would measure FMA latency + loop overhead, not throughput)                                                |
+| `flops-f32-vec4`                                   | One FMA chain held in a `vec4<f32>` register. On scalar-SIMT GPUs (Apple, NVIDIA, AMD) that is 4 independent scalar FMAs per step — it measures 4-wide instruction-level parallelism, not a wider ALU                                                   |
+| `flops-f32-mat4`                                   | `x = m * x + c` chained with a `mat4x4<f32>` (a bounded contraction, so it stays numerically stable over any iteration count)                                                                                                                           |
+| `flops-f32-matvec`                                 | Register-resident matvec tile: a 4x8 f32 weight tile held in registers, applied to an 8-wide input every iteration via `dot()`, outputs feeding back as the next inputs. The dot-product-accumulate shape of a GEMV inner loop with zero buffer traffic |
+| `flops-f16-scalar` / `-vec4` / `-mat4` / `-matvec` | The same four shapes, entirely in `f16` (skipped if the device lacks `shader-f16`)                                                                                                                                                                      |
+| `flops-i8-scalar` / `-vec4` / `-mat4`              | The scalar / vec4 shapes on `i32` (WGSL has no first-class `i8` type), and a 4x4 integer matvec emulated as four `vec4<i32>` rows combined with `dot()` (WGSL has no `mat4x4<i32>`)                                                                     |
+| `flops-i8-matvec`                                  | The register-resident matvec tile with int8-range weights/inputs held unpacked as `vec4<i32>` and integer `dot()` accumulation — the no-extension int8 path                                                                                             |
+| `flops-i8-matvec-dp4a`                             | The same tile with weights/inputs kept packed four int8 lanes per `u32`, each 4-wide dot product a single `dot4I8Packed` (skipped without `packed_4x8_integer_dot_product`)                                                                             |
+| `flops-i8-dp4a`                                    | `dot4I8Packed` accumulated in a tight loop to isolate the instruction's peak throughput (skipped without the feature)                                                                                                                                   |
+
+The two bandwidth benchmarks stream the same deterministically-generated buffer (default 4096 &times;
+4096 f32, padded to a multiple of 4). The raw-FLOPS kernels' loop trip count and per-lane operands are
+runtime values (derived from a uniform and the thread id), so the shader compiler can't constant-fold or
+hoist the FMA chain away. Each kernel has its own ceiling on the trip count (256 for the unrolled scalar
+chains, 512 for the matvec tiles, 1024 otherwise); the actual count is calibrated per GPU so a single
+dispatch takes ~10ms (see below), which keeps per-thread setup, the final store, and dispatch overhead
+negligible without ever freezing the display. `computeIterations` pins it. The integer variants rely on i32/u32 wraparound (defined, trap-free
+two's-complement behavior in WGSL) to stay bounded instead of the float variants' damped/contraction
+operands.
+
+## How it samples (and why the number is the _best_ run)
+
+Benchmarks aren't run one after another to completion. That's the naive approach, and on a phone it
+fails in a specific way: a few seconds of saturated GPU is enough to hit thermal throttling, so every
+benchmark after the first couple measures a slowed-down device, and the numbers depend on the run
+order. Instead the suite:
+
+1. **Prepares every kernel up front** (shader compile, buffers, bind groups) so rows that can't run —
+   missing `shader-f16` / `packed_4x8_integer_dot_product`, a failed shader compile — resolve as
+   `skipped` / `error` immediately and the table has its final shape before any timing starts.
+2. **Sizes each dispatch for this GPU.** A GPU dispatch can't be preempted, so a long one freezes
+   the display for its whole duration. The raw-FLOPS kernels' loop trip count is therefore not fixed:
+   on its first visit each kernel is probed with a tiny trip count (16) and ramped up — never more than
+   4x per step — until one dispatch takes about `targetDispatchMs` (10ms), capped at the kernel's own
+   default (256–1024). A desktop lands near the cap; a phone lands on a much smaller count; neither
+   ever runs a dispatch longer than a few tens of ms, even during calibration. `computeIterations`
+   pins the count and disables this.
+3. **Samples round-robin, in a fresh random order each round.** Each round takes one short timed measurement (~100ms, `targetMs`: a batch
+   of those ~10ms dispatches in one command buffer) of every still-active kernel, with an idle gap
+   (`idleMs`, 100ms) between measurements so the GPU duty-cycles instead of running flat out. The
+   calibration probes double as warm-up; one further discarded warmup measurement (`warmups`) follows.
+4. **Reports the best run.** Every noise source a benchmark meets — throttling, clock ramp, compositor
+   frames, other apps — only ever makes a run _slower_, so the minimum is the least-contaminated
+   estimate of the device's capability. Throughput/bandwidth are derived from `stats.min`; the table
+   updates after every measurement and its numbers only ever improve.
+5. **Converges when the best stops improving.** A kernel retires once it has at least `minRounds` (3)
+   kept measurements and its best hasn't improved by more than `improvementTolerance` (1%) over the
+   last `stableRounds` (2) of them. On a cool GPU that's 3 measurements per kernel; a GPU still
+   ramping its clock keeps sampling, up to `maxRounds` (10, flagged `max-rounds`).
+6. **Discards throttled runs.** A measurement more than `throttleThreshold` (20%) slower than that
+   kernel's best is thermal noise, not information: it's recorded in `throttledMs` for diagnostics
+   but never feeds `stats` or convergence.
+7. **Pauses the whole suite when the device is throttling.** If half the kernels in a round come back
+   throttled (`throttledFraction`, at least two of them), the suite sleeps
+   for `cooldownMs` (3s) and tries again — throttling recovers, so a later round can still beat the
+   current best. After `maxCooldowns` (3) pauses it gives up: whatever is still unconverged is
+   reported with its best run so far and `stopReason: 'throttled'` (shown as a warning in the table).
+
+`onProgress` reports round boundaries and cooldowns; all of the knobs above are `SuiteOptions`.
+GPU timing uses `timestamp-query` when available (pure device-side time, no CPU/driver overhead);
+otherwise it falls back to wall-clock around `queue.onSubmittedWorkDone()`. "Available" is checked, not
+trusted: every timestamp reading is compared with wall clock (minus the fixed submit/readback overhead,
+measured with empty submits at calibration) and a kernel is demoted to wall-clock timing once the GPU
+reading comes in under half of that twice running. Safari needs this — outside a cross-origin-isolated
+context its timestamps are quantized to the point of reporting ~1ms for a 70ms batch — and all batch
+sizing uses wall clock regardless, since a batch sized from a bogus timestamp is a multi-second command
+buffer that hangs the GPU process. Two further hygiene rules: a measurement during which the tab was
+hidden is dropped (background tabs get a throttled event loop and a lower-priority GPU queue) and the
+suite waits for the page to be visible again; and the idle gap between measurements ends on
+`requestIdleCallback`, so the results table's re-render and the compositor frame it triggers land in the
+gap rather than inside the next measurement. Mean / median / stddev /
+ci95 over the kept runs are still in `BenchmarkResult.stats` if you want a sustained number — the
+table just shows the best.
+
+## Monorepo layout
+
+- `packages/webgpu-bench` — the benchmark suite itself (WGSL shaders, data generation, timing
+  harness, orchestration). Framework-agnostic, browser-only, consumed as TypeScript source.
+- `packages/website` — TanStack Start + Tailwind CSS + shadcn/ui app that runs the suite client-side and
+  renders results incrementally. Dev server on **port 3500**.
+
+## Development
+
+```bash
+pnpm install
+pnpm dev        # starts the website on http://localhost:3500
+pnpm build      # typecheck webgpu-bench + build the website
+pnpm lint
+pnpm tsc
+```
+
+Requires a WebGPU-capable browser (recent Chrome/Edge desktop). `f16`/`int8`-dot-product benchmarks report
+themselves as "skipped" with an explanation when the browser/GPU doesn't support the underlying WebGPU
+feature, rather than failing the whole run.
+
+## Deployment
+
+`packages/website/Dockerfile` builds the whole workspace and serves the TanStack Start (Nitro) production
+server on port 3500. `.github/workflows/deploy.yml` deploys it to Cloud Run on push to `main` (reuses the
+generic `deploy-service.yml` workflow).

package/dist/benchmarks/common.d.ts

@@ -0,0 +1,71 @@
+import type { GpuContext } from '../gpu/context.ts';
+import type { KernelHarness, MeasurementConfig, WorkKnob } from '../gpu/benchmarkRunner.ts';
+import type { BenchmarkCategory, BenchmarkResult, MetricDef } from '../types.ts';
+/** Shared metric definitions. `key` is what a JSON export would key the value by, stable across every benchmark that reports it. */
+export declare const FLOPS_METRIC: MetricDef;
+export declare const OPS_METRIC: MetricDef;
+export declare const BYTES_METRIC: MetricDef;
+/**
+ * Compiles a shader module and builds a compute pipeline from it, watching
+ * for validation errors via error scopes rather than trusting the WebGPU
+ * calls to throw. Both `createShaderModule` and `createComputePipeline`
+ * (`'auto'` layout) succeed synchronously even when the WGSL fails to
+ * compile or the pipeline is otherwise invalid — the failure only surfaces
+ * later as a device-level 'uncapturederror' when something dispatches
+ * against it. Left unchecked, that means the compute pass silently does
+ * nothing: the command buffer still submits and completes almost
+ * instantly, so a GPU-timestamp read of a never-touched, zero-initialized
+ * query buffer comes back as exactly 0ns elapsed — reported as a
+ * misleadingly "ok" benchmark result with 0s timings, rather than the
+ * shader-compile failure it actually is.
+ */
+export declare function createPipeline(device: GPUDevice, label: string, code: string, constants?: Record<string, number>): Promise<GPUComputePipeline>;
+/** `<metric.unit>/s`, from the amount of that unit moved/computed in one op and that op's best time. */
+export declare function metricPerSecond(amountPerOp: number, perOpMs: number): number;
+/** Per-measurement knobs (`targetMs`, `targetDispatchMs`, `warmups`) shared by every benchmark. */
+export type HarnessConfig = MeasurementConfig;
+/** Everything about a benchmark that's known before it's measured. */
+export interface BenchmarkMeta {
+    id: string;
+    label: string;
+    description: string;
+    /** WGSL source of the kernel, for display alongside the result. */
+    source: string;
+    category: BenchmarkCategory;
+    rows: number;
+    cols: number;
+    /** What this benchmark's throughput number counts. */
+    metric: MetricDef;
+    /** Amount of `metric.unit` moved/computed per op. */
+    amountPerOp: number;
+}
+/**
+ * A benchmark whose GPU resources are built and which is ready to be
+ * measured by the scheduler, or one that has already resolved to a
+ * `skipped` row (missing device feature).
+ */
+export type PreparedBenchmark = {
+    kind: 'kernel';
+    meta: BenchmarkMeta;
+    harness: KernelHarness;
+    /** For kernels with a work knob: the metadata (problem size, FLOPs, bytes per op) at a given work setting. */
+    metaAtWork?: (work: number) => BenchmarkMeta;
+} | {
+    kind: 'skipped';
+    result: BenchmarkResult;
+};
+export interface PrepareKernelOptions extends HarnessConfig, BenchmarkMeta {
+    ctx: GpuContext;
+    workgroupsPerIteration: [number, number, number];
+    pipeline: GPUComputePipeline;
+    bindGroup: GPUBindGroup;
+    work?: WorkKnob;
+    metaAtWork?: (work: number) => BenchmarkMeta;
+}
+/** Packages a built pipeline/bind group as a kernel the sampling scheduler can measure. */
+export declare function prepareKernelBenchmark(opts: PrepareKernelOptions): PreparedBenchmark;
+export declare function skippedResult(meta: BenchmarkMeta, message: string): BenchmarkResult;
+export declare function errorResult(meta: BenchmarkMeta, error: unknown): BenchmarkResult;
+/** A blank row for a benchmark: identity + problem size, no timings yet. */
+export declare function rowFromMeta(meta: BenchmarkMeta): BenchmarkResult;
+//# sourceMappingURL=common.d.ts.map

package/dist/benchmarks/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/benchmarks/common.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC5F,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEjF,oIAAoI;AACpI,eAAO,MAAM,YAAY,EAAE,SAAsE,CAAC;AAClG,eAAO,MAAM,UAAU,EAAE,SAA0D,CAAC;AACpF,eAAO,MAAM,YAAY,EAAE,SAA0D,CAAC;AAEtF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,OAAO,CAAC,kBAAkB,CAAC,CAa7B;AAED,wGAAwG;AACxG,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,mGAAmG;AACnG,MAAM,MAAM,aAAa,GAAG,iBAAiB,CAAC;AAE9C,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,MAAM,EAAE,SAAS,CAAC;IAClB,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GACzB;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,aAAa,CAAC;IACvB,8GAA8G;IAC9G,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,aAAa,CAAC;CAC9C,GACD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,CAAC;AAEjD,MAAM,WAAW,oBAAqB,SAAQ,aAAa,EAAE,aAAa;IACxE,GAAG,EAAE,UAAU,CAAC;IAChB,sBAAsB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACjD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,SAAS,EAAE,YAAY,CAAC;IACxB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,aAAa,CAAC;CAC9C;AAED,2FAA2F;AAC3F,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,GAAG,iBAAiB,CAiCpF;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,GAAG,eAAe,CAMnF;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,GAAG,eAAe,CAMhF;AAED,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa,GAAG,eAAe,CAgBhE"}

package/dist/benchmarks/common.js

@@ -0,0 +1,104 @@
+/** Shared metric definitions. `key` is what a JSON export would key the value by, stable across every benchmark that reports it. */
+export const FLOPS_METRIC = { key: 'flops', unit: 'FLOP', name: 'Floating-point ops' };
+export const OPS_METRIC = { key: 'ops', unit: 'OP', name: 'Operations' };
+export const BYTES_METRIC = { key: 'bytes', unit: 'B', name: 'Bandwidth' };
+/**
+ * Compiles a shader module and builds a compute pipeline from it, watching
+ * for validation errors via error scopes rather than trusting the WebGPU
+ * calls to throw. Both `createShaderModule` and `createComputePipeline`
+ * (`'auto'` layout) succeed synchronously even when the WGSL fails to
+ * compile or the pipeline is otherwise invalid — the failure only surfaces
+ * later as a device-level 'uncapturederror' when something dispatches
+ * against it. Left unchecked, that means the compute pass silently does
+ * nothing: the command buffer still submits and completes almost
+ * instantly, so a GPU-timestamp read of a never-touched, zero-initialized
+ * query buffer comes back as exactly 0ns elapsed — reported as a
+ * misleadingly "ok" benchmark result with 0s timings, rather than the
+ * shader-compile failure it actually is.
+ */
+export async function createPipeline(device, label, code, constants) {
+    device.pushErrorScope('validation');
+    const module = device.createShaderModule({ label, code });
+    const pipeline = device.createComputePipeline({
+        label,
+        layout: 'auto',
+        compute: { module, entryPoint: 'main', constants },
+    });
+    const error = await device.popErrorScope();
+    if (error) {
+        throw new Error(`Failed to create pipeline "${label}": ${error.message}`);
+    }
+    return pipeline;
+}
+/** `<metric.unit>/s`, from the amount of that unit moved/computed in one op and that op's best time. */
+export function metricPerSecond(amountPerOp, perOpMs) {
+    return amountPerOp / (perOpMs / 1000);
+}
+/** Packages a built pipeline/bind group as a kernel the sampling scheduler can measure. */
+export function prepareKernelBenchmark(opts) {
+    const { ctx, pipeline, bindGroup, workgroupsPerIteration } = opts;
+    return {
+        kind: 'kernel',
+        meta: {
+            id: opts.id,
+            label: opts.label,
+            description: opts.description,
+            source: opts.source,
+            category: opts.category,
+            rows: opts.rows,
+            cols: opts.cols,
+            metric: opts.metric,
+            amountPerOp: opts.amountPerOp,
+        },
+        metaAtWork: opts.metaAtWork,
+        harness: {
+            device: ctx.device,
+            useTimestamps: ctx.info.supportsTimestampQuery,
+            targetMs: opts.targetMs,
+            targetDispatchMs: opts.targetDispatchMs,
+            warmups: opts.warmups,
+            maxIterations: opts.maxIterations,
+            work: opts.work,
+            encode: (pass, iterations) => {
+                pass.setPipeline(pipeline);
+                pass.setBindGroup(0, bindGroup);
+                for (let i = 0; i < iterations; i++) {
+                    pass.dispatchWorkgroups(...workgroupsPerIteration);
+                }
+            },
+        },
+    };
+}
+export function skippedResult(meta, message) {
+    return {
+        ...rowFromMeta(meta),
+        status: 'skipped',
+        message,
+    };
+}
+export function errorResult(meta, error) {
+    return {
+        ...rowFromMeta(meta),
+        status: 'error',
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+/** A blank row for a benchmark: identity + problem size, no timings yet. */
+export function rowFromMeta(meta) {
+    return {
+        id: meta.id,
+        label: meta.label,
+        description: meta.description,
+        source: meta.source,
+        category: meta.category,
+        status: 'running',
+        rows: meta.rows,
+        cols: meta.cols,
+        innerIterations: 0,
+        timesMs: [],
+        throttledMs: [],
+        metric: meta.metric,
+        timingMethod: 'cpu-wallclock',
+    };
+}
+//# sourceMappingURL=common.js.map

package/dist/benchmarks/common.js.map

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

package/dist/benchmarks/flopsCommon.d.ts

@@ -0,0 +1,52 @@
+import type { GpuContext } from '../gpu/context.ts';
+import { type HarnessConfig, type PreparedBenchmark } from './common.ts';
+import type { MetricDef } from '../types.ts';
+export interface FlopsKernelSpec {
+    id: string;
+    label: string;
+    description: string;
+    wgsl: string;
+    /**
+     * What this kernel's per-iteration count represents. Defaults to
+     * `FLOPS_METRIC`; kernels doing integer or bit-twiddling work (not IEEE
+     * floating-point ops) should pass `OPS_METRIC` instead.
+     */
+    metric?: MetricDef;
+    /** Amount of `metric.unit` (same MAC-as-2 convention throughout) performed per loop iteration by a single thread. */
+    flopsPerIteration: number;
+    /**
+     * Loop trip count to use when the harness doesn't override it. Kernels
+     * that do more work per iteration (unrolled chains, matvec tiles) use
+     * fewer trips so every kernel's dispatch lands in the same several-ms
+     * range — long enough that per-thread setup, the final store, and
+     * dispatch overhead are negligible next to the ALU work being measured.
+     */
+    defaultIterations?: number;
+    /**
+     * Smallest loop trip count calibration may settle on. Also the first,
+     * deliberately cheap probe a fresh device sees. Default 16.
+     */
+    minIterations?: number;
+    /** Only raw-FLOPS kernels using f16 need this; skips with an explanation if the device lacks `shader-f16`. */
+    requiresF16?: boolean;
+    /** Only the `dot4I8Packed` kernel needs this; skips with an explanation if the device lacks `packed_4x8_integer_dot_product`. */
+    requiresI8Dot?: boolean;
+}
+export interface FlopsHarnessConfig extends HarnessConfig {
+    threads?: number;
+    iterations?: number;
+}
+/**
+ * Shared runner for the raw-FLOPS "little read/write, lots of ALU" compute
+ * benchmarks: every kernel here shares the same `Params{threads,iterations}`
+ * uniform + single scalar-per-thread output buffer layout, so only the WGSL
+ * and the FLOPs-per-iteration accounting differ between them.
+ *
+ * The loop trip count is exposed to the sampler as a work knob: unless
+ * `harness.iterations` pins it, the sampler calibrates it (between
+ * `minIterations` and the kernel's default) so a single dispatch takes about
+ * `targetDispatchMs` on this particular GPU — a fixed count that's a few ms
+ * on a desktop is a display-freezing second on a phone.
+ */
+export declare function prepareFlopsBenchmark(ctx: GpuContext, spec: FlopsKernelSpec, harness?: FlopsHarnessConfig): Promise<PreparedBenchmark>;
+//# sourceMappingURL=flopsCommon.d.ts.map

package/dist/benchmarks/flopsCommon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsCommon.d.ts","sourceRoot":"","sources":["../../src/benchmarks/flopsCommon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EAML,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACvB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,qHAAqH;IACrH,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,8GAA8G;IAC9G,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iIAAiI;IACjI,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,kBAAmB,SAAQ,aAAa;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAMD;;;;;;;;;;;GAWG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,eAAe,EACrB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAmE5B"}

package/dist/benchmarks/flopsCommon.js

@@ -0,0 +1,78 @@
+import { createUniformBuffer, createEmptyStorageBuffer } from "../gpu/buffers.js";
+import { createPipeline, prepareKernelBenchmark, skippedResult, FLOPS_METRIC, } from "./common.js";
+const DEFAULT_THREADS = 1024 * 1024;
+const DEFAULT_ITERATIONS = 1024;
+const DEFAULT_MIN_ITERATIONS = 16;
+/**
+ * Shared runner for the raw-FLOPS "little read/write, lots of ALU" compute
+ * benchmarks: every kernel here shares the same `Params{threads,iterations}`
+ * uniform + single scalar-per-thread output buffer layout, so only the WGSL
+ * and the FLOPs-per-iteration accounting differ between them.
+ *
+ * The loop trip count is exposed to the sampler as a work knob: unless
+ * `harness.iterations` pins it, the sampler calibrates it (between
+ * `minIterations` and the kernel's default) so a single dispatch takes about
+ * `targetDispatchMs` on this particular GPU — a fixed count that's a few ms
+ * on a desktop is a display-freezing second on a phone.
+ */
+export async function prepareFlopsBenchmark(ctx, spec, harness = {}) {
+    const threads = harness.threads ?? DEFAULT_THREADS;
+    const maxIterations = harness.iterations ?? spec.defaultIterations ?? DEFAULT_ITERATIONS;
+    const metaAtWork = (iterations) => ({
+        id: spec.id,
+        label: spec.label,
+        description: spec.description,
+        source: spec.wgsl,
+        category: 'compute',
+        rows: threads,
+        cols: iterations,
+        metric: spec.metric ?? FLOPS_METRIC,
+        amountPerOp: threads * iterations * spec.flopsPerIteration,
+    });
+    const meta = metaAtWork(maxIterations);
+    if (spec.requiresF16 && !ctx.info.supportsF16) {
+        return {
+            kind: 'skipped',
+            result: skippedResult(meta, 'Device/browser does not support the "shader-f16" WebGPU feature.'),
+        };
+    }
+    if (spec.requiresI8Dot && !ctx.info.supportsI8Dot) {
+        return {
+            kind: 'skipped',
+            result: skippedResult(meta, 'Device/browser does not support the "packed_4x8_integer_dot_product" WebGPU feature.'),
+        };
+    }
+    const { device } = ctx;
+    const pipeline = await createPipeline(device, spec.id, spec.wgsl);
+    const paramsBuf = createUniformBuffer(device, new Uint32Array([threads, maxIterations]), 'params');
+    const outBuf = createEmptyStorageBuffer(device, threads * 4, 'out');
+    const bindGroup = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+            { binding: 0, resource: { buffer: paramsBuf } },
+            { binding: 1, resource: { buffer: outBuf } },
+        ],
+    });
+    // An explicit `iterations` pins the trip count; otherwise let the sampler size it.
+    const work = harness.iterations === undefined
+        ? {
+            min: Math.min(maxIterations, spec.minIterations ?? DEFAULT_MIN_ITERATIONS),
+            max: maxIterations,
+            apply: (iterations) => device.queue.writeBuffer(paramsBuf, 0, new Uint32Array([threads, iterations])),
+        }
+        : undefined;
+    return prepareKernelBenchmark({
+        ...meta,
+        ctx,
+        workgroupsPerIteration: [Math.ceil(threads / 64), 1, 1],
+        pipeline,
+        bindGroup,
+        work,
+        metaAtWork,
+        targetMs: harness.targetMs,
+        targetDispatchMs: harness.targetDispatchMs,
+        warmups: harness.warmups,
+        maxIterations: harness.maxIterations,
+    });
+}
+//# sourceMappingURL=flopsCommon.js.map

package/dist/benchmarks/flopsCommon.js.map

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

package/dist/benchmarks/flopsConvert.d.ts

@@ -0,0 +1,18 @@
+import type { GpuContext } from '../gpu/context.ts';
+import { type FlopsHarnessConfig } from './flopsCommon.ts';
+import type { PreparedBenchmark } from './common.ts';
+/**
+ * Bit-twiddling and type-conversion ops: what quantized/packed formats
+ * actually cost to get in and out of, as opposed to the flops-i8-* kernels
+ * (which measure compute once data is already unpacked into i32/u32
+ * registers). "Ops/s" here again isn't IEEE FLOPs, same caveat as flopsMath.ts.
+ */
+/** Manual (shift+mask) byte pack/unpack: no pack4x8 (or unpack4x8) builtin, just what those compile to. */
+export declare function prepareFlopsU32PackUnpack(ctx: GpuContext, harness?: FlopsHarnessConfig): Promise<PreparedBenchmark>;
+/** i32<->f32 round-trip: convert, FMA, convert back — the delta against the fp32 scalar test isolates conversion cost. */
+export declare function prepareFlopsI32F32Convert(ctx: GpuContext, harness?: FlopsHarnessConfig): Promise<PreparedBenchmark>;
+/** fp32<->fp16 round-trip via pack2x16float/unpack2x16float — no shader-f16 feature needed. */
+export declare function prepareFlopsF32F16Convert(ctx: GpuContext, harness?: FlopsHarnessConfig): Promise<PreparedBenchmark>;
+/** i32<->f16 round-trip, chained through f32 (there's no native int<->f16 builtin). */
+export declare function prepareFlopsI32F16Convert(ctx: GpuContext, harness?: FlopsHarnessConfig): Promise<PreparedBenchmark>;
+//# sourceMappingURL=flopsConvert.d.ts.map

package/dist/benchmarks/flopsConvert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsConvert.d.ts","sourceRoot":"","sources":["../../src/benchmarks/flopsConvert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAMlF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;;GAKG;AAEH,2GAA2G;AAC3G,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,UAAU,EACf,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAe5B;AAED,0HAA0H;AAC1H,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,UAAU,EACf,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAe5B;AAED,+FAA+F;AAC/F,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,UAAU,EACf,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAe5B;AAED,uFAAuF;AACvF,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,UAAU,EACf,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAe5B"}

package/dist/benchmarks/flopsConvert.js

@@ -0,0 +1,61 @@
+import { prepareFlopsBenchmark } from "./flopsCommon.js";
+import { flopsU32PackUnpackWgsl } from "../shaders/flopsU32PackUnpack.js";
+import { flopsI32F32ConvertWgsl } from "../shaders/flopsI32F32Convert.js";
+import { flopsF32F16ConvertWgsl } from "../shaders/flopsF32F16Convert.js";
+import { flopsI32F16ConvertWgsl } from "../shaders/flopsI32F16Convert.js";
+import { OPS_METRIC } from "./common.js";
+/**
+ * Bit-twiddling and type-conversion ops: what quantized/packed formats
+ * actually cost to get in and out of, as opposed to the flops-i8-* kernels
+ * (which measure compute once data is already unpacked into i32/u32
+ * registers). "Ops/s" here again isn't IEEE FLOPs, same caveat as flopsMath.ts.
+ */
+/** Manual (shift+mask) byte pack/unpack: no pack4x8 (or unpack4x8) builtin, just what those compile to. */
+export function prepareFlopsU32PackUnpack(ctx, harness = {}) {
+    return prepareFlopsBenchmark(ctx, {
+        id: 'flops-u32-packunpack',
+        label: 'u32 byte pack/unpack ops',
+        description: 'Eight independent u32 lanes, each step unpacking 4 bytes via shift+mask, incrementing them, and repacking the same way — no pack4x8 (or unpack4x8) builtin, just the bit-twiddling those compile to. 25 ops/lane/step, no unrolling.',
+        wgsl: flopsU32PackUnpackWgsl,
+        metric: OPS_METRIC,
+        flopsPerIteration: 200,
+        defaultIterations: 256,
+    }, harness);
+}
+/** i32<->f32 round-trip: convert, FMA, convert back — the delta against the fp32 scalar test isolates conversion cost. */
+export function prepareFlopsI32F32Convert(ctx, harness = {}) {
+    return prepareFlopsBenchmark(ctx, {
+        id: 'flops-i32-f32-convert',
+        label: 'i32<->f32 convert FLOPS',
+        description: 'Eight independent chains per thread, unrolled 4x: xi -> f32(xi)*a+b -> back to i32 each step. Same FMA as the fp32 scalar test plus a convert on each side, so the gap against that test isolates int<->float conversion cost.',
+        wgsl: flopsI32F32ConvertWgsl,
+        metric: OPS_METRIC,
+        flopsPerIteration: 128,
+        defaultIterations: 256,
+    }, harness);
+}
+/** fp32<->fp16 round-trip via pack2x16float/unpack2x16float — no shader-f16 feature needed. */
+export function prepareFlopsF32F16Convert(ctx, harness = {}) {
+    return prepareFlopsBenchmark(ctx, {
+        id: 'flops-f32-f16-convert',
+        label: 'f32<->f16 convert FLOPS',
+        description: 'Eight independent vec2<f32> chains per thread, unrolled 4x: pack2x16float then unpack2x16float (round-trips through fp16 bits) plus a vec2 FMA to keep the chain moving. Unlike flops-f16-*, this needs no shader-f16 device feature — it measures the conversion, not f16 compute.',
+        wgsl: flopsF32F16ConvertWgsl,
+        metric: OPS_METRIC,
+        flopsPerIteration: 192,
+        defaultIterations: 256,
+    }, harness);
+}
+/** i32<->f16 round-trip, chained through f32 (there's no native int<->f16 builtin). */
+export function prepareFlopsI32F16Convert(ctx, harness = {}) {
+    return prepareFlopsBenchmark(ctx, {
+        id: 'flops-i32-f16-convert',
+        label: 'i32<->f16 convert FLOPS',
+        description: 'Eight independent i32 chains per thread, unrolled 4x: xi -> f32 -> pack2x16float -> unpack2x16float -> f32*a+b -> i32. There is no native int<->f16 conversion, so this is what the real path (through f32) costs.',
+        wgsl: flopsI32F16ConvertWgsl,
+        metric: OPS_METRIC,
+        flopsPerIteration: 192,
+        defaultIterations: 256,
+    }, harness);
+}
+//# sourceMappingURL=flopsConvert.js.map

package/dist/benchmarks/flopsConvert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsConvert.js","sourceRoot":"","sources":["../../src/benchmarks/flopsConvert.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAA2B,MAAM,kBAAkB,CAAC;AAClF,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC;;;;;GAKG;AAEH,2GAA2G;AAC3G,MAAM,UAAU,yBAAyB,CACvC,GAAe,EACf,UAA8B,EAAE;IAEhC,OAAO,qBAAqB,CAC1B,GAAG,EACH;QACE,EAAE,EAAE,sBAAsB;QAC1B,KAAK,EAAE,0BAA0B;QACjC,WAAW,EACT,sOAAsO;QACxO,IAAI,EAAE,sBAAsB;QAC5B,MAAM,EAAE,UAAU;QAClB,iBAAiB,EAAE,GAAG;QACtB,iBAAiB,EAAE,GAAG;KACvB,EACD,OAAO,CACR,CAAC;AACJ,CAAC;AAED,0HAA0H;AAC1H,MAAM,UAAU,yBAAyB,CACvC,GAAe,EACf,UAA8B,EAAE;IAEhC,OAAO,qBAAqB,CAC1B,GAAG,EACH;QACE,EAAE,EAAE,uBAAuB;QAC3B,KAAK,EAAE,yBAAyB;QAChC,WAAW,EACT,gOAAgO;QAClO,IAAI,EAAE,sBAAsB;QAC5B,MAAM,EAAE,UAAU;QAClB,iBAAiB,EAAE,GAAG;QACtB,iBAAiB,EAAE,GAAG;KACvB,EACD,OAAO,CACR,CAAC;AACJ,CAAC;AAED,+FAA+F;AAC/F,MAAM,UAAU,yBAAyB,CACvC,GAAe,EACf,UAA8B,EAAE;IAEhC,OAAO,qBAAqB,CAC1B,GAAG,EACH;QACE,EAAE,EAAE,uBAAuB;QAC3B,KAAK,EAAE,yBAAyB;QAChC,WAAW,EACT,qRAAqR;QACvR,IAAI,EAAE,sBAAsB;QAC5B,MAAM,EAAE,UAAU;QAClB,iBAAiB,EAAE,GAAG;QACtB,iBAAiB,EAAE,GAAG;KACvB,EACD,OAAO,CACR,CAAC;AACJ,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,yBAAyB,CACvC,GAAe,EACf,UAA8B,EAAE;IAEhC,OAAO,qBAAqB,CAC1B,GAAG,EACH;QACE,EAAE,EAAE,uBAAuB;QAC3B,KAAK,EAAE,yBAAyB;QAChC,WAAW,EACT,oNAAoN;QACtN,IAAI,EAAE,sBAAsB;QAC5B,MAAM,EAAE,UAAU;QAClB,iBAAiB,EAAE,GAAG;QACtB,iBAAiB,EAAE,GAAG;KACvB,EACD,OAAO,CACR,CAAC;AACJ,CAAC"}

package/dist/benchmarks/flopsF16.d.ts

@@ -0,0 +1,12 @@
+import type { GpuContext } from '../gpu/context.ts';
+import { type FlopsHarnessConfig } from './flopsCommon.ts';
+import type { PreparedBenchmark } from './common.ts';
+/** Raw fp16 FLOPS: eight independent scalar f16 FMA chains per thread, unrolled 4x. */
+export declare function prepareFlopsF16Scalar(ctx: GpuContext, harness?: FlopsHarnessConfig): Promise<PreparedBenchmark>;
+/** fp16 vec4 FLOPS: one f16 FMA chain on a vec4<f16> register (4 independent lanes). */
+export declare function prepareFlopsF16Vec4(ctx: GpuContext, harness?: FlopsHarnessConfig): Promise<PreparedBenchmark>;
+/** fp16 mat4 FLOPS: x = m*x + c chained with a mat4x4<f16>. */
+export declare function prepareFlopsF16Mat4(ctx: GpuContext, harness?: FlopsHarnessConfig): Promise<PreparedBenchmark>;
+/** fp16 register-resident matvec tile: 4x8 f16 weights in registers, two dot() calls per output row. */
+export declare function prepareFlopsF16Matvec(ctx: GpuContext, harness?: FlopsHarnessConfig): Promise<PreparedBenchmark>;
+//# sourceMappingURL=flopsF16.d.ts.map

package/dist/benchmarks/flopsF16.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flopsF16.d.ts","sourceRoot":"","sources":["../../src/benchmarks/flopsF16.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAKlF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,uFAAuF;AACvF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAenH;AAED,wFAAwF;AACxF,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAejH;AAED,+DAA+D;AAC/D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAejH;AAED,wGAAwG;AACxG,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAenH"}