webgpu-bench 0.1.0

package/dist/gpu/benchmarkRunner.d.ts

@@ -0,0 +1,98 @@
+import type { TimingMethod } from '../types.ts';
+/** Knobs controlling how one timed measurement of a kernel is taken. */
+export interface MeasurementConfig {
+    /**
+     * Target duration of a single measurement (one submitted command buffer),
+     * in ms; sets how many dispatches get batched. Default 100.
+     */
+    targetMs?: number;
+    /**
+     * Target duration of a single *dispatch*, in ms. A dispatch can't be
+     * preempted, so a long one freezes the display; kernels that expose a
+     * work knob get it calibrated so one dispatch lands near this. Default 10.
+     */
+    targetDispatchMs?: number;
+    /** Discarded measurements taken after calibration and before timing starts. Default 1. */
+    warmups?: number;
+    /** Hard cap on how many dispatches get batched into one measurement (guards against runaway calibration). */
+    maxIterations?: number;
+}
+export declare const DEFAULT_MEASUREMENT: Required<MeasurementConfig>;
+/**
+ * A kernel's tunable per-dispatch work (for the raw-FLOPS kernels: the
+ * in-shader loop trip count). Lets the sampler size a single dispatch to
+ * `targetDispatchMs` on whatever GPU it finds itself on, instead of a fixed
+ * count that's a few ms on a desktop and a second on a phone.
+ */
+export interface WorkKnob {
+    /** Smallest sensible work per dispatch (also the first calibration probe, so keep it cheap). */
+    min: number;
+    /** Largest work per dispatch (the kernel's own default; bounds numerical range and per-thread setup amortisation). */
+    max: number;
+    /** Make subsequent dispatches use this much work (e.g. rewrite the params uniform). */
+    apply(work: number): void;
+}
+export interface KernelHarness extends MeasurementConfig {
+    device: GPUDevice;
+    /** Records `iterations` back-to-back dispatches (same pipeline/bind group) into the pass. */
+    encode: (pass: GPUComputePassEncoder, iterations: number) => void;
+    useTimestamps: boolean;
+    /** Present for kernels whose per-dispatch work can be resized at runtime. */
+    work?: WorkKnob;
+}
+/**
+ * Takes individual timed measurements of one kernel on demand, so a
+ * scheduler can interleave many kernels round-robin (see `runSampling`)
+ * instead of hammering one kernel until it converges. Holds the GPU timer
+ * and the calibrated batch size between calls.
+ *
+ * Lifecycle: `calibrate()` once (sizes the dispatch and the batch, runs the
+ * warmups), then `sample()` as often as wanted, then `destroy()`.
+ */
+export declare class KernelSampler {
+    private readonly h;
+    private readonly timer;
+    private iterations;
+    private currentWork;
+    /** Cleared once the GPU timestamps have disagreed with wall clock `TIMESTAMP_STRIKES_TO_DEMOTE` times running. */
+    private trustTimestamps;
+    private timestampStrikes;
+    /** Wall time of an empty submit (min of `OVERHEAD_PROBES`): submit, scheduling and readback, no GPU work. */
+    private overheadMs;
+    constructor(h: KernelHarness);
+    get timingMethod(): TimingMethod;
+    /** Number of dispatches batched into each measurement; 0 until calibrated. */
+    get innerIterations(): number;
+    /** Per-dispatch work the kernel was calibrated to; undefined if it has no work knob. */
+    get work(): number | undefined;
+    /**
+     * Sizes the kernel so one dispatch takes about `targetDispatchMs` (when it
+     * has a work knob: start from the cheapest probe and ramp up, never more
+     * than 4x per step, so even a very slow GPU never gets handed a long
+     * dispatch), then batches dispatches to fill `targetMs`, then runs the
+     * discarded warmups. The probes double as pipeline warm-up.
+     *
+     * Batch sizing uses *wall-clock* time, never the GPU timestamps: wall
+     * clock includes submit/readback overhead so it can only over-estimate,
+     * which errs toward smaller batches — whereas a broken timestamp (see
+     * `TIMESTAMP_MAX_UNDERREPORT`) would size a batch tens of times too large
+     * and hang the browser. The work ramp does use the GPU time while it's
+     * trusted (a single dispatch's wall time is mostly readback overhead, so
+     * sizing from it leaves dispatches far too small), which is safe there
+     * because growth is capped at 4x per step: a bogus reading can at worst
+     * overshoot one step before the wall-clock cross-check demotes it.
+     */
+    calibrate(): Promise<void>;
+    /** One timed measurement: per-op time in ms. Requires `calibrate()` first. */
+    sample(): Promise<number>;
+    destroy(): void;
+    /**
+     * Submits `iterations` dispatches as one command buffer and waits for
+     * them. Always returns the wall-clock time; returns the GPU-timestamp
+     * time too while the timestamps are trusted. An implausibly small reading
+     * (see `TIMESTAMP_MAX_UNDERREPORT`) is replaced by wall clock, and the
+     * sampler is demoted to wall-clock for good on the second in a row.
+     */
+    private measureRaw;
+}
+//# sourceMappingURL=benchmarkRunner.d.ts.map

