sync from abhijitramesh/webgpu-bench@cfa77c10dc

build/asyncify/bench.wasm

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1ba4381b1a8c3a34d003bae0837e684515174b8c1e24b470b7013eedafc359e4
-size 5235854
+oid sha256:992c98b10bc138f1b92c12b9586a8ea0f925ea9e6789b2a8da3117c928ee5acc
+size 5240204

build/asyncify/build-info.json

@@ -2,5 +2,5 @@
   "llamaCppCommit": "f22c8021d213567942a3d0134692e70f02f28f3a",
   "llamaCppDescribe": "b8981-3-gf22c8021d",
   "dawnTag": "v20260317.182325",
-  "builtAt": "2026-05-01T08:36:58Z"
+  "builtAt": "2026-05-01T09:06:07Z"
 }

build/jspi/bench.wasm

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:39eea46a9d02b044c9d143cf8243c3e05f8bf89d94bb5bcd804b6e43755b958d
-size 3614207
+oid sha256:a699aba49bfcc4e8cf4e78efa891cf1eb4b7a895345ea17d64916cc7c50c6df1
+size 3616251

build/jspi/build-info.json

@@ -2,5 +2,5 @@
   "llamaCppCommit": "f22c8021d213567942a3d0134692e70f02f28f3a",
   "llamaCppDescribe": "b8981-3-gf22c8021d",
   "dawnTag": "v20260317.182325",
-  "builtAt": "2026-05-01T08:33:19Z"
+  "builtAt": "2026-05-01T09:02:12Z"
 }

harness.js

