wgblas 1.1.0 → 1.2.0

package/index.d.mts

@@ -6,6 +6,7 @@ export { GpuMatrix } from "./src/classes/GpuMatrix.mjs";
 export {
   randomFloat32Array,
   randomFloat64Array,
+  randomTriangularFloat32Array,
 } from "./src/random/random.mjs";
 export { sscal } from "./src/sscal/sscal.mjs";
 export { sswap } from "./src/sswap/sswap.mjs";

package/index.mjs

@@ -4,6 +4,7 @@ export { GpuMatrix } from "./src/classes/GpuMatrix.mjs";
 export {
   randomFloat32Array,
   randomFloat64Array,
+  randomTriangularFloat32Array,
 } from "./src/random/random.mjs";
 export { sscal } from "./src/sscal/sscal.mjs";
 export { sswap } from "./src/sswap/sswap.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wgblas",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "BLAS on WebGPU",
   "type": "module",
   "main": "index.mjs",

package/src/classes/GpuMatrix.d.mts

@@ -32,9 +32,12 @@ export declare class GpuMatrix {
 
   /**
    * Uploads a Float32Array or Float64Array matrix to GPU memory, row-major
-   * or column-major. A Float64Array is packed as two f32s per element (WGSL
-   * has no f64 type) and stored across two GPU buffers internally; `read()`
-   * reassembles the original doubles.
+   * or column-major. A Float64Array is split into a double-double (hi, lo)
+   * f32 pair per element (WGSL has no f64 type) and stored across two GPU
+   * buffers internally; `read()` reassembles doubles from these pairs. This
+   * gives ~48 bits of mantissa (vs. 24 for a single f32) but less than true
+   * f64 precision (52 bits), so round-tripped values are not always
+   * bit-exact with the original input.
    *
    * `rows`/`cols` always describe the logical shape regardless of layout.
    * `lda` defaults to `cols` (row-major) or `rows` (column-major) — dense, no

package/src/classes/GpuMatrix.mjs

@@ -1,15 +1,12 @@
 import { getDevice } from "../init.mjs";
 import { uploadBuffer, stageReadback } from "../util/buffer.mjs";
 import { extractResult } from "../util/result.mjs";
-import { packF64, unpackF64 } from "../util/f64pack.mjs";
+import { splitDoubleDouble, mergeDoubleDouble } from "../util/f64.mjs";
 
 export class GpuMatrix {
-  constructor(buffer, rows, cols, lda, auxBuffer = null, layout = "row-major") {
+  constructor(buffer, rows, cols, lda, loBuffer = null, layout = "row-major") {
     this._buf = buffer;
-    // Non-null only for Float64Array-backed matrices — see GpuVector for why
-    // (packF64 splits each element into a "main"/_buf f32 and "aux"/_auxBuf
-    // raw u32 — never a Float32Array, see f64pack.mjs).
-    this._auxBuf = auxBuffer;
+    this._loBuf = loBuffer; // Non-null only for Float64Array-backed matrices
     this.rows = rows;
     this.cols = cols;
     this.lda  = lda;
@@ -50,16 +47,10 @@ export class GpuMatrix {
 
     if (data instanceof Float64Array) {
       const n = outerCount * lda;
-      const main = new Float32Array(n);
-      const aux = new Uint32Array(n);
-      for (let i = 0; i < n; i++) {
-        const packed = packF64(data[i]);
-        main[i] = packed[0];
-        aux[i] = packed[1];
-      }
-      const mainBuf = uploadBuffer(main, "gpu-matrix-f64-main", true);
-      const auxBuf = uploadBuffer(aux, "gpu-matrix-f64-aux", true);
-      return new GpuMatrix(mainBuf, rows, cols, lda, auxBuf, layout);
+      const { hi, lo } = splitDoubleDouble(data.subarray(0, n));
+      const hiBuf = uploadBuffer(hi, "gpu-matrix-f64-hi", true);
+      const loBuf = uploadBuffer(lo, "gpu-matrix-f64-lo", true);
+      return new GpuMatrix(hiBuf, rows, cols, lda, loBuf, layout);
     }
 
     const buf = uploadBuffer(data.subarray(0, outerCount * lda), "gpu-matrix", true);
@@ -76,17 +67,16 @@ export class GpuMatrix {
     const outerCount = isRowMajor ? this.rows : this.cols;
     const innerLen   = isRowMajor ? this.cols : this.rows;
 
-    if (this._auxBuf) {
-      const encAux = device.createCommandEncoder();
-      const rbAux = stageReadback(encAux, this._auxBuf);
-      device.queue.submit([encAux.finish()]);
+    if (this._loBuf) {
+      const encLo = device.createCommandEncoder();
+      const rbLo = stageReadback(encLo, this._loBuf);
+      device.queue.submit([encLo.finish()]);
 
-      const [main, aux] = await Promise.all([
+      const [hi, lo] = await Promise.all([
         extractResult(rb, Float32Array),
-        extractResult(rbAux, Uint32Array),
+        extractResult(rbLo, Float32Array),
       ]);
-      const raw = new Float64Array(outerCount * this.lda);
-      for (let i = 0; i < raw.length; i++) raw[i] = unpackF64(main[i], aux[i]);
+      const raw = mergeDoubleDouble(hi, lo);
       if (this.lda === innerLen) return raw;
       const out = new Float64Array(outerCount * innerLen);
       for (let r = 0; r < outerCount; r++)
@@ -104,6 +94,6 @@ export class GpuMatrix {
 
   destroy() {
     this._buf.destroy();
-    if (this._auxBuf) this._auxBuf.destroy();
+    if (this._loBuf) this._loBuf.destroy();
   }
 }

package/src/classes/GpuVector.d.mts

@@ -17,8 +17,11 @@ export declare class GpuVector {
 
   /**
    * Uploads a Float32Array or Float64Array to GPU memory. A Float64Array is
-   * packed as two f32s per element (WGSL has no f64 type) and stored across
-   * two GPU buffers internally; `read()` reassembles the original doubles.
+   * split into a double-double (hi, lo) f32 pair per element (WGSL has no
+   * f64 type) and stored across two GPU buffers internally; `read()`
+   * reassembles doubles from these pairs. This gives ~48 bits of mantissa
+   * (vs. 24 for a single f32) but less than true f64 precision (52 bits), so
+   * round-tripped values are not always bit-exact with the original input.
    *
    * @param data - input vector data
    * @returns GpuVector backed by a GPU buffer

package/src/classes/GpuVector.mjs

@@ -1,28 +1,22 @@
 import { getDevice } from "../init.mjs";
 import { uploadBuffer, stageReadback } from "../util/buffer.mjs";
 import { extractResult } from "../util/result.mjs";
-import { packF64, unpackF64 } from "../util/f64pack.mjs";
+import { splitDoubleDouble, mergeDoubleDouble } from "../util/f64.mjs";
 
 export class GpuVector {
-  constructor(buffer, length, dtype = Float32Array, auxBuffer = null) {
+  constructor(buffer, length, dtype = Float32Array, loBuffer = null) {
     this._buf = buffer;
-    this._auxBuf = auxBuffer;
+    this._loBuf = loBuffer; // Non-null only for Float64Array-backed vectors
     this.length = length;
     this.dtype = dtype;
   }
 
   static from(data) {
     if (data instanceof Float64Array) {
-      const main = new Float32Array(data.length);
-      const aux = new Uint32Array(data.length);
-      for (let i = 0; i < data.length; i++) {
-        const packed = packF64(data[i]);
-        main[i] = packed[0];
-        aux[i] = packed[1];
-      }
-      const mainBuf = uploadBuffer(main, "gpu-vector-f64-main", true);
-      const auxBuf = uploadBuffer(aux, "gpu-vector-f64-aux", true);
-      return new GpuVector(mainBuf, data.length, Float64Array, auxBuf);
+      const { hi, lo } = splitDoubleDouble(data);
+      const hiBuf = uploadBuffer(hi, "gpu-vector-f64-hi", true);
+      const loBuf = uploadBuffer(lo, "gpu-vector-f64-lo", true);
+      return new GpuVector(hiBuf, data.length, Float64Array, loBuf);
     }
     if (!(data instanceof Float32Array)) {
       throw new Error("GpuVector.from expects a Float32Array or Float64Array.");
@@ -37,23 +31,21 @@ export class GpuVector {
     const rb = stageReadback(enc, this._buf);
     device.queue.submit([enc.finish()]);
 
-    if (!this._auxBuf) return extractResult(rb, this.dtype);
+    if (!this._loBuf) return extractResult(rb, this.dtype);
 
-    const encAux = device.createCommandEncoder();
-    const rbAux = stageReadback(encAux, this._auxBuf);
-    device.queue.submit([encAux.finish()]);
+    const encLo = device.createCommandEncoder();
+    const rbLo = stageReadback(encLo, this._loBuf);
+    device.queue.submit([encLo.finish()]);
 
-    const [main, aux] = await Promise.all([
+    const [hi, lo] = await Promise.all([
       extractResult(rb, Float32Array),
-      extractResult(rbAux, Uint32Array),
+      extractResult(rbLo, Float32Array),
     ]);
-    const out = new Float64Array(this.length);
-    for (let i = 0; i < this.length; i++) out[i] = unpackF64(main[i], aux[i]);
-    return out;
+    return mergeDoubleDouble(hi, lo);
   }
 
   destroy() {
     this._buf.destroy();
-    if (this._auxBuf) this._auxBuf.destroy();
+    if (this._loBuf) this._loBuf.destroy();
   }
 }

package/src/dasum/dasum.d.mts

@@ -1,10 +1,13 @@
 import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
- * Computes the sum of absolute values of a vector of doubles in double
- * precision: result = sum(|x[i]|). Each element of `x` is packed into a
- * [main, aux] f32 pair (see `packF64`/`GpuVector`) since WGSL has no f64
- * type; accumulation is done with f64add.wgsl's IEEE-754 binary64 addition.
+ * Computes the sum of absolute values of a vector of doubles in extended
+ * precision: result = sum(|x[i]|). Each element of `x` has abs() applied,
+ * then is split into a (hi, lo) double-double f32 pair (see
+ * `splitDoubleDouble`/`f64.mjs`) since WGSL has no f64 type; accumulation
+ * uses Dekker's double-double algorithm (see `shaders/f64/dekker.wgsl`), giving ~48 bits
+ * of mantissa — more than a single f32 (24 bits) but less than true f64
+ * (52 bits), so results are not bit-exact with a CPU double.
  *
  * {@includeCode ../../examples/dasum/dasum.js}
  *

package/src/dasum/dasum.mjs

@@ -4,14 +4,15 @@ import {
   createResultBuffer,
   stageReadback,
   destroyBuffers,
+  uploadBuffer,
 } from "../util/buffer.mjs";
 import { createBindGroup } from "../util/bindgroup.mjs";
 import { runComputePass, submit } from "../util/compute.mjs";
 import { extractTimestamp } from "../util/benchmark.mjs";
 import { extractResult } from "../util/result.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
-import { unpackF64 } from "../util/f64pack.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
+import { splitDoubleDouble, mergeDoubleDouble } from "../util/f64.mjs";
 
 const WGS = 64; // workgroup size
 
@@ -33,29 +34,34 @@ export async function dasum(device, n, x, incx) {
       "x does not have enough elements for the given n and incx.",
     );
 
-  // dasum.wgsl/reduction/sumF64.wgsl are each concatenated with f64add.wgsl
-  // (reusing its decode/encode/computeSum/Packed — WGSL has no #include).
-  // f64add.wgsl declares no bindings/entry point of its own, so each
-  // concatenated module has exactly one @compute entry — omitting entryPoint
-  // here lets getPipeline auto-detect it, the stable path (see pipeline.mjs).
-  const pipelineMain = await getPipeline(device, ["f64add", "dasum"]);
-  const pipelineReduce = await getPipeline(device, ["f64add", "reduction/sumF64"]);
+  // Concatenated with f64/dekker.wgsl for its DD struct/ddAdd helpers (WGSL
+  // has no #include); entryPoint omitted since each module has only one @compute.
+  const pipelineMain = await getPipeline(device, ["f64/dekker", "dasum"]);
+  const pipelineReduce = await getPipeline(device, ["f64/dekker", "reduction/sumF64"]);
 
-  let xVec = null;
-  let partialsMainBuffer = null;
-  let partialsAuxBuffer = null;
-  let resultMainBuffer = null;
-  let resultAuxBuffer = null;
+  let xHiBuffer = null;
+  let xLoBuffer = null;
+  let partialsHiBuffer = null;
+  let partialsLoBuffer = null;
+  let resultHiBuffer = null;
+  let resultLoBuffer = null;
   let paramsBuffer = null;
-  let readMainBuffer = null;
-  let readAuxBuffer = null;
+  let readHiBuffer = null;
+  let readLoBuffer = null;
 
   try {
-    xVec = xIsGpu ? x : GpuVector.from(x);
-    partialsMainBuffer = createStorageBuffer(2 * WGS * 4, "dasum-partialsMain"); // 2*WGS partial sums, main halves
-    partialsAuxBuffer = createStorageBuffer(2 * WGS * 4, "dasum-partialsAux"); // 2*WGS partial sums, aux halves (raw u32 bits)
-    resultMainBuffer = createResultBuffer(4, "dasum-result-main"); // final main half
-    resultAuxBuffer = createResultBuffer(4, "dasum-result-aux"); // final aux half (raw u32 bits)
+    if (xIsGpu) {
+      xHiBuffer = x._buf;
+      xLoBuffer = x._loBuf;
+    } else {
+      const { hi, lo } = splitDoubleDouble(x.map(Math.abs));
+      xHiBuffer = uploadBuffer(hi, "dasum-xHi", false);
+      xLoBuffer = uploadBuffer(lo, "dasum-xLo", false);
+    }
+    partialsHiBuffer = createStorageBuffer(2 * WGS * 4, "dasum-partialsHi");
+    partialsLoBuffer = createStorageBuffer(2 * WGS * 4, "dasum-partialsLo");
+    resultHiBuffer = createResultBuffer(4, "dasum-result-hi");
+    resultLoBuffer = createResultBuffer(4, "dasum-result-lo");
     paramsBuffer = createParamsBuffer(
       [
         { value: n, type: "u32" },
@@ -66,7 +72,7 @@ export async function dasum(device, n, x, incx) {
 
     const bgMain = createBindGroup(
       pipelineMain.getBindGroupLayout(0),
-      [xVec._buf, xVec._auxBuf, partialsMainBuffer, partialsAuxBuffer, paramsBuffer],
+      [xHiBuffer, xLoBuffer, partialsHiBuffer, partialsLoBuffer, paramsBuffer],
     );
     const { commandEncoder: enc1, ts: ts1 } = runComputePass(
       pipelineMain,
@@ -78,44 +84,45 @@ export async function dasum(device, n, x, incx) {
 
     const bgReduce = createBindGroup(
       pipelineReduce.getBindGroupLayout(0),
-      [partialsMainBuffer, partialsAuxBuffer, resultMainBuffer, resultAuxBuffer],
+      [partialsHiBuffer, partialsLoBuffer, resultHiBuffer, resultLoBuffer],
     );
     const { commandEncoder: enc2, ts: ts2 } = runComputePass(
       pipelineReduce,
       bgReduce,
       1,
     ); // dispatch 1 workgroup to reduce the partial sums to a single result
-    readMainBuffer = stageReadback(enc2, resultMainBuffer);
-    readAuxBuffer = stageReadback(enc2, resultAuxBuffer);
+    readHiBuffer = stageReadback(enc2, resultHiBuffer);
+    readLoBuffer = stageReadback(enc2, resultLoBuffer);
 
     submit(enc2);
 
-    const mainPromise = extractResult(readMainBuffer, Float32Array);
-    const auxPromise = extractResult(readAuxBuffer, Uint32Array);
-    readMainBuffer = null; // ownership transferred — extractResult's own finally destroys it
-    readAuxBuffer = null;
+    const hiPromise = extractResult(readHiBuffer, Float32Array);
+    const loPromise = extractResult(readLoBuffer, Float32Array);
+    readHiBuffer = null; // ownership transferred — extractResult's own finally destroys it
+    readLoBuffer = null;
 
-    const [gpuTime1, gpuTime2, mainArr, auxArr] = await Promise.all([
+    const [gpuTime1, gpuTime2, hiArr, loArr] = await Promise.all([
       extractTimestamp(ts1),
       extractTimestamp(ts2),
-      mainPromise,
-      auxPromise,
+      hiPromise,
+      loPromise,
     ]);
 
     // asum is always a scalar readback — both paths return { asum }
-    const asum = unpackF64(mainArr[0], auxArr[0]);
+    const asum = mergeDoubleDouble(hiArr, loArr)[0];
     if (gpuTime1 !== undefined && gpuTime2 !== undefined)
       return { asum, gpuTimeMs: gpuTime1 + gpuTime2 };
     return { asum };
   } finally {
-    if (!xIsGpu && xVec) xVec.destroy();
-    if (partialsMainBuffer) destroyBuffers(partialsMainBuffer);
-    if (partialsAuxBuffer) destroyBuffers(partialsAuxBuffer);
-    if (resultMainBuffer) destroyBuffers(resultMainBuffer);
-    if (resultAuxBuffer) destroyBuffers(resultAuxBuffer);
+    if (!xIsGpu && xHiBuffer) destroyBuffers(xHiBuffer);
+    if (!xIsGpu && xLoBuffer) destroyBuffers(xLoBuffer);
+    if (partialsHiBuffer) destroyBuffers(partialsHiBuffer);
+    if (partialsLoBuffer) destroyBuffers(partialsLoBuffer);
+    if (resultHiBuffer) destroyBuffers(resultHiBuffer);
+    if (resultLoBuffer) destroyBuffers(resultLoBuffer);
     if (paramsBuffer) destroyBuffers(paramsBuffer);
     // Only reached if submit(enc2) threw before ownership was transferred above.
-    if (readMainBuffer) destroyBuffers(readMainBuffer);
-    if (readAuxBuffer) destroyBuffers(readAuxBuffer);
+    if (readHiBuffer) destroyBuffers(readHiBuffer);
+    if (readLoBuffer) destroyBuffers(readLoBuffer);
   }
 }

package/src/shaders/browser-shaders.mjs

@@ -19,6 +19,7 @@ import sger from "./sger.wgsl";
 import ssyr from "./ssyr.wgsl";
 import ssyr2 from "./ssyr2.wgsl";
 import f64add from "./f64add.wgsl";
+import dekker from "./f64/dekker.wgsl";
 import dasum from "./dasum.wgsl";
 import strsv_invert_block from "./strsv_invert_block.wgsl";
 import strsv_apply_inverse from "./strsv_apply_inverse.wgsl";
@@ -46,6 +47,7 @@ export const shaderSources = {
   ssyr,
   ssyr2,
   f64add,
+  "f64/dekker": dekker,
   dasum,
   strsv_invert_block,
   strsv_apply_inverse,

package/src/shaders/dasum.wgsl

@@ -1,36 +1,12 @@
-// dasum: result = sum(|x[i]|)
-// pass 1 dispatches exactly 2 * WGS workgroups; pass 2 uses reduction/sumF64.wgsl.
-// Same structure as sasum.wgsl — every value is now a [main, aux] pair
-// (see src/util/f64pack.mjs) and every `+`/`+=` is computeSum via addPair
-// instead of plain f32 addition. Concatenated after f64add.wgsl by
-// getPipeline (WGSL has no #include), reusing its decode/encode/computeSum/
-// addFields and Packed struct — f64add.wgsl declares no bindings and no entry
-// point of its own (just helper functions), so bindings here start at 0 and
-// the entry point is simply `dasum_main`.
-//
-// xAux/partialsAux are array<u32>, not array<f32> — aux's bits must never
-// pass through an f32-typed storage slot (NaN-bit-pattern corruption risk,
-// see f64pack.mjs and the Packed struct comment above decode()/encode() in
-// f64add.wgsl); Packed (from f64add.wgsl) keeps aux as u32 in registers/
-// workgroup memory too.
-//
-// Per-thread accumulation (acc0..acc3) stays in DECODED Fields form for the
-// entire strided loop below, via addFields — not re-encoded to Packed and
-// re-decoded on every single element like a naive version would. Only the
-// freshly-loaded x[idx] needs decoding each iteration (unavoidable, it's new
-// data every time); the running total never leaves Fields form until the
-// four accumulators are combined and encoded exactly once, right before
-// writing into workgroup-shared `tile`. The cross-thread reduction tree
-// after that still goes through Packed per level (unavoidable — each level
-// combines values that live in different threads' registers via shared
-// memory), but that's a fixed 6 levels regardless of n, unlike the strided
-// loop above whose iteration count scales with n.
+// dasum: sum(|x[i]|), double-double (Dekker). Same ILP=4 shape as sasum.wgsl;
+// see f64/dekker.wgsl for ddAddProtected and why plain ddAdd isn't safe.
+// GpuVector input isn't pre-abs'd, so ddAbs() applies unconditionally below.
 
-@group(0) @binding(0) var<storage, read>       xMain:        array<f32>;
-@group(0) @binding(1) var<storage, read>       xAux:         array<u32>;
-@group(0) @binding(2) var<storage, read_write> partialsMain: array<f32>;
-@group(0) @binding(3) var<storage, read_write> partialsAux:  array<u32>;
-@group(0) @binding(4) var<uniform>             params:       Params;
+@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> partialsHi: array<f32>;
+@group(0) @binding(3) var<storage, read_write> partialsLo: array<f32>;
+@group(0) @binding(4) var<uniform>             params:     Params;
 
 struct Params {
   n:     u32,
@@ -39,21 +15,7 @@ struct Params {
 
 const WGS: u32 = 64;
 
-var<workgroup> tile: array<Packed, 64>;
-
-// a + b, where a/b are [main, aux] pairs — computeSum takes decoded Fields.
-// Only used for the cross-thread reduction tree below; the per-thread
-// strided loop uses addFields directly instead (see module comment).
-fn addPair(a: Packed, b: Packed) -> Packed {
-  return computeSum(decode(bitcast<u32>(a.main), a.aux), decode(bitcast<u32>(b.main), b.aux));
-}
-
-// |x| for a packed double is abs(main) with aux untouched — only main's
-// sign bit carries the double's sign (see fieldsToPacked() in f64pack.mjs).
-// Returns decoded Fields directly (not Packed) for the per-thread loop.
-fn absFields(idx: u32) -> Fields {
-  return decode(bitcast<u32>(abs(xMain[idx])), xAux[idx]);
-}
+var<workgroup> tile: array<DD, 64>;
 
 @compute @workgroup_size(64)
 fn dasum_main(
@@ -62,37 +24,61 @@ fn dasum_main(
   @builtin(workgroup_id)         wgid:   vec3u,
   @builtin(num_workgroups)       num_wg: vec3u,
 ) {
-  var acc0: Fields = Fields(0u, 0u, 0u, 0u);
-  var acc1: Fields = Fields(0u, 0u, 0u, 0u);
-  var acc2: Fields = Fields(0u, 0u, 0u, 0u);
-  var acc3: Fields = Fields(0u, 0u, 0u, 0u);
+  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);
 
-  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
-    acc0 = addFields(acc0, absFields( id                * params.x_inc));
-    acc1 = addFields(acc1, absFields((id +      stride) * params.x_inc));
-    acc2 = addFields(acc2, absFields((id + 2u * stride) * params.x_inc));
-    acc3 = addFields(acc3, absFields((id + 3u * stride) * params.x_inc));
+  // Same trip count for every thread, but driven by a counter, not `id`
+  // itself (ddAddProtected's barrier needs 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 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 = ddAddProtected(acc0, ddAbs(DD(xHi[i0], xLo[i0])), lid.x);
+    acc1 = ddAddProtected(acc1, ddAbs(DD(xHi[i1], xLo[i1])), lid.x);
+    acc2 = ddAddProtected(acc2, ddAbs(DD(xHi[i2], xLo[i2])), lid.x);
+    acc3 = ddAddProtected(acc3, ddAbs(DD(xHi[i3], xLo[i3])), lid.x);
+  }
+
+  // Tail is ragged (0-3 extra per thread) — pad to this workgroup's worst case.
+  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 id = n4_floor + gid.x; id < params.n; id += stride) {
-    acc0 = addFields(acc0, absFields(id * params.x_inc));
+  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);
+    let loaded = ddAbs(DD(xHi[i], xLo[i])); // select() has no DD overload
+    let contribution = DD(select(0.0, loaded.hi, valid), select(0.0, loaded.lo, valid));
+    acc0 = ddAddProtected(acc0, contribution, lid.x);
   }
 
-  // Combine the 4 per-thread accumulators in Fields form too — still no
-  // encode/decode needed, since none of them have touched Packed yet.
-  let combined = addFields(addFields(acc0, acc1), addFields(acc2, acc3));
-  tile[lid.x] = encode(combined.sign, combined.rawExp, combined.mantissaHi, combined.lo);
+  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) {
-    if (lid.x < s) { tile[lid.x] = addPair(tile[lid.x], tile[lid.x + s]); }
+    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) {
-    partialsMain[wgid.x] = tile[0].main;
-    partialsAux[wgid.x] = tile[0].aux;
+    partialsHi[wgid.x] = tile[0].hi;
+    partialsLo[wgid.x] = tile[0].lo;
   }
 }

package/src/shaders/f64/dekker.wgsl

@@ -0,0 +1,99 @@
+// Double-double arithmetic via Dekker's algorithm — an alternative to
+// f64add.wgsl's bit-exact IEEE-754 emulation. Doesn't touch that path.
+//
+// A double-double number is a pair (hi, lo) of f32 with hi+lo approximating
+// a higher-precision value, hi holding the leading bits and lo the rounding
+// error hi lost. ~48 bits of mantissa vs f32's 24, less than real f64's 52.
+//
+// No bindings, no entry point — a helper library, concatenated with a
+// consumer's own bindings/entry point by getPipeline (WGSL has no #include).
+
+struct DD {
+  hi: f32,
+  lo: f32,
+}
+
+// |a| for a double-double pair. Negation is exact (no rounding), so this is
+// just a sign flip on both components — hi alone determines the pair's sign.
+fn ddAbs(a: DD) -> DD {
+  if (a.hi < 0.0) {
+    return DD(-a.hi, -a.lo);
+  }
+  return a;
+}
+
+// ── A real compiler bug — read before touching anything below ──────────────
+//
+// twoSum/fastTwoSum's error term `e` should be nonzero (that's the point —
+// `s` is rounded). A front-end-optimizer bug zeros it anyway, on both NVIDIA
+// and Mesa (ANV + llvmpipe), via two different mechanisms needing two fixes:
+// bitcast-based subtraction (`fsub`/`negf`, fixes NVIDIA) and materializing
+// the sum through workgroup memory + workgroupBarrier() (fixes Mesa). Only
+// both together (ddAddProtected) is verified correct everywhere — the plain
+// twoSum/fastTwoSum/ddAdd below are reference-only, not safe to use.
+fn negf(x: f32) -> f32 {
+  return bitcast<f32>(bitcast<u32>(x) ^ 0x80000000u);
+}
+fn fsub(a: f32, b: f32) -> f32 {
+  return a + negf(b);
+}
+
+// Knuth/Møller's TwoSum: s = fl(a+b), e = exact rounding error, a+b == s+e.
+// Works for any a, b. UNPROTECTED — see header above.
+fn twoSum(a: f32, b: f32) -> DD {
+  let s = a + b;
+  let v = s - a;
+  let e = (a - (s - v)) + (b - v);
+  return DD(s, e);
+}
+
+// Dekker's Fast-Two-Sum: same contract, but only correct when |a| >= |b|.
+// UNPROTECTED — see header above.
+fn fastTwoSum(a: f32, b: f32) -> DD {
+  let s = a + b;
+  let e = b - (s - a);
+  return DD(s, e);
+}
+
+// Double-double addition (Dekker's Add2). UNPROTECTED — see header above.
+fn ddAdd(a: DD, b: DD) -> DD {
+  let s = twoSum(a.hi, b.hi);
+  let loSum = a.lo + b.lo;
+  return fastTwoSum(s.hi, s.lo + loSum);
+}
+
+// ── Protected variants — use these ──────────────────────────────────────────
+//
+// Bitcast subtraction + workgroup-barrier materialization, verified correct
+// on all three backends tested. Costs a real barrier: fine for O(1)-per-
+// thread or O(log n) reduction use, not a long per-element loop. A
+// workgroupBarrier() requires uniform control flow, so:
+//   - `threadSlot` must be unique per concurrent caller (e.g. local_invocation_index).
+//   - Every thread in the workgroup must call this the same number of times
+//     — including ones whose result gets discarded. Compute unconditionally;
+//     only the write-back should be conditional.
+var<workgroup> dekkerScratch: array<f32, 64>;
+
+fn twoSumProtected(a: f32, b: f32, threadSlot: u32) -> DD {
+  dekkerScratch[threadSlot] = a + b;
+  workgroupBarrier();
+  let s = dekkerScratch[threadSlot];
+  let v = fsub(s, a);
+  let e = fsub(a, fsub(s, v)) + fsub(b, v);
+  return DD(s, e);
+}
+
+fn fastTwoSumProtected(a: f32, b: f32, threadSlot: u32) -> DD {
+  dekkerScratch[threadSlot] = a + b;
+  workgroupBarrier();
+  let s = dekkerScratch[threadSlot];
+  let e = fsub(b, fsub(s, a));
+  return DD(s, e);
+}
+
+// Protected double-double addition — same contract as ddAdd, but exact.
+fn ddAddProtected(a: DD, b: DD, threadSlot: u32) -> DD {
+  let s = twoSumProtected(a.hi, b.hi, threadSlot);
+  let loSum = a.lo + b.lo;
+  return fastTwoSumProtected(s.hi, s.lo + loSum, threadSlot);
+}