package/dist/gpu/benchmarkRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmarkRunner.d.ts","sourceRoot":"","sources":["../../src/gpu/benchmarkRunner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,wEAAwE;AACxE,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6GAA6G;IAC7G,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,iBAAiB,CAK3D,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,gGAAgG;IAChG,GAAG,EAAE,MAAM,CAAC;IACZ,sHAAsH;IACtH,GAAG,EAAE,MAAM,CAAC;IACZ,uFAAuF;IACvF,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,aAAc,SAAQ,iBAAiB;IACtD,MAAM,EAAE,SAAS,CAAC;IAClB,6FAA6F;IAC7F,MAAM,EAAE,CAAC,IAAI,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAClE,aAAa,EAAE,OAAO,CAAC;IACvB,6EAA6E;IAC7E,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB;AAsBD;;;;;;;;GAQG;AACH,qBAAa,aAAa;IAUZ,OAAO,CAAC,QAAQ,CAAC,CAAC;IAT9B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;IACjC,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,WAAW,CAAqB;IACxC,kHAAkH;IAClH,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,gBAAgB,CAAK;IAC7B,6GAA6G;IAC7G,OAAO,CAAC,UAAU,CAAK;gBAEM,CAAC,EAAE,aAAa;IAK7C,IAAI,YAAY,IAAI,YAAY,CAE/B;IAED,8EAA8E;IAC9E,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,wFAAwF;IACxF,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;IAED;;;;;;;;;;;;;;;;OAgBG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAsDhC,8EAA8E;IACxE,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC;IAQ/B,OAAO,IAAI,IAAI;IAIf;;;;;;OAMG;YACW,UAAU;CAgCzB"}

package/dist/gpu/benchmarkRunner.js