@@ -30,6 +30,7 @@ window.addEventListener('unhandledrejection', (e) => {
   const nPrompt             = parseInt(params.get('nPrompt')    || '512', 10);
   const nGen                = parseInt(params.get('nGen')       || '128', 10);
   const nReps               = parseInt(params.get('nReps')      || '5', 10);
+  const nDepth              = parseInt(params.get('nDepth')     || '0', 10);
   const nCtx                = parseInt(params.get('nCtx')       || '2048', 10);
   const nGpuLayers          = parseInt(params.get('nGpuLayers') || '999', 10);
   const refTokenIds         = params.get('refTokenIds') || null;
@@ -145,6 +146,7 @@ window.addEventListener('unhandledrejection', (e) => {
         nPrompt: runPerf ? nPrompt : 0,
         nGen:    runPerf ? nGen    : 0,
         nReps,
+        nDepth:  runPerf ? nDepth  : 0,
         noWarmup: false,
       },
       opfsPath: { rootDir: OPFS_ROOT_NAME, repo: hfRepo, filename: modelFile },

js/dataset.js

@@ -151,6 +151,10 @@ function flattenForDashboard(r, slug) {
     tg_test_name: tg?.name ?? null,
     pp_n_prompt: pp?.n_prompt ?? r.nPrompt ?? null,
     tg_n_gen:    tg?.n_gen    ?? r.nGen    ?? null,
+    // KV-cache depth the timed reps ran at. Mirrors llama-bench's `-d` and
+    // is per-test in metrics.tests; record-level r.nDepth is the
+    // study/runner-set value, used as a fallback for older exports.
+    n_depth: pp?.n_depth ?? tg?.n_depth ?? r.nDepth ?? 0,
     n_p_eval: r.metrics?.n_p_eval ?? null,
     t_p_eval_ms: r.metrics?.t_p_eval_ms ?? null,
     n_eval: r.metrics?.n_eval ?? null,

js/run/bench-worker.js

@@ -13,7 +13,7 @@
 //       // consistency phase (set consistencyPrompt to '' to skip)
 //       consistencyPrompt, consistencyNPredict, refTokenIds,
 //       // perf phase
-//       nPrompt, nGen, nReps, noWarmup,
+//       nPrompt, nGen, nReps, nDepth, noWarmup,
 //     },
 //     opfsPath: { rootDir, repo, filename }
 //   }
@@ -162,10 +162,14 @@ function opfsFreeAll(Module) {
 // llama-bench reports avg_ts = (n_tokens * 1e9) / avg_ns and stddev_ts as
 // the std of per-sample t/s, computed independently rather than propagated
 // from stddev_ns (the mapping isn't linear).
-function buildTest(name, n_prompt, n_gen, samples_ns) {
+//
+// `n_depth` carries through unchanged so downstream consumers can label
+// e.g. "pp512 @ d2048" the way llama-bench does (line 1984 of
+// llama.cpp/tools/llama-bench/llama-bench.cpp).
+function buildTest(name, n_prompt, n_gen, n_depth, samples_ns) {
   const n = samples_ns.length;
   if (n === 0) {
-    return { name, n_prompt, n_gen, avg_ns: 0, stddev_ns: 0, avg_ts: 0, stddev_ts: 0, samples_ns: [], samples_ts: [] };
+    return { name, n_prompt, n_gen, n_depth, avg_ns: 0, stddev_ns: 0, avg_ts: 0, stddev_ts: 0, samples_ns: [], samples_ts: [] };
   }
   const avg_ns = samples_ns.reduce((a, b) => a + b, 0) / n;
   const var_ns = n > 1
@@ -184,6 +188,7 @@ function buildTest(name, n_prompt, n_gen, samples_ns) {
     name,
     n_prompt,
     n_gen,
+    n_depth,
     avg_ns: Math.round(avg_ns),
     stddev_ns: Math.round(stddev_ns),
     avg_ts: round2(avg_ts),
@@ -236,6 +241,7 @@ async function runOne({ params, opfsPath }) {
     nPrompt,
     nGen,
     nReps,
+    nDepth = 0,
     noWarmup,
   } = params;
   // The worker only loads via OPFS now: main thread downloads to OPFS,
@@ -409,29 +415,44 @@ async function runOne({ params, opfsPath }) {
   // which the dashboard renders as a dash.
   const wantPp = nPrompt > 0;
   const wantTg = nGen > 0;
+  // Test name suffix mirroring llama-bench (e.g. "pp512 @ d2048").
+  const depthSuffix = nDepth > 0 ? ` @ d${nDepth}` : '';
+  // Each timed rep is preceded by an untimed bench_set_depth call so the KV
+  // cache is in a known state. The C side caches the post-prefill snapshot,
+  // so reps 2..N at the same depth restore from snapshot instead of
+  // re-running the prefill (mirroring llama-bench's `cstate` reuse).
+  const setDepth = async (label) => {
+    const raw = await Module.ccall('bench_set_depth', 'string', ['number'], [nDepth], { async: true });
+    const r = parseBenchResult(`bench_set_depth(${nDepth}) ${label}`, raw);
+    if (nDepth > 0) {
+      log(`bench_set_depth(${nDepth}) ${label}: ${r.cached ? 'restored snapshot' : 'prefilled'}`);
+    }
+  };
   if (wantPp || wantTg) {
     const tests = [];
 
     if (wantPp) {
       try {
         if (!noWarmup) {
-          status('perf', `warmup pp${nPrompt}`, Date.now());
-          log(`bench_pp(${nPrompt}) — warmup`);
+          status('perf', `warmup pp${nPrompt}${depthSuffix}`, Date.now());
+          await setDepth('pp warmup');
+          log(`bench_pp(${nPrompt})${depthSuffix} — warmup`);
           const raw = await Module.ccall('bench_pp', 'string', ['number'], [nPrompt], { async: true });
           parseBenchResult('bench_pp warmup', raw);
         }
         const samples_ns = [];
         for (let i = 0; i < nReps; i++) {
-          status('perf', `pp${nPrompt} ${i + 1}/${nReps}`, Date.now());
+          status('perf', `pp${nPrompt}${depthSuffix} ${i + 1}/${nReps}`, Date.now());
+          await setDepth(`pp rep ${i + 1}/${nReps}`);
           const t0 = performance.now();
           const raw = await Module.ccall('bench_pp', 'string', ['number'], [nPrompt], { async: true });
           const t_ns = (performance.now() - t0) * 1e6;
           parseBenchResult('bench_pp', raw);
           samples_ns.push(t_ns);
-          log(`pp${nPrompt} run ${i + 1}/${nReps}: ${(t_ns / 1e6).toFixed(1)} ms (${(1e9 * nPrompt / t_ns).toFixed(1)} t/s)`);
+          log(`pp${nPrompt}${depthSuffix} run ${i + 1}/${nReps}: ${(t_ns / 1e6).toFixed(1)} ms (${(1e9 * nPrompt / t_ns).toFixed(1)} t/s)`);
           if (i + 1 < nReps) await sleep(REP_COOLDOWN_MS);
         }
-        tests.push(buildTest(`pp${nPrompt}`, nPrompt, 0, samples_ns));
+        tests.push(buildTest(`pp${nPrompt}${depthSuffix}`, nPrompt, 0, nDepth, samples_ns));
       } catch (err) {
         log(`pp test failed: ${err.message}`);
       }
@@ -444,23 +465,25 @@ async function runOne({ params, opfsPath }) {
           // A 1-token warmup exercises the decode kernel once, which leaves
           // the first timed rep absorbing pipeline-cache / shader-specialize
           // cost on every subsequent step.
-          status('perf', `warmup tg${nGen}`, Date.now());
-          log(`bench_tg(${nGen}) — warmup`);
+          status('perf', `warmup tg${nGen}${depthSuffix}`, Date.now());
+          await setDepth('tg warmup');
+          log(`bench_tg(${nGen})${depthSuffix} — warmup`);
           const raw = await Module.ccall('bench_tg', 'string', ['number'], [nGen], { async: true });
           parseBenchResult('bench_tg warmup', raw);
         }
         const samples_ns = [];
         for (let i = 0; i < nReps; i++) {
-          status('perf', `tg${nGen} ${i + 1}/${nReps}`, Date.now());
+          status('perf', `tg${nGen}${depthSuffix} ${i + 1}/${nReps}`, Date.now());
+          await setDepth(`tg rep ${i + 1}/${nReps}`);
           const t0 = performance.now();
           const raw = await Module.ccall('bench_tg', 'string', ['number'], [nGen], { async: true });
           const t_ns = (performance.now() - t0) * 1e6;
           parseBenchResult('bench_tg', raw);
           samples_ns.push(t_ns);
-          log(`tg${nGen} run ${i + 1}/${nReps}: ${(t_ns / 1e6).toFixed(1)} ms (${(1e9 * nGen / t_ns).toFixed(1)} t/s)`);
+          log(`tg${nGen}${depthSuffix} run ${i + 1}/${nReps}: ${(t_ns / 1e6).toFixed(1)} ms (${(1e9 * nGen / t_ns).toFixed(1)} t/s)`);
           if (i + 1 < nReps) await sleep(REP_COOLDOWN_MS);
         }
-        tests.push(buildTest(`tg${nGen}`, 0, nGen, samples_ns));
+        tests.push(buildTest(`tg${nGen}${depthSuffix}`, 0, nGen, nDepth, samples_ns));
       } catch (err) {
         log(`tg test failed: ${err.message}`);
       }
@@ -471,6 +494,7 @@ async function runOne({ params, opfsPath }) {
         tests,
         n_prompt: wantPp ? nPrompt : 0,
         n_gen: wantTg ? nGen : 0,
+        n_depth: nDepth,
         n_reps: nReps,
       };
     }

js/run/controller.js

@@ -22,6 +22,7 @@ const YIELD_BETWEEN_RUNS_MS = 500;
 // llama-bench defaults: -p 512 -n 128 -r 5
 const DEFAULT_N_PROMPT = 512;
 const DEFAULT_N_GEN = 128;
+const DEFAULT_N_DEPTH = 2048;
 const DEFAULT_ITERATIONS = 5;
 const MIN_ITERATIONS_FOR_SUBMIT = 5;
 
@@ -40,6 +41,7 @@ const state = {
   iterations: DEFAULT_ITERATIONS,
   nPrompt: DEFAULT_N_PROMPT,
   nGen: DEFAULT_N_GEN,
+  nDepth: DEFAULT_N_DEPTH,
   // User-controlled phase toggles. Defaults match the previous behaviour:
   // run consistency (CPU baseline + GPU forced-decode) AND run CPU perf
   // baseline. Both checkable to skip — useful on devices where CPU is too
@@ -706,6 +708,15 @@ function wirePerfInputs() {
       ng.value = String(state.nGen);
     });
   }
+  const nd = $('n-depth-input');
+  if (nd) {
+    nd.value = String(state.nDepth);
+    nd.addEventListener('change', () => {
+      const n = Math.max(0, Math.min(32768, parseInt(nd.value, 10)));
+      state.nDepth = Number.isFinite(n) ? n : DEFAULT_N_DEPTH;
+      nd.value = String(state.nDepth);
+    });
+  }
   const skipCons = $('skip-consistency');
   if (skipCons) {
     skipCons.checked = state.skipConsistency;
@@ -1400,6 +1411,7 @@ async function runBenchmarkInWorker(v, params, callbacks) {
     nPrompt: params.nPrompt ?? 0,
     nGen:    params.nGen    ?? 0,
     nReps:   params.nReps   ?? DEFAULT_ITERATIONS,
+    nDepth:  params.nDepth  ?? 0,
     noWarmup: !!params.noWarmup,
   };
 
@@ -1453,6 +1465,11 @@ async function runVariantWithIterations(v, row) {
   const nReps = Math.max(1, state.iterations || DEFAULT_ITERATIONS);
   const nPrompt = Math.max(0, state.nPrompt ?? DEFAULT_N_PROMPT);
   const nGen = Math.max(0, state.nGen ?? DEFAULT_N_GEN);
+  const nDepth = Math.max(0, state.nDepth ?? DEFAULT_N_DEPTH);
+  // Per-test n_ctx mirrors llama-bench (line 1211 of
+  // tools/llama-bench/llama-bench.cpp): sized to fit prompt+gen+depth so a
+  // raised depth doesn't silently overflow the cache.
+  const nCtxFor = (depth) => Math.max(DEFAULT_N_CTX, nPrompt + nGen + depth);
   // Phase toggles from the run page. Combined effect:
   //   skip both          → only GPU perf, no CPU pass at all
   //   skip consistency   → CPU perf baseline + GPU perf, no token-id check
@@ -1480,8 +1497,11 @@ async function runVariantWithIterations(v, row) {
         refTokenIds: null,
         nPrompt: runCpuPerf ? nPrompt : 0,
         nGen:    runCpuPerf ? nGen    : 0,
+        // CPU baseline keeps depth=0 — its job is reference-token capture
+        // and a single-rep perf comparator, not depth-loaded sweeping.
+        nDepth: 0,
         nReps: 1,
-        nCtx: DEFAULT_N_CTX,
+        nCtx: nCtxFor(0),
         nGpuLayers: 0,
       }, {
         onStatus: (status, msg, sinceMs) => row.setStatus(`cpu/${status}`, msg, sinceMs),
@@ -1525,8 +1545,9 @@ async function runVariantWithIterations(v, row) {
       refTokenIds: refTokenIds || null,
       nPrompt,
       nGen,
+      nDepth,
       nReps,
-      nCtx: DEFAULT_N_CTX,
+      nCtx: nCtxFor(nDepth),
       nGpuLayers: DEFAULT_N_GPU_LAYERS,
     }, {
       onStatus: (s, m, sinceMs) => row.setStatus(`gpu/${s}`, m, sinceMs),
@@ -1605,6 +1626,7 @@ function makeRecord(v, vr, machine, browser, wallTimeMs) {
     nPredict: DEFAULT_N_PREDICT,
     nPrompt: gpu?.metrics?.n_prompt ?? 0,
     nGen: gpu?.metrics?.n_gen ?? 0,
+    nDepth: gpu?.metrics?.n_depth ?? 0,
     nReps: gpu?.metrics?.n_reps ?? 0,
     nGpuLayers: DEFAULT_N_GPU_LAYERS,
     timestamp: new Date().toISOString(),

run.html

@@ -231,6 +231,10 @@
               <label class="filter-label" for="n-gen-input">Gen tokens (-n)</label>
               <input type="number" id="n-gen-input" class="filter-select run-iter-input" value="128" min="0" max="4096" step="1">
             </div>
+            <div class="filter-group">
+              <label class="filter-label" for="n-depth-input">KV depth (-d)</label>
+              <input type="number" id="n-depth-input" class="filter-select run-iter-input" value="2048" min="0" max="32768" step="1">
+            </div>
             <div class="filter-group">
               <label class="filter-label" for="iterations-input">Reps (-r)</label>
               <input type="number" id="iterations-input" class="filter-select run-iter-input" value="5" min="1" max="50" step="1">