wgblas 2.1.0 → 2.2.1

package/src/sger/sger.mjs

@@ -11,18 +11,28 @@ import { extractTimestamp } from "../util/benchmark.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
-import { requireSameDevice } from "../util/device.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
-export async function sger(device, m, n, alpha, x, incx, y, incy, A, lda, layout = "row-major") {
+export async function sger(
+  device,
+  m,
+  n,
+  alpha,
+  x,
+  incx,
+  y,
+  incy,
+  A,
+  lda,
+  layout = "row-major",
+) {
   const AIsGpu = A instanceof GpuMatrix;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
   requireSameDevice(device, "sger", { A, x, y });
   if (layout !== "row-major" && layout !== "column-major")
     throw new Error("layout must be 'row-major' or 'column-major'.");
-  if (typeof alpha !== "number")
-    throw new Error("alpha must be a number.");
+  if (typeof alpha !== "number") throw new Error("alpha must be a number.");
   if (Number.isNaN(alpha)) throw new Error("alpha must not be NaN.");
   if (!Number.isFinite(alpha)) throw new Error("alpha must be finite.");
   if (
@@ -79,9 +89,13 @@ export async function sger(device, m, n, alpha, x, incx, y, incy, A, lda, layout
       "A does not have enough elements for the given m, n, and lda.",
     );
   if (x.length < (m - 1) * incx + 1)
-    throw new Error("x does not have enough elements for the given m and incx.");
+    throw new Error(
+      "x does not have enough elements for the given m and incx.",
+    );
   if (y.length < (n - 1) * incy + 1)
-    throw new Error("y does not have enough elements for the given n and incy.");
+    throw new Error(
+      "y does not have enough elements for the given n and incy.",
+    );
 
   const pipeline = await getPipeline(device, "sger");
 
@@ -94,14 +108,15 @@ export async function sger(device, m, n, alpha, x, incx, y, incy, A, lda, layout
     xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "sger-x", false);
     yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "sger-y", false);
     ABuffer = AIsGpu ? A._buf : uploadBuffer(device, A, "sger-A", true);
-    paramsBuffer = createParamsBuffer(device,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
-        { value: m,     type: "u32" },
-        { value: n,     type: "u32" },
+        { value: m, type: "u32" },
+        { value: n, type: "u32" },
         { value: alpha, type: "f32" },
-        { value: incx,  type: "u32" },
-        { value: incy,  type: "u32" },
-        { value: lda,   type: "u32" },
+        { value: incx, type: "u32" },
+        { value: incy, type: "u32" },
+        { value: lda, type: "u32" },
       ],
       "sger-params",
     );
@@ -116,8 +131,15 @@ export async function sger(device, m, n, alpha, x, incx, y, incy, A, lda, layout
     // One workgroup per row of A; clamped to device limit — the shader's
     // grid-stride loop handles remaining rows when m > dispatch count.
     const wgCount = Math.min(m, device.limits.maxComputeWorkgroupsPerDimension);
-    const { commandEncoder, ts } = runComputePass(device, pipeline, bindGroup, wgCount);
-    const readBuffer = AIsGpu ? null : stageReadback(device, commandEncoder, ABuffer);
+    const { commandEncoder, ts } = runComputePass(
+      device,
+      pipeline,
+      bindGroup,
+      wgCount,
+    );
+    const readBuffer = AIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, ABuffer);
 
     submit(device, commandEncoder);
 

package/src/shaders/__test_pipeline_a.wgsl

@@ -0,0 +1,3 @@
+// Fixture: valid shader, used only by test.pipeline.js's compile-error
+// line-mapping regression test. Not referenced by any routine or by
+// shaders/index.mjs's browser-bundle mapping.

package/src/shaders/__test_pipeline_b.wgsl

@@ -0,0 +1,2 @@
+// Fixture: shader with a deliberate syntax error on the next line.
+this is not valid wgsl syntax;

package/src/shaders/cscal.wgsl

@@ -0,0 +1,33 @@
+// cscal: x := alpha * x, complex. x is one interleaved f32 array
+// (re0, im0, re1, im1, ...), matching Complex32Array/GpuVector's storage
+// (and cuBLAS's cuComplex / stdlib's Complex64Array) — no repacking needed
+// between JS and GPU.
+//   (alphaRe + i*alphaIm)(re + i*im) = (alphaRe*re - alphaIm*im) + i*(alphaRe*im + alphaIm*re)
+
+@group(0) @binding(0) var<storage, read_write> x: array<f32>;
+
+struct Params {
+  n:       u32,
+  alphaRe: f32,
+  alphaIm: f32,
+  x_inc:   u32,
+}
+
+@group(0) @binding(1) var<uniform> params: Params;
+
+const WGS: u32 = 64;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(global_invocation_id) gid: vec3u,
+  @builtin(num_workgroups) num_wg: vec3u,
+) {
+  for (var id = gid.x; id < params.n; id += num_wg.x * WGS) {
+    let base = 2u * id * params.x_inc;
+    // Both new parts need both old parts, so capture them before either write.
+    let re = x[base];
+    let im = x[base + 1u];
+    x[base]      = params.alphaRe * re - params.alphaIm * im;
+    x[base + 1u] = params.alphaRe * im + params.alphaIm * re;
+  }
+}