@@ -0,0 +1,178 @@
+import { GpuTimer } from "./timing.js";
+export const DEFAULT_MEASUREMENT = {
+    targetMs: 100,
+    targetDispatchMs: 10,
+    warmups: 1,
+    maxIterations: 200_000,
+};
+/** Never grow a calibration probe by more than this factor per step, so no probe can run away on a slow GPU. */
+const MAX_PROBE_GROWTH = 4;
+/**
+ * GPU timestamps are cross-checked against wall clock on every measurement.
+ * Wall clock minus the measured fixed submit/readback overhead is what the
+ * GPU actually spent, so a GPU reading under half of that is a broken timer.
+ * Safari's `timestamp-query` does exactly this — reporting ~1ms for a ~70ms
+ * batch — and trusting it makes calibration batch ~70x too much work into
+ * one command buffer, which hangs the browser. Two consecutive failures are
+ * required before demoting for good, so a one-off main-thread stall that
+ * inflates wall time (GC, a compositor frame) can't cost a kernel its
+ * accurate timer.
+ */
+const TIMESTAMP_CHECK_MIN_GPU_MS = 4;
+const TIMESTAMP_MAX_UNDERREPORT = 2;
+const TIMESTAMP_STRIKES_TO_DEMOTE = 2;
+/** Empty submits measured at calibration to estimate the fixed per-measurement overhead. */
+const OVERHEAD_PROBES = 3;
+/**
+ * Takes individual timed measurements of one kernel on demand, so a
+ * scheduler can interleave many kernels round-robin (see `runSampling`)
+ * instead of hammering one kernel until it converges. Holds the GPU timer
+ * and the calibrated batch size between calls.
+ *
+ * Lifecycle: `calibrate()` once (sizes the dispatch and the batch, runs the
+ * warmups), then `sample()` as often as wanted, then `destroy()`.
+ */
+export class KernelSampler {
+    h;
+    timer;
+    iterations = 0;
+    currentWork;
+    /** Cleared once the GPU timestamps have disagreed with wall clock `TIMESTAMP_STRIKES_TO_DEMOTE` times running. */
+    trustTimestamps;
+    timestampStrikes = 0;
+    /** Wall time of an empty submit (min of `OVERHEAD_PROBES`): submit, scheduling and readback, no GPU work. */
+    overheadMs = 0;
+    constructor(h) {
+        this.h = h;
+        this.timer = new GpuTimer(h.device, h.useTimestamps);
+        this.trustTimestamps = this.timer.supported;
+    }
+    get timingMethod() {
+        return this.trustTimestamps ? 'gpu-timestamp' : 'cpu-wallclock';
+    }
+    /** Number of dispatches batched into each measurement; 0 until calibrated. */
+    get innerIterations() {
+        return this.iterations;
+    }
+    /** Per-dispatch work the kernel was calibrated to; undefined if it has no work knob. */
+    get work() {
+        return this.currentWork;
+    }
+    /**
+     * Sizes the kernel so one dispatch takes about `targetDispatchMs` (when it
+     * has a work knob: start from the cheapest probe and ramp up, never more
+     * than 4x per step, so even a very slow GPU never gets handed a long
+     * dispatch), then batches dispatches to fill `targetMs`, then runs the
+     * discarded warmups. The probes double as pipeline warm-up.
+     *
+     * Batch sizing uses *wall-clock* time, never the GPU timestamps: wall
+     * clock includes submit/readback overhead so it can only over-estimate,
+     * which errs toward smaller batches — whereas a broken timestamp (see
+     * `TIMESTAMP_MAX_UNDERREPORT`) would size a batch tens of times too large
+     * and hang the browser. The work ramp does use the GPU time while it's
+     * trusted (a single dispatch's wall time is mostly readback overhead, so
+     * sizing from it leaves dispatches far too small), which is safe there
+     * because growth is capped at 4x per step: a bogus reading can at worst
+     * overshoot one step before the wall-clock cross-check demotes it.
+     */
+    async calibrate() {
+        const targetMs = this.h.targetMs ?? DEFAULT_MEASUREMENT.targetMs;
+        const targetDispatchMs = this.h.targetDispatchMs ?? DEFAULT_MEASUREMENT.targetDispatchMs;
+        const warmups = this.h.warmups ?? DEFAULT_MEASUREMENT.warmups;
+        const maxIterations = this.h.maxIterations ?? DEFAULT_MEASUREMENT.maxIterations;
+        this.overheadMs = Number.POSITIVE_INFINITY;
+        for (let i = 0; i < OVERHEAD_PROBES; i++) {
+            this.overheadMs = Math.min(this.overheadMs, (await this.measureRaw(0)).wallMs);
+        }
+        const knob = this.h.work;
+        if (knob) {
+            let work = Math.max(1, Math.floor(knob.min));
+            knob.apply(work);
+            const dispatchTime = async () => {
+                const { gpuMs, wallMs } = await this.measureRaw(1);
+                return gpuMs ?? wallMs;
+            };
+            let dispatchMs = await dispatchTime();
+            // Ramp: the dispatch time is ~linear in work, so extrapolate straight
+            // to the target, but cap the growth per step and re-measure.
+            while (work < knob.max && dispatchMs < targetDispatchMs) {
+                const wanted = (work * targetDispatchMs) / Math.max(dispatchMs, 1e-6);
+                const next = Math.min(knob.max, Math.floor(Math.min(wanted, work * MAX_PROBE_GROWTH)));
+                if (next <= work)
+                    break;
+                work = next;
+                knob.apply(work);
+                dispatchMs = await dispatchTime();
+            }
+            this.currentWork = work;
+        }
+        // Batch sizing: grow from a single dispatch until one measurement's wall
+        // time is near the target. Wall clock over-estimates a tiny dispatch
+        // (fixed submit/readback overhead dominates), so the first extrapolation
+        // under-shoots and a couple of refinement steps home in from below. The
+        // very first measurement never ends the search: it can absorb a one-off
+        // stall (lazy shader compile, GC) that would leave the batch at 1.
+        let iterations = 1;
+        for (let step = 0; step < 4; step++) {
+            const { wallMs } = await this.measureRaw(iterations);
+            if ((step > 0 && wallMs >= targetMs / 2) || iterations >= maxIterations)
+                break;
+            const next = Math.min(maxIterations, Math.floor((iterations * targetMs) / Math.max(wallMs, 1e-6)));
+            if (next <= iterations)
+                break;
+            iterations = next;
+        }
+        this.iterations = iterations;
+        for (let i = 0; i < warmups; i++) {
+            await this.measureRaw(this.iterations);
+        }
+    }
+    /** One timed measurement: per-op time in ms. Requires `calibrate()` first. */
+    async sample() {
+        if (this.iterations === 0) {
+            throw new Error('KernelSampler.sample() called before calibrate()');
+        }
+        const { gpuMs, wallMs } = await this.measureRaw(this.iterations);
+        return (gpuMs ?? wallMs) / this.iterations;
+    }
+    destroy() {
+        this.timer.destroy();
+    }
+    /**
+     * Submits `iterations` dispatches as one command buffer and waits for
+     * them. Always returns the wall-clock time; returns the GPU-timestamp
+     * time too while the timestamps are trusted. An implausibly small reading
+     * (see `TIMESTAMP_MAX_UNDERREPORT`) is replaced by wall clock, and the
+     * sampler is demoted to wall-clock for good on the second in a row.
+     */
+    async measureRaw(iterations) {
+        const { h, timer } = this;
+        const useTimestamps = this.trustTimestamps;
+        const encoder = h.device.createCommandEncoder();
+        const pass = encoder.beginComputePass({ timestampWrites: useTimestamps ? timer.timestampWrites : undefined });
+        h.encode(pass, iterations);
+        pass.end();
+        if (useTimestamps)
+            timer.resolve(encoder);
+        const cpuStart = performance.now();
+        h.device.queue.submit([encoder.finish()]);
+        if (!useTimestamps) {
+            await h.device.queue.onSubmittedWorkDone();
+            return { gpuMs: null, wallMs: performance.now() - cpuStart };
+        }
+        const gpuMs = await timer.readElapsedMs();
+        const wallMs = performance.now() - cpuStart;
+        const gpuWallMs = wallMs - this.overheadMs;
+        if (iterations > 0 &&
+            gpuWallMs >= TIMESTAMP_CHECK_MIN_GPU_MS &&
+            !(gpuMs * TIMESTAMP_MAX_UNDERREPORT >= gpuWallMs)) {
+            this.timestampStrikes += 1;
+            if (this.timestampStrikes >= TIMESTAMP_STRIKES_TO_DEMOTE)
+                this.trustTimestamps = false;
+            return { gpuMs: null, wallMs };
+        }
+        this.timestampStrikes = 0;
+        return { gpuMs, wallMs };
+    }
+}
+//# sourceMappingURL=benchmarkRunner.js.map

package/dist/gpu/benchmarkRunner.js.map

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

package/dist/gpu/buffers.d.ts

@@ -0,0 +1,8 @@
+/** Creates a GPU buffer, uploads `data` into it, and returns the buffer. */
+export declare function createUploadedBuffer(device: GPUDevice, data: ArrayBufferView, usage: GPUBufferUsageFlags, label?: string): GPUBuffer;
+export declare function createStorageBuffer(device: GPUDevice, data: ArrayBufferView, label?: string): GPUBuffer;
+export declare function createUniformBuffer(device: GPUDevice, data: ArrayBufferView, label?: string): GPUBuffer;
+export declare function createEmptyStorageBuffer(device: GPUDevice, byteLength: number, label?: string): GPUBuffer;
+/** Reads a storage buffer back to the CPU as a Float32Array (used only for correctness spot-checks, not timing). */
+export declare function readFloat32(device: GPUDevice, buffer: GPUBuffer, count: number): Promise<Float32Array>;
+//# sourceMappingURL=buffers.d.ts.map

package/dist/gpu/buffers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffers.d.ts","sourceRoot":"","sources":["../../src/gpu/buffers.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,mBAAmB,EAC1B,KAAK,CAAC,EAAE,MAAM,GACb,SAAS,CAUX;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAOvG;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAEvG;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAMzG;AAED,oHAAoH;AACpH,wBAAsB,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAa5G"}