package/src/shaders/daxpy.wgsl

@@ -0,0 +1,66 @@
+// daxpy: y := alpha * x + y, double-double (Dekker) f64 emulation of saxpy.
+// Each element costs one ddMulProtected (alpha*x[i]) then one ddAddProtected
+// (+ y[i]) — the same two-protected-op shape ddot spends per term, applied
+// straight to the output instead of folded into a reduction. See dscal.wgsl
+// for why this is a uniform main pass plus a ragged, select-masked tail
+// rather than a plain `id < params.n` grid-stride loop.
+
+@group(0) @binding(0) var<storage, read>       xHi: array<f32>;
+@group(0) @binding(1) var<storage, read>       xLo: array<f32>;
+@group(0) @binding(2) var<storage, read_write> yHi: array<f32>;
+@group(0) @binding(3) var<storage, read_write> yLo: array<f32>;
+@group(0) @binding(4) var<uniform> params: Params;
+
+struct Params {
+  n:       u32,
+  alphaHi: f32,
+  alphaLo: f32,
+  x_inc:   u32,
+  y_inc:   u32,
+}
+
+const WGS: u32 = 64;
+
+@compute @workgroup_size(64)
+fn daxpy_main(
+  @builtin(global_invocation_id) gid:    vec3u,
+  @builtin(local_invocation_id)  lid:    vec3u,
+  @builtin(workgroup_id)         wgid:   vec3u,
+  @builtin(num_workgroups)       num_wg: vec3u,
+) {
+  let alpha = DD(params.alphaHi, params.alphaLo);
+  let stride = num_wg.x * WGS;
+
+  let n_floor = (params.n / stride) * stride;
+  let mainIters = n_floor / stride;
+  for (var iter = 0u; iter < mainIters; iter++) {
+    let id = gid.x + iter * stride;
+    let ix = id * params.x_inc;
+    let iy = id * params.y_inc;
+    let prod = ddMulProtected(alpha, DD(xHi[ix], xLo[ix]), lid.x);
+    let result = ddAddProtected(prod, DD(yHi[iy], yLo[iy]), lid.x);
+    yHi[iy] = result.hi;
+    yLo[iy] = result.lo;
+  }
+
+  // Tail is ragged (0 or 1 extra per thread) — pad to this workgroup's worst
+  // case so every thread still calls ddMulProtected/ddAddProtected the same
+  // number of times (their barriers need that), masking only the write.
+  let wgBaseGid = wgid.x * WGS;
+  var tailIters = 0u;
+  if (n_floor + wgBaseGid < params.n) {
+    tailIters = (params.n - 1u - n_floor - wgBaseGid) / stride + 1u;
+  }
+  for (var iter = 0u; iter < tailIters; iter++) {
+    let id = n_floor + gid.x + iter * stride;
+    let valid = id < params.n;
+    let ix = select(0u, id * params.x_inc, valid); // index 0 always in-bounds
+    let iy = select(0u, id * params.y_inc, valid);
+    let prod = ddMulProtected(alpha, DD(xHi[ix], xLo[ix]), lid.x);
+    let result = ddAddProtected(prod, DD(yHi[iy], yLo[iy]), lid.x);
+    if (valid) {
+      yHi[iy] = result.hi;
+      yLo[iy] = result.lo;
+    }
+  }
+}

package/src/shaders/dcopy.wgsl