package/dist/gpu/buffers.js

@@ -0,0 +1,41 @@
+/** Creates a GPU buffer, uploads `data` into it, and returns the buffer. */
+export function createUploadedBuffer(device, data, usage, label) {
+    const buffer = device.createBuffer({
+        label,
+        size: Math.max(4, Math.ceil(data.byteLength / 4) * 4),
+        usage,
+        mappedAtCreation: true,
+    });
+    new Uint8Array(buffer.getMappedRange()).set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+    buffer.unmap();
+    return buffer;
+}
+export function createStorageBuffer(device, data, label) {
+    return createUploadedBuffer(device, data, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, label);
+}
+export function createUniformBuffer(device, data, label) {
+    return createUploadedBuffer(device, data, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST, label);
+}
+export function createEmptyStorageBuffer(device, byteLength, label) {
+    return device.createBuffer({
+        label,
+        size: Math.max(4, Math.ceil(byteLength / 4) * 4),
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+    });
+}
+/** Reads a storage buffer back to the CPU as a Float32Array (used only for correctness spot-checks, not timing). */
+export async function readFloat32(device, buffer, count) {
+    const staging = device.createBuffer({
+        size: count * 4,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+    });
+    const encoder = device.createCommandEncoder();
+    encoder.copyBufferToBuffer(buffer, 0, staging, 0, count * 4);
+    device.queue.submit([encoder.finish()]);
+    await staging.mapAsync(GPUMapMode.READ);
+    const result = new Float32Array(staging.getMappedRange().slice(0));
+    staging.unmap();
+    staging.destroy();
+    return result;
+}
+//# sourceMappingURL=buffers.js.map

package/dist/gpu/buffers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffers.js","sourceRoot":"","sources":["../../src/gpu/buffers.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,MAAM,UAAU,oBAAoB,CAClC,MAAiB,EACjB,IAAqB,EACrB,KAA0B,EAC1B,KAAc;IAEd,MAAM,MAAM,GAAG,MAAM,CAAC,YAAY,CAAC;QACjC,KAAK;QACL,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QACrD,KAAK;QACL,gBAAgB,EAAE,IAAI;KACvB,CAAC,CAAC;IACH,IAAI,UAAU,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IAC3G,MAAM,CAAC,KAAK,EAAE,CAAC;IACf,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAiB,EAAE,IAAqB,EAAE,KAAc;IAC1F,OAAO,oBAAoB,CACzB,MAAM,EACN,IAAI,EACJ,cAAc,CAAC,OAAO,GAAG,cAAc,CAAC,QAAQ,GAAG,cAAc,CAAC,QAAQ,EAC1E,KAAK,CACN,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAiB,EAAE,IAAqB,EAAE,KAAc;IAC1F,OAAO,oBAAoB,CAAC,MAAM,EAAE,IAAI,EAAE,cAAc,CAAC,OAAO,GAAG,cAAc,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;AACrG,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,MAAiB,EAAE,UAAkB,EAAE,KAAc;IAC5F,OAAO,MAAM,CAAC,YAAY,CAAC;QACzB,KAAK;QACL,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QAChD,KAAK,EAAE,cAAc,CAAC,OAAO,GAAG,cAAc,CAAC,QAAQ,GAAG,cAAc,CAAC,QAAQ;KAClF,CAAC,CAAC;AACL,CAAC;AAED,oHAAoH;AACpH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,MAAiB,EAAE,MAAiB,EAAE,KAAa;IACnF,MAAM,OAAO,GAAG,MAAM,CAAC,YAAY,CAAC;QAClC,IAAI,EAAE,KAAK,GAAG,CAAC;QACf,KAAK,EAAE,cAAc,CAAC,QAAQ,GAAG,cAAc,CAAC,QAAQ;KACzD,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,MAAM,CAAC,oBAAoB,EAAE,CAAC;IAC9C,OAAO,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;IAC7D,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACxC,MAAM,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACnE,OAAO,CAAC,KAAK,EAAE,CAAC;IAChB,OAAO,CAAC,OAAO,EAAE,CAAC;IAClB,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/gpu/context.d.ts