@@ -0,0 +1,34 @@
+// dcopy: y = x, double-double (Dekker) f64 emulation of scopy. A copy is
+// pure data movement — hi and lo are transferred verbatim, with no
+// arithmetic at all — so (unlike dscal/daxpy/ddot) this needs no
+// ddMulProtected/ddAddProtected renormalizing barrier, and so no
+// ragged-tail-with-barrier split; a plain grid-stride loop is safe, same
+// shape as scopy.wgsl itself.
+
+@group(0) @binding(0) var<storage, read>       xHi: array<f32>;
+@group(0) @binding(1) var<storage, read>       xLo: array<f32>;
+@group(0) @binding(2) var<storage, read_write> yHi: array<f32>;
+@group(0) @binding(3) var<storage, read_write> yLo: array<f32>;
+
+struct Params {
+  n:     u32,
+  x_inc: u32,
+  y_inc: u32,
+}
+
+@group(0) @binding(4) var<uniform> params: Params;
+
+const WGS: u32 = 64;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(global_invocation_id) gid: vec3u,
+  @builtin(num_workgroups) num_wg: vec3u,
+) {
+  for (var id = gid.x; id < params.n; id += num_wg.x * WGS) {
+    let ix = id * params.x_inc;
+    let iy = id * params.y_inc;
+    yHi[iy] = xHi[ix];
+    yLo[iy] = xLo[ix];
+  }
+}

package/src/shaders/ddot.wgsl

@@ -0,0 +1,106 @@
+// ddot: sum(x[i] * y[i]), double-double (Dekker). Same ILP=4 shape as
+// dasum.wgsl, which this mirrors closely — the only structural difference is
+// a second input vector and a product where dasum takes an absolute value.
+//
+// See f64/utils/add.wgsl for ddAddProtected and why plain ddAdd isn't safe,
+// and f64/utils/multiply.wgsl for ddMulProtected. The multiply itself
+// (twoProdBit) needs no barrier; only its final renormalisation does, which
+// is why each element costs two protected ops here against dasum's one.
+
+@group(0) @binding(0) var<storage, read>       xHi:        array<f32>;
+@group(0) @binding(1) var<storage, read>       xLo:        array<f32>;
+@group(0) @binding(2) var<storage, read>       yHi:        array<f32>;
+@group(0) @binding(3) var<storage, read>       yLo:        array<f32>;
+@group(0) @binding(4) var<storage, read_write> partialsHi: array<f32>;
+@group(0) @binding(5) var<storage, read_write> partialsLo: array<f32>;
+@group(0) @binding(6) var<uniform>             params:     Params;
+
+struct Params {
+  n:     u32,
+  x_inc: u32,
+  y_inc: u32,
+}
+
+const WGS: u32 = 64;
+
+var<workgroup> tile: array<DD, 64>;
+
+@compute @workgroup_size(64)
+fn ddot_main(
+  @builtin(global_invocation_id) gid:    vec3u,
+  @builtin(local_invocation_id)  lid:    vec3u,
+  @builtin(workgroup_id)         wgid:   vec3u,
+  @builtin(num_workgroups)       num_wg: vec3u,
+) {
+  var acc0 = DD(0.0, 0.0);
+  var acc1 = DD(0.0, 0.0);
+  var acc2 = DD(0.0, 0.0);
+  var acc3 = DD(0.0, 0.0);
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  // Same trip count for every thread, but driven by a counter, not `id`
+  // itself (the protected ops' barriers need a provably-uniform loop bound).
+  let mainIters = n4_floor / (4u * stride);
+  for (var iter = 0u; iter < mainIters; iter++) {
+    let id =  gid.x + iter * 4u * stride;
+    let d0 =  id;
+    let d1 =  id +      stride;
+    let d2 =  id + 2u * stride;
+    let d3 =  id + 3u * stride;
+
+    let p0 = ddMulProtected(DD(xHi[d0 * params.x_inc], xLo[d0 * params.x_inc]),
+                            DD(yHi[d0 * params.y_inc], yLo[d0 * params.y_inc]), lid.x);
+    let p1 = ddMulProtected(DD(xHi[d1 * params.x_inc], xLo[d1 * params.x_inc]),
+                            DD(yHi[d1 * params.y_inc], yLo[d1 * params.y_inc]), lid.x);
+    let p2 = ddMulProtected(DD(xHi[d2 * params.x_inc], xLo[d2 * params.x_inc]),
+                            DD(yHi[d2 * params.y_inc], yLo[d2 * params.y_inc]), lid.x);
+    let p3 = ddMulProtected(DD(xHi[d3 * params.x_inc], xLo[d3 * params.x_inc]),
+                            DD(yHi[d3 * params.y_inc], yLo[d3 * params.y_inc]), lid.x);
+
+    acc0 = ddAddProtected(acc0, p0, lid.x);
+    acc1 = ddAddProtected(acc1, p1, lid.x);
+    acc2 = ddAddProtected(acc2, p2, lid.x);
+    acc3 = ddAddProtected(acc3, p3, lid.x);
+  }
+
+  // Tail is ragged (0-3 extra per thread) — pad to this workgroup's worst case.
+  // Out-of-range lanes still run the multiply (it carries a barrier, so every
+  // thread must reach it) against index 0, then mask the result to zero.
+  let wgBaseGid = wgid.x * WGS;
+  var tailIters = 0u;
+  if (n4_floor + wgBaseGid < params.n) {
+    tailIters = (params.n - 1u - n4_floor - wgBaseGid) / stride + 1u;
+  }
+  for (var iter = 0u; iter < tailIters; iter++) {
+    let id    = n4_floor + gid.x + iter * stride;
+    let valid = id < params.n;
+    let ix    = select(0u, id * params.x_inc, valid);
+    let iy    = select(0u, id * params.y_inc, valid);
+    let prod  = ddMulProtected(DD(xHi[ix], xLo[ix]), DD(yHi[iy], yLo[iy]), lid.x);
+    // select() has no DD overload
+    let contribution = DD(select(0.0, prod.hi, valid), select(0.0, prod.lo, valid));
+    acc0 = ddAddProtected(acc0, contribution, lid.x);
+  }
+
+  let combined01 = ddAddProtected(acc0, acc1, lid.x);
+  let combined23 = ddAddProtected(acc2, acc3, lid.x);
+  tile[lid.x] = ddAddProtected(combined01, combined23, lid.x);
+  workgroupBarrier();
+
+  // Inactive threads combine against a throwaway partner and discard it
+  // (ddAddProtected must be called unconditionally by every thread).
+  for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+    let partner = select(lid.x, lid.x + s, lid.x < s);
+    let combined = ddAddProtected(tile[lid.x], tile[partner], lid.x);
+    workgroupBarrier(); // all threads must read tile[] above before any write below
+    if (lid.x < s) { tile[lid.x] = combined; }
+    workgroupBarrier();
+  }
+
+  if (lid.x == 0u) {
+    partialsHi[wgid.x] = tile[0].hi;
+    partialsLo[wgid.x] = tile[0].lo;
+  }
+}