@@ -0,0 +1,16 @@
+import type { DeviceInfo } from '../types.ts';
+export interface GpuContext {
+    adapter: GPUAdapter;
+    device: GPUDevice;
+    info: DeviceInfo;
+}
+/**
+ * Acquires a GPUAdapter/GPUDevice directly from the browser's `navigator.gpu`
+ * (high-performance power preference), requesting every optional device
+ * feature this suite can make use of — f16 shaders and GPU timestamp
+ * queries — without failing if the device lacks some of them. Each benchmark
+ * checks `info.supports*` and reports itself as "skipped" rather than
+ * crashing the suite when a feature is missing.
+ */
+export declare function acquireGpuContext(): Promise<GpuContext>;
+//# sourceMappingURL=context.d.ts.map

package/dist/gpu/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/gpu/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,EAAE,SAAS,CAAC;IAClB,IAAI,EAAE,UAAU,CAAC;CAClB;AAWD;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,UAAU,CAAC,CA4D7D"}

package/dist/gpu/context.js

@@ -0,0 +1,71 @@
+const OPTIONAL_FEATURES = ['shader-f16', 'timestamp-query'];
+// `packed_4x8_integer_dot_product` is a WGSL *language* extension (enabled in
+// shader source via `enable packed_4x8_integer_dot_product;`), not a
+// GPUFeatureName — it's never granted via requestDevice()'s requiredFeatures
+// and never appears in adapter.features / device.features. Support is
+// reported separately through navigator.gpu.wgslLanguageFeatures.
+const WGSL_I8_DOT_EXTENSION = 'packed_4x8_integer_dot_product';
+/**
+ * Acquires a GPUAdapter/GPUDevice directly from the browser's `navigator.gpu`
+ * (high-performance power preference), requesting every optional device
+ * feature this suite can make use of — f16 shaders and GPU timestamp
+ * queries — without failing if the device lacks some of them. Each benchmark
+ * checks `info.supports*` and reports itself as "skipped" rather than
+ * crashing the suite when a feature is missing.
+ */
+export async function acquireGpuContext() {
+    if (!('gpu' in navigator) || !navigator.gpu) {
+        throw new Error('WebGPU is not available in this browser (navigator.gpu is undefined).');
+    }
+    const adapter = await navigator.gpu.requestAdapter({ powerPreference: 'high-performance' });
+    if (!adapter) {
+        throw new Error('No suitable WebGPU adapter was found.');
+    }
+    const requiredFeatures = OPTIONAL_FEATURES.filter((f) => adapter.features.has(f));
+    const requiredLimits = {};
+    // Ask for the largest storage-buffer binding & workgroup budgets the adapter allows,
+    // so large matrices and tuned workgroup sizes aren't capped by conservative defaults.
+    for (const key of [
+        'maxStorageBufferBindingSize',
+        'maxBufferSize',
+        'maxComputeWorkgroupSizeX',
+        'maxComputeInvocationsPerWorkgroup',
+        'maxComputeWorkgroupStorageSize',
+    ]) {
+        const value = adapter.limits[key];
+        if (typeof value === 'number')
+            requiredLimits[key] = value;
+    }
+    const device = await adapter.requestDevice({ requiredFeatures, requiredLimits });
+    const limits = {};
+    for (const key of Object.keys(device.limits)) {
+        const value = device.limits[key];
+        if (typeof value === 'number')
+            limits[key] = value;
+    }
+    let adapterInfoDescription;
+    let vendor;
+    let architecture;
+    const anyAdapter = adapter;
+    if (anyAdapter.info) {
+        vendor = anyAdapter.info.vendor || undefined;
+        architecture = anyAdapter.info.architecture || undefined;
+        adapterInfoDescription = anyAdapter.info.description || undefined;
+    }
+    const info = {
+        vendor,
+        architecture,
+        description: adapterInfoDescription,
+        features: [...device.features].toSorted(),
+        limits,
+        supportsF16: device.features.has('shader-f16'),
+        supportsI8Dot: Boolean(navigator.gpu.wgslLanguageFeatures?.has(WGSL_I8_DOT_EXTENSION)),
+        supportsTimestampQuery: device.features.has('timestamp-query'),
+    };
+    device.addEventListener('uncapturederror', (event) => {
+        // eslint-disable-next-line no-console
+        console.error('WebGPU uncaptured error:', event.error);
+    });
+    return { adapter, device, info };
+}
+//# sourceMappingURL=context.js.map