package/src/shaders/dnrm2.wgsl

@@ -0,0 +1,167 @@
+// dnrm2: result = sqrt(sum(x[i] * x[i])), double-double (Dekker) f64
+// emulation of snrm2 — same scaled accumulation (Blue's algorithm), just
+// with `scale`/`ssq` as DD pairs (via ddDivProtected/ddMulProtected/
+// ddAddProtected/ddSqrtProtected) instead of plain f32. Squaring still
+// saturates an f32 hi component above ~1.8e19 regardless of DD precision
+// (DD widens the mantissa, not the exponent range), so the scaling is
+// still needed here for the same reason it was in snrm2.
+//
+// snrm2.wgsl's ssqAccum/ssqMerge each branch on which operand is bigger —
+// can't carry over directly, since a protected op's workgroupBarrier()
+// needs every thread to reach the same call site, and here different
+// threads could take different branches. Both formulas are computed
+// unconditionally below; only the final combine (`ddSelect`) differs per
+// thread — same fix shape as drot's/drotm's own per-dispatch flags, just
+// applied to a per-element branch instead.
+//
+// pass 1 dispatches 2*WGS workgroups; pass 2 (reduction/scaledSumF64.wgsl)
+// duplicates ssqAccumProtected/ssqMergeProtected rather than sharing them,
+// same as the plain-f32 pair already does.
+
+@group(0) @binding(0) var<storage, read>       xHi:           array<f32>;
+@group(0) @binding(1) var<storage, read>       xLo:           array<f32>;
+@group(0) @binding(2) var<storage, read_write> partialsScaleHi: array<f32>;
+@group(0) @binding(3) var<storage, read_write> partialsScaleLo: array<f32>;
+@group(0) @binding(4) var<storage, read_write> partialsSsqHi:   array<f32>;
+@group(0) @binding(5) var<storage, read_write> partialsSsqLo:   array<f32>;
+@group(0) @binding(6) var<uniform>             params:        Params;
+
+struct Params {
+  n:     u32,
+  x_inc: u32,
+}
+
+const WGS: u32 = 64;
+
+struct ScaleSsq {
+  scale: DD,
+  ssq:   DD,
+}
+
+fn ddSelect(a: DD, b: DD, cond: bool) -> DD {
+  return DD(select(a.hi, b.hi, cond), select(a.lo, b.lo, cond));
+}
+
+// Folds one more |value| (DD) into a running (scale, ssq) pair — branch-free,
+// see file header. `bigger`/`smaller` name the two operands by magnitude
+// (not by which one was "acc" vs "new"), and biggerIsZero==true only when
+// both scale and absxi are still exactly zero (the very first zero
+// elements, before any nonzero value has been seen) — substituting a safe
+// denominator there avoids a 0/0 without needing a separate branch/return;
+// the arithmetic already reduces to a correct no-op in that case.
+fn ssqAccumProtected(acc: ScaleSsq, absxi: DD, threadSlot: u32) -> ScaleSsq {
+  let isBigger = ddGreater(absxi, acc.scale);
+  let bigger = ddSelect(acc.scale, absxi, isBigger);
+  let smaller = ddSelect(absxi, acc.scale, isBigger);
+  let biggerIsZero = bigger.hi == 0.0;
+  let safeBigger = ddSelect(bigger, DD(1.0, 0.0), biggerIsZero);
+  let r = ddDivProtected(smaller, safeBigger, threadSlot);
+  let rsq = ddMulProtected(r, r, threadSlot);
+  let ssqTimesRsq = ddMulProtected(acc.ssq, rsq, threadSlot);
+  let sumIfBigger = ddAddProtected(DD(1.0, 0.0), ssqTimesRsq, threadSlot);
+  let sumIfNotBigger = ddAddProtected(acc.ssq, rsq, threadSlot);
+  let newSsq = ddSelect(sumIfNotBigger, sumIfBigger, isBigger);
+  return ScaleSsq(bigger, newSsq);
+}
+
+// Associative merge of two independent (scale, ssq) partials — same
+// branch-free shape, for combining ILP lanes and the tree reduction.
+fn ssqMergeProtected(a: ScaleSsq, b: ScaleSsq, threadSlot: u32) -> ScaleSsq {
+  let isBigger = !ddGreater(b.scale, a.scale); // a.scale >= b.scale
+  let bigger = ddSelect(b.scale, a.scale, isBigger);
+  let smaller = ddSelect(a.scale, b.scale, isBigger);
+  let biggerSsq = ddSelect(b.ssq, a.ssq, isBigger);
+  let smallerSsq = ddSelect(a.ssq, b.ssq, isBigger);
+  let biggerIsZero = bigger.hi == 0.0;
+  let safeBigger = ddSelect(bigger, DD(1.0, 0.0), biggerIsZero);
+  let r = ddDivProtected(smaller, safeBigger, threadSlot);
+  let rsq = ddMulProtected(r, r, threadSlot);
+  let smallerSsqTimesRsq = ddMulProtected(smallerSsq, rsq, threadSlot);
+  let newSsq = ddAddProtected(biggerSsq, smallerSsqTimesRsq, threadSlot);
+  return ScaleSsq(bigger, newSsq);
+}
+
+var<workgroup> tileScaleHi: array<f32, 64>;
+var<workgroup> tileScaleLo: array<f32, 64>;
+var<workgroup> tileSsqHi:   array<f32, 64>;
+var<workgroup> tileSsqLo:   array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn dnrm2_main(
+  @builtin(global_invocation_id) gid:    vec3u,
+  @builtin(local_invocation_id)  lid:    vec3u,
+  @builtin(workgroup_id)         wgid:   vec3u,
+  @builtin(num_workgroups)       num_wg: vec3u,
+) {
+  var acc0 = ScaleSsq(DD(0.0, 0.0), DD(1.0, 0.0));
+  var acc1 = ScaleSsq(DD(0.0, 0.0), DD(1.0, 0.0));
+  var acc2 = ScaleSsq(DD(0.0, 0.0), DD(1.0, 0.0));
+  var acc3 = ScaleSsq(DD(0.0, 0.0), DD(1.0, 0.0));
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  // Same trip count for every thread, driven by a counter (protected ops'
+  // barriers need a provably-uniform loop bound) — see dasum.wgsl.
+  let mainIters = n4_floor / (4u * stride);
+  for (var iter = 0u; iter < mainIters; iter++) {
+    let id =  gid.x + iter * 4u * stride;
+    let i0 =  id                * params.x_inc;
+    let i1 = (id +      stride) * params.x_inc;
+    let i2 = (id + 2u * stride) * params.x_inc;
+    let i3 = (id + 3u * stride) * params.x_inc;
+    acc0 = ssqAccumProtected(acc0, ddAbs(DD(xHi[i0], xLo[i0])), lid.x);
+    acc1 = ssqAccumProtected(acc1, ddAbs(DD(xHi[i1], xLo[i1])), lid.x);
+    acc2 = ssqAccumProtected(acc2, ddAbs(DD(xHi[i2], xLo[i2])), lid.x);
+    acc3 = ssqAccumProtected(acc3, ddAbs(DD(xHi[i3], xLo[i3])), lid.x);
+  }
+
+  // Tail is ragged (0-3 extra per thread) — pad to this workgroup's worst
+  // case, masking an invalid element to exactly 0 (contributes nothing).
+  let wgBaseGid = wgid.x * WGS;
+  var tailIters = 0u;
+  if (n4_floor + wgBaseGid < params.n) {
+    tailIters = (params.n - 1u - n4_floor - wgBaseGid) / stride + 1u;
+  }
+  for (var iter = 0u; iter < tailIters; iter++) {
+    let id    = n4_floor + gid.x + iter * stride;
+    let valid = id < params.n;
+    let i     = select(0u, id * params.x_inc, valid); // index 0 always in-bounds
+    let loaded = ddAbs(DD(xHi[i], xLo[i]));
+    let contribution = DD(select(0.0, loaded.hi, valid), select(0.0, loaded.lo, valid));
+    acc0 = ssqAccumProtected(acc0, contribution, lid.x);
+  }
+
+  let combined01 = ssqMergeProtected(acc0, acc1, lid.x);
+  let combined23 = ssqMergeProtected(acc2, acc3, lid.x);
+  let combined = ssqMergeProtected(combined01, combined23, lid.x);
+  tileScaleHi[lid.x] = combined.scale.hi;
+  tileScaleLo[lid.x] = combined.scale.lo;
+  tileSsqHi[lid.x]   = combined.ssq.hi;
+  tileSsqLo[lid.x]   = combined.ssq.lo;
+  workgroupBarrier();
+
+  // Inactive threads merge against a throwaway partner and discard it
+  // (ssqMergeProtected must be called unconditionally by every thread).
+  for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+    let partner = select(lid.x, lid.x + s, lid.x < s);
+    let a = ScaleSsq(DD(tileScaleHi[lid.x], tileScaleLo[lid.x]), DD(tileSsqHi[lid.x], tileSsqLo[lid.x]));
+    let b = ScaleSsq(DD(tileScaleHi[partner], tileScaleLo[partner]), DD(tileSsqHi[partner], tileSsqLo[partner]));
+    let merged = ssqMergeProtected(a, b, lid.x);
+    workgroupBarrier(); // all threads must read tile[] above before any write below
+    if (lid.x < s) {
+      tileScaleHi[lid.x] = merged.scale.hi;
+      tileScaleLo[lid.x] = merged.scale.lo;
+      tileSsqHi[lid.x]   = merged.ssq.hi;
+      tileSsqLo[lid.x]   = merged.ssq.lo;
+    }
+    workgroupBarrier();
+  }
+
+  if (lid.x == 0u) {
+    partialsScaleHi[wgid.x] = tileScaleHi[0];
+    partialsScaleLo[wgid.x] = tileScaleLo[0];
+    partialsSsqHi[wgid.x]   = tileSsqHi[0];
+    partialsSsqLo[wgid.x]   = tileSsqLo[0];
+  }
+}