package/dist/gpu/context.js.map

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

package/dist/gpu/timing.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Wraps a single compute pass in GPU timestamp queries when the device
+ * supports `timestamp-query`, giving pure device-side elapsed time (no CPU
+ * dispatch/driver overhead in the number). Falls back to CPU wall-clock
+ * around `queue.onSubmittedWorkDone()` otherwise — still a fair comparison
+ * across kernels, just with a little more noise.
+ */
+export declare class GpuTimer {
+    readonly supported: boolean;
+    private readonly querySet;
+    private readonly resolveBuffer;
+    private readonly resultBuffer;
+    constructor(device: GPUDevice, supported: boolean);
+    get timestampWrites(): GPUComputePassTimestampWrites | undefined;
+    resolve(encoder: GPUCommandEncoder): void;
+    /** Reads back the two timestamps written by the most recently submitted pass and returns elapsed ms. */
+    readElapsedMs(): Promise<number>;
+    destroy(): void;
+}
+//# sourceMappingURL=timing.d.ts.map

package/dist/gpu/timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.d.ts","sourceRoot":"","sources":["../../src/gpu/timing.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,QAAQ;IAOjB,QAAQ,CAAC,SAAS,EAAE,OAAO;IAN7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4B;IACrD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0B;IACxD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0B;gBAGrD,MAAM,EAAE,SAAS,EACR,SAAS,EAAE,OAAO;IAe7B,IAAI,eAAe,IAAI,6BAA6B,GAAG,SAAS,CAG/D;IAED,OAAO,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAMzC,wGAAwG;IAClG,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC;IAUtC,OAAO,IAAI,IAAI;CAKhB"}

package/dist/gpu/timing.js

@@ -0,0 +1,55 @@
+/**
+ * Wraps a single compute pass in GPU timestamp queries when the device
+ * supports `timestamp-query`, giving pure device-side elapsed time (no CPU
+ * dispatch/driver overhead in the number). Falls back to CPU wall-clock
+ * around `queue.onSubmittedWorkDone()` otherwise — still a fair comparison
+ * across kernels, just with a little more noise.
+ */
+export class GpuTimer {
+    supported;
+    querySet = null;
+    resolveBuffer = null;
+    resultBuffer = null;
+    constructor(device, supported) {
+        this.supported = supported;
+        if (supported) {
+            this.querySet = device.createQuerySet({ type: 'timestamp', count: 2 });
+            this.resolveBuffer = device.createBuffer({
+                size: 16,
+                usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
+            });
+            this.resultBuffer = device.createBuffer({
+                size: 16,
+                usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+            });
+        }
+    }
+    get timestampWrites() {
+        if (!this.supported || !this.querySet)
+            return undefined;
+        return { querySet: this.querySet, beginningOfPassWriteIndex: 0, endOfPassWriteIndex: 1 };
+    }
+    resolve(encoder) {
+        if (!this.supported || !this.querySet || !this.resolveBuffer || !this.resultBuffer)
+            return;
+        encoder.resolveQuerySet(this.querySet, 0, 2, this.resolveBuffer, 0);
+        encoder.copyBufferToBuffer(this.resolveBuffer, 0, this.resultBuffer, 0, 16);
+    }
+    /** Reads back the two timestamps written by the most recently submitted pass and returns elapsed ms. */
+    async readElapsedMs() {
+        if (!this.supported || !this.resultBuffer)
+            return Number.NaN;
+        await this.resultBuffer.mapAsync(GPUMapMode.READ);
+        const times = new BigInt64Array(this.resultBuffer.getMappedRange().slice(0));
+        this.resultBuffer.unmap();
+        const start = times[0];
+        const end = times[1];
+        return Number(end - start) / 1e6; // nanoseconds -> milliseconds
+    }
+    destroy() {
+        this.querySet?.destroy();
+        this.resolveBuffer?.destroy();
+        this.resultBuffer?.destroy();
+    }
+}
+//# sourceMappingURL=timing.js.map