package/src/shaders/drot.wgsl

@@ -0,0 +1,81 @@
+// drot: x = c*x + s*y, y = -s*x + c*y — double-double (Dekker) f64 emulation
+// of srot. c, s, x, and y are each split into an f32 (hi, lo) pair. Each
+// element costs four ddMulProtected (c*x, s*y, -s*x, c*y) then two
+// ddAddProtected (the two sums) — negS is computed once outside the loop
+// via bitcast negation (exact, no rounding, so no barrier needed there)
+// rather than adding a DD-subtract helper. See dscal.wgsl for why this is a
+// uniform main pass plus a ragged, select-masked tail rather than a plain
+// `id < params.n` grid-stride loop.
+
+@group(0) @binding(0) var<storage, read_write> xHi: array<f32>;
+@group(0) @binding(1) var<storage, read_write> xLo: array<f32>;
+@group(0) @binding(2) var<storage, read_write> yHi: array<f32>;
+@group(0) @binding(3) var<storage, read_write> yLo: array<f32>;
+@group(0) @binding(4) var<uniform> params: Params;
+
+struct Params {
+  n:     u32,
+  cHi:   f32,
+  cLo:   f32,
+  sHi:   f32,
+  sLo:   f32,
+  x_inc: u32,
+  y_inc: u32,
+}
+
+const WGS: u32 = 64;
+
+@compute @workgroup_size(64)
+fn drot_main(
+  @builtin(global_invocation_id) gid:    vec3u,
+  @builtin(local_invocation_id)  lid:    vec3u,
+  @builtin(workgroup_id)         wgid:   vec3u,
+  @builtin(num_workgroups)       num_wg: vec3u,
+) {
+  let c = DD(params.cHi, params.cLo);
+  let s = DD(params.sHi, params.sLo);
+  let negS = DD(negf(params.sHi), negf(params.sLo));
+  let stride = num_wg.x * WGS;
+
+  let n_floor = (params.n / stride) * stride;
+  let mainIters = n_floor / stride;
+  for (var iter = 0u; iter < mainIters; iter++) {
+    let id = gid.x + iter * stride;
+    let ix = id * params.x_inc;
+    let iy = id * params.y_inc;
+    let xi = DD(xHi[ix], xLo[ix]);
+    let yi = DD(yHi[iy], yLo[iy]);
+    let xNew = ddAddProtected(ddMulProtected(c, xi, lid.x), ddMulProtected(s, yi, lid.x), lid.x);
+    let yNew = ddAddProtected(ddMulProtected(negS, xi, lid.x), ddMulProtected(c, yi, lid.x), lid.x);
+    xHi[ix] = xNew.hi;
+    xLo[ix] = xNew.lo;
+    yHi[iy] = yNew.hi;
+    yLo[iy] = yNew.lo;
+  }
+
+  // Tail is ragged (0 or 1 extra per thread) — pad to this workgroup's worst
+  // case so every thread in the workgroup still calls ddMulProtected/
+  // ddAddProtected the same number of times (their barriers need that),
+  // masking only the write.
+  let wgBaseGid = wgid.x * WGS;
+  var tailIters = 0u;
+  if (n_floor + wgBaseGid < params.n) {
+    tailIters = (params.n - 1u - n_floor - wgBaseGid) / stride + 1u;
+  }
+  for (var iter = 0u; iter < tailIters; iter++) {
+    let id = n_floor + gid.x + iter * stride;
+    let valid = id < params.n;
+    let ix = select(0u, id * params.x_inc, valid); // index 0 always in-bounds
+    let iy = select(0u, id * params.y_inc, valid);
+    let xi = DD(xHi[ix], xLo[ix]);
+    let yi = DD(yHi[iy], yLo[iy]);
+    let xNew = ddAddProtected(ddMulProtected(c, xi, lid.x), ddMulProtected(s, yi, lid.x), lid.x);
+    let yNew = ddAddProtected(ddMulProtected(negS, xi, lid.x), ddMulProtected(c, yi, lid.x), lid.x);
+    if (valid) {
+      xHi[ix] = xNew.hi;
+      xLo[ix] = xNew.lo;
+      yHi[iy] = yNew.hi;
+      yLo[iy] = yNew.lo;
+    }
+  }
+}