package/dist/gpu/timing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.js","sourceRoot":"","sources":["../../src/gpu/timing.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,OAAO,QAAQ;IAOR;IANM,QAAQ,GAAuB,IAAI,CAAC;IACpC,aAAa,GAAqB,IAAI,CAAC;IACvC,YAAY,GAAqB,IAAI,CAAC;IAEvD,YACE,MAAiB,EACR,SAAkB;QAAlB,cAAS,GAAT,SAAS,CAAS;QAE3B,IAAI,SAAS,EAAE,CAAC;YACd,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,cAAc,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;YACvE,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,YAAY,CAAC;gBACvC,IAAI,EAAE,EAAE;gBACR,KAAK,EAAE,cAAc,CAAC,aAAa,GAAG,cAAc,CAAC,QAAQ;aAC9D,CAAC,CAAC;YACH,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;gBACtC,IAAI,EAAE,EAAE;gBACR,KAAK,EAAE,cAAc,CAAC,QAAQ,GAAG,cAAc,CAAC,QAAQ;aACzD,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,IAAI,eAAe;QACjB,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,OAAO,SAAS,CAAC;QACxD,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,yBAAyB,EAAE,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,CAAC;IAC3F,CAAC;IAED,OAAO,CAAC,OAA0B;QAChC,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,YAAY;YAAE,OAAO;QAC3F,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;QACpE,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;IAC9E,CAAC;IAED,wGAAwG;IACxG,KAAK,CAAC,aAAa;QACjB,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,YAAY;YAAE,OAAO,MAAM,CAAC,GAAG,CAAC;QAC7D,MAAM,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAClD,MAAM,KAAK,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7E,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAC1B,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC;QACxB,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC;QACtB,OAAO,MAAM,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,8BAA8B;IAClE,CAAC;IAED,OAAO;QACL,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC;QACzB,IAAI,CAAC,aAAa,EAAE,OAAO,EAAE,CAAC;QAC9B,IAAI,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC;IAC/B,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { runSuite } from './suite.ts';
+export type { BenchmarkResult, SuiteOptions, SuiteProgressEvent, DeviceInfo, Stats, BenchmarkCategory, BenchmarkStatus, TimingMethod, SamplingStopReason, } from './types.ts';
+export { computeStats, isBestStable, isThrottled, tQuantile975 } from './stats.ts';
+export type { BestStableOptions } from './stats.ts';
+export { DEFAULT_SAMPLING, runSampling, recordSample, roundIsThrottled, resolveSamplingConfig } from './sampling.ts';
+export type { SamplingConfig, Sampleable, SampleState, SampleStateSnapshot, RunSamplingOptions } from './sampling.ts';
+export { DEFAULT_MEASUREMENT, KernelSampler } from './gpu/benchmarkRunner.ts';
+export type { MeasurementConfig, KernelHarness, WorkKnob } from './gpu/benchmarkRunner.ts';
+export { generateMatVecData, padToMultipleOf4, mulberry32 } from './data/generate.ts';
+export { acquireGpuContext } from './gpu/context.ts';
+export type { GpuContext } from './gpu/context.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,YAAY,EACV,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,UAAU,EACV,KAAK,EACL,iBAAiB,EACjB,eAAe,EACf,YAAY,EACZ,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AACnF,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACrH,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACtH,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9E,YAAY,EAAE,iBAAiB,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAC3F,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACtF,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { runSuite } from "./suite.js";
+export { computeStats, isBestStable, isThrottled, tQuantile975 } from "./stats.js";
+export { DEFAULT_SAMPLING, runSampling, recordSample, roundIsThrottled, resolveSamplingConfig } from "./sampling.js";
+export { DEFAULT_MEASUREMENT, KernelSampler } from "./gpu/benchmarkRunner.js";
+export { generateMatVecData, padToMultipleOf4, mulberry32 } from "./data/generate.js";
+export { acquireGpuContext } from "./gpu/context.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAYtC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEnF,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAErH,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9E,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACtF,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}