wgblas 0.1.2 → 1.1.0

package/src/shaders/ssymv.wgsl

@@ -0,0 +1,69 @@
+// ssymv: y = alpha * A * x + beta * y
+// A is n×n symmetric, lower (uplo=0) or upper (uplo=1) triangle stored.
+// The logical matrix is fully dense (symmetric), so each row's dot product
+// sums over all n columns; entries on the unstored side of the diagonal are
+// fetched from their mirror position (A[i,j] == A[j,i]).
+// One workgroup per row, grid-stride outer loop.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read>       x: array<f32>;
+@group(0) @binding(2) var<storage, read_write> y: array<f32>;
+
+struct Params {
+  n:     u32,
+  alpha: f32,
+  beta:  f32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+  uplo:  u32,  // 0 = lower, 1 = upper
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> scratch: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  for (var i = wgid.x; i < params.n; i += nwg.x) {
+    var acc = 0.0f;
+
+    // y[i] = Σ_j A[i,j] * x[j]
+    for (var j = lid.x; j < params.n; j += WGS) {
+      var aVal: f32;
+      if params.uplo == 0u {
+        // Lower: A[i,j] stored at A[i*lda+j] for j ≤ i, mirrored from A[j*lda+i] otherwise
+        if j <= i {
+          aVal = A[i * params.lda + j];
+        } else {
+          aVal = A[j * params.lda + i];
+        }
+      } else {
+        // Upper: A[i,j] stored at A[i*lda+j] for j ≥ i, mirrored from A[j*lda+i] otherwise
+        if j >= i {
+          aVal = A[i * params.lda + j];
+        } else {
+          aVal = A[j * params.lda + i];
+        }
+      }
+      acc += aVal * x[j * params.incx];
+    }
+
+    // Parallel reduction: 64 → 1
+    scratch[lid.x] = acc;
+    workgroupBarrier();
+    for (var stride = WGS >> 1u; stride > 0u; stride >>= 1u) {
+      if lid.x < stride { scratch[lid.x] += scratch[lid.x + stride]; }
+      workgroupBarrier();
+    }
+
+    if lid.x == 0u {
+      y[i * params.incy] = params.alpha * scratch[0] + params.beta * y[i * params.incy];
+    }
+  }
+}

package/src/shaders/ssyr.wgsl

@@ -0,0 +1,60 @@
+// ssyr: A := alpha * x * x^T + A  (symmetric rank-1 update)
+// A is n×n symmetric; only the triangle specified by uplo is referenced/updated,
+// the other triangle is implied by symmetry (not touched).
+
+@group(0) @binding(0) var<storage, read>       x: array<f32>;
+@group(0) @binding(1) var<storage, read_write> A: array<f32>;
+
+struct Params {
+  n:     u32,
+  alpha: f32,
+  incx:  u32,
+  lda:   u32,
+  uplo:  u32,  // 0 = lower, 1 = upper
+}
+
+@group(0) @binding(2) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  for (var row = wgid.x; row < params.n; row += nwg.x) {
+    let xi = params.alpha * x[row * params.incx];
+    let row_base = row * params.lda;
+
+    // Stored-triangle column range for this row: lower [0,row], upper [row,n).
+    var colStart: u32;
+    var colEnd: u32;
+    if params.uplo == 1u {
+      colStart = row;
+      colEnd = params.n;
+    } else {
+      colStart = 0u;
+      colEnd = row + 1u;
+    }
+
+    // 4-unrolled loop over the stored range.
+    let rangeLen = colEnd - colStart;
+    let n4_floor = colStart + (rangeLen / (4u * WGS)) * (4u * WGS);
+    for (var col: u32 = colStart + lid.x; col < n4_floor; col += 4u * WGS) {
+      let idx0 = row_base + col;
+      let idx1 = row_base + col + WGS;
+      let idx2 = row_base + col + 2u * WGS;
+      let idx3 = row_base + col + 3u * WGS;
+      A[idx0] = xi * x[ col             * params.incx] + A[idx0];
+      A[idx1] = xi * x[(col +     WGS)  * params.incx] + A[idx1];
+      A[idx2] = xi * x[(col + 2u * WGS) * params.incx] + A[idx2];
+      A[idx3] = xi * x[(col + 3u * WGS) * params.incx] + A[idx3];
+    }
+    // Scalar tail: at most 3*WGS elements left after the unrolled block.
+    for (var col: u32 = n4_floor + lid.x; col < colEnd; col += WGS) {
+      let idx = row_base + col;
+      A[idx] = xi * x[col * params.incx] + A[idx];
+    }
+  }
+}

package/src/shaders/ssyr2.wgsl

@@ -0,0 +1,63 @@
+// ssyr2: A := alpha * x * y^T + alpha * y * x^T + A  (symmetric rank-2 update)
+// A is n×n symmetric; only the triangle specified by uplo is referenced/updated,
+// the other triangle is implied by symmetry (not touched).
+
+@group(0) @binding(0) var<storage, read>       x: array<f32>;
+@group(0) @binding(1) var<storage, read>       y: array<f32>;
+@group(0) @binding(2) var<storage, read_write> A: array<f32>;
+
+struct Params {
+  n:     u32,
+  alpha: f32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+  uplo:  u32,  // 0 = lower, 1 = upper
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  for (var row = wgid.x; row < params.n; row += nwg.x) {
+    let xi = params.alpha * x[row * params.incx];
+    let yi = params.alpha * y[row * params.incy];
+    let row_base = row * params.lda;
+
+    // Stored-triangle column range for this row: lower [0,row], upper [row,n).
+    var colStart: u32;
+    var colEnd: u32;
+    if params.uplo == 1u {
+      colStart = row;
+      colEnd = params.n;
+    } else {
+      colStart = 0u;
+      colEnd = row + 1u;
+    }
+
+    // 4-unrolled loop over the stored range.
+    let rangeLen = colEnd - colStart;
+    let n4_floor = colStart + (rangeLen / (4u * WGS)) * (4u * WGS);
+    for (var col: u32 = colStart + lid.x; col < n4_floor; col += 4u * WGS) {
+      let idx0 = row_base + col;
+      let idx1 = row_base + col + WGS;
+      let idx2 = row_base + col + 2u * WGS;
+      let idx3 = row_base + col + 3u * WGS;
+      A[idx0] = xi * y[ col             * params.incy] + yi * x[ col             * params.incx] + A[idx0];
+      A[idx1] = xi * y[(col +     WGS)  * params.incy] + yi * x[(col +     WGS)  * params.incx] + A[idx1];
+      A[idx2] = xi * y[(col + 2u * WGS) * params.incy] + yi * x[(col + 2u * WGS) * params.incx] + A[idx2];
+      A[idx3] = xi * y[(col + 3u * WGS) * params.incy] + yi * x[(col + 3u * WGS) * params.incx] + A[idx3];
+    }
+    // Scalar tail: at most 3*WGS elements left after the unrolled block.
+    for (var col: u32 = n4_floor + lid.x; col < colEnd; col += WGS) {
+      let idx = row_base + col;
+      A[idx] = xi * y[col * params.incy] + yi * x[col * params.incx] + A[idx];
+    }
+  }
+}

package/src/shaders/strmv.wgsl

@@ -0,0 +1,103 @@
+// strmv: y = op(A) * x
+// A is n×n triangular, lower (uplo=0) or upper (uplo=1) triangle stored.
+// op(A) is A (trans=0) or A^T (trans=1).
+// diag=1 (unit) treats the diagonal as 1 without reading A's diagonal values.
+// One workgroup per row, grid-stride outer loop.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read>       x: array<f32>;
+@group(0) @binding(2) var<storage, read_write> y: array<f32>;
+
+struct Params {
+  n:     u32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+  trans: u32,  // 0 = no-transpose, 1 = transpose
+  uplo:  u32,  // 0 = lower, 1 = upper
+  diag:  u32,  // 0 = non-unit, 1 = unit
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> scratch: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  for (var i = wgid.x; i < params.n; i += nwg.x) {
+    var acc = 0.0f;
+
+    if params.trans == 0u {
+      // No-transpose: y[i] = Σ_j A[i,j] * x[j]
+      if params.uplo == 0u {
+        // Lower: A[i,j] stored at A[i*lda+j] for j ≤ i
+        for (var j = lid.x; j <= i; j += WGS) {
+          var aVal: f32;
+          // unit diagonal: use 1 instead of A's actual diagonal value
+          if params.diag == 1u && j == i {
+            aVal = 1.0;
+          } else if ( j <= i ) {
+            aVal = A[i * params.lda + j];
+          }
+          acc += aVal * x[j * params.incx];
+        }
+      } else {
+        // Upper: A[i,j] stored at A[i*lda+j] for j ≥ i
+        for (var j = i + lid.x; j < params.n; j += WGS) {
+          var aVal: f32;
+          // unit diagonal: use 1 instead of A's actual diagonal value
+          if params.diag == 1u && j == i {
+            aVal = 1.0;
+          } else if ( j >= i ) {
+            aVal = A[i * params.lda + j];
+          }
+          acc += aVal * x[j * params.incx];
+        }
+      }
+    } else {
+      // Transpose: y[i] = Σ_j A[j,i] * x[j]
+      if params.uplo == 0u {
+        // Lower: A[j,i] stored at A[j*lda+i] for j ≥ i
+        for (var j = i + lid.x; j < params.n; j += WGS) {
+          var aVal: f32;
+          // unit diagonal: use 1 instead of A's actual diagonal value
+          if params.diag == 1u && j == i {
+            aVal = 1.0;
+          } else if ( j >= i ) {
+            aVal = A[j * params.lda + i];
+          }
+          acc += aVal * x[j * params.incx];
+        }
+      } else {
+        // Upper: A[j,i] stored at A[j*lda+i] for j ≤ i
+        for (var j = lid.x; j <= i; j += WGS) {
+          var aVal: f32;
+          // unit diagonal: use 1 instead of A's actual diagonal value
+          if params.diag == 1u && j == i {
+            aVal = 1.0;
+          } else if ( j <= i ) {
+            aVal = A[j * params.lda + i];
+          }
+          acc += aVal * x[j * params.incx];
+        }
+      }
+    }
+
+    // Parallel reduction: 64 → 1
+    scratch[lid.x] = acc;
+    workgroupBarrier();
+    for (var stride = WGS >> 1u; stride > 0u; stride >>= 1u) {
+      if lid.x < stride { scratch[lid.x] += scratch[lid.x + stride]; }
+      workgroupBarrier();
+    }
+
+    if lid.x == 0u {
+      y[ i * params.incy ] = scratch[0];
+    }
+  }
+}

package/src/shaders/strsv_apply_inverse.wgsl

@@ -0,0 +1,47 @@
+// strsv_apply_inverse: given a precomputed block inverse (from
+// strsv_invert_block.wgsl), computes this block's solution as a dense
+// matrix-vector multiply against the block's current remainder in x —
+// replacing what the old strsv_block.wgsl did via a genuinely sequential,
+// barrier-per-row substitution.
+//
+// All blockLen rows are computed in parallel within a single workgroup: the
+// remainder is loaded into workgroup-shared memory once, then each thread
+// independently computes one full row's dot product from that shared copy.
+// No further synchronization is needed after the load — every thread only
+// reads shared memory from then on (never written again within this call)
+// and writes a distinct element of x, so there's no cross-thread hazard to
+// guard against.
+
+@group(0) @binding(0) var<storage, read>       Ainv: array<f32>;
+@group(0) @binding(1) var<storage, read_write> x: array<f32>;
+
+struct Params {
+  incx:       u32,
+  blockIndex: u32,
+  blockStart: u32,
+  blockEnd:   u32,
+}
+
+@group(0) @binding(2) var<uniform> params: Params;
+
+const BLOCK_SIZE: u32 = 64u;
+var<workgroup> xLocal: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn strsv_apply_inverse_main(@builtin(local_invocation_id) lid: vec3u) {
+  let blockLen = params.blockEnd - params.blockStart;
+
+  if (lid.x < blockLen) {
+    xLocal[lid.x] = x[(params.blockStart + lid.x) * params.incx];
+  }
+  workgroupBarrier();
+
+  if (lid.x >= blockLen) { return; }
+
+  let ainvBase = params.blockIndex * BLOCK_SIZE * BLOCK_SIZE;
+  var acc = 0.0f;
+  for (var j = 0u; j < blockLen; j++) {
+    acc += Ainv[ainvBase + lid.x * BLOCK_SIZE + j] * xLocal[j];
+  }
+  x[(params.blockStart + lid.x) * params.incx] = acc;
+}

package/src/shaders/strsv_invert_block.wgsl

@@ -0,0 +1,109 @@
+// strsv_invert_block: computes ONE column (workgroup_id.x) of ONE block's
+// (workgroup_id.y) explicit inverse, via the same one-row-at-a-time
+// substitution as strsv_block.wgsl, but solving against a unit basis vector
+// e_col instead of the real right-hand side, and writing to a dense
+// (BLOCK_SIZE x BLOCK_SIZE, row-major) scratch buffer per block instead of
+// mutating x. Dispatched once for the whole matrix (2D: BLOCK_SIZE columns x
+// numBlocks), fully in parallel -- unlike the sequential per-block main
+// loop in strsv.mjs, no block's inverse depends on any other block or on x.
+//
+// A triangular block's inverse is itself triangular: forward (effectively-
+// lower, e.g. no-trans+lower) blocks have inverse column col nonzero only
+// for row>=col, solved in increasing row order; backward (effectively-
+// upper) blocks have it nonzero only for row<=col, solved in decreasing
+// order. Rows outside a column's nonzero range are written as literal 0 —
+// strsv_apply_inverse.wgsl's dense matvec depends on that, not just on
+// those entries being mathematically implied zero.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read_write> Ainv: array<f32>;
+
+struct Params {
+  n:     u32,
+  lda:   u32,
+  trans: u32,  // 0 = no-transpose, 1 = transpose
+  uplo:  u32,  // 0 = lower, 1 = upper
+  diag:  u32,  // 0 = non-unit, 1 = unit
+}
+
+@group(0) @binding(2) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+const BLOCK_SIZE: u32 = 64u;
+var<workgroup> scratch: array<f32, 64>;
+
+fn readA(i: u32, j: u32) -> f32 {
+  if params.trans == 0u {
+    return A[i * params.lda + j];
+  } else {
+    return A[j * params.lda + i];
+  }
+}
+
+@compute @workgroup_size(64)
+fn strsv_invert_block_main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+) {
+  let col = wgid.x;
+  let blockIndex = wgid.y;
+  let blockStart = blockIndex * BLOCK_SIZE;
+  var blockEnd = blockStart + BLOCK_SIZE;
+  if (blockEnd > params.n) { blockEnd = params.n; }
+  let blockLen = blockEnd - blockStart;
+
+  if (col >= blockLen) { return; }
+
+  let ainvBase = blockIndex * BLOCK_SIZE * BLOCK_SIZE;
+  let forward = (params.trans == 0u) == (params.uplo == 0u);
+
+  if forward {
+    for (var r = lid.x; r < col; r += WGS) {
+      Ainv[ainvBase + r * BLOCK_SIZE + col] = 0.0;
+    }
+  } else {
+    for (var r = col + 1u + lid.x; r < blockLen; r += WGS) {
+      Ainv[ainvBase + r * BLOCK_SIZE + col] = 0.0;
+    }
+  }
+  storageBarrier();
+  workgroupBarrier();
+
+  let numSteps = select(col + 1u, blockLen - col, forward);
+  for (var step = 0u; step < numSteps; step++) {
+    let localRow = select(col - step, col + step, forward);
+    let i = blockStart + localRow;
+
+    var acc = 0.0f;
+    if forward {
+      for (var lj = col + lid.x; lj < localRow; lj += WGS) {
+        acc += readA(i, blockStart + lj) * Ainv[ainvBase + lj * BLOCK_SIZE + col];
+      }
+    } else {
+      for (var lj = localRow + 1u + lid.x; lj <= col; lj += WGS) {
+        acc += readA(i, blockStart + lj) * Ainv[ainvBase + lj * BLOCK_SIZE + col];
+      }
+    }
+
+    scratch[lid.x] = acc;
+    workgroupBarrier();
+    for (var stride = WGS >> 1u; stride > 0u; stride >>= 1u) {
+      if lid.x < stride { scratch[lid.x] += scratch[lid.x + stride]; }
+      workgroupBarrier();
+    }
+
+    if lid.x == 0u {
+      let e = select(0.0, 1.0, localRow == col);
+      let rhs = e - scratch[0];
+      var val: f32;
+      if params.diag == 1u {
+        val = rhs;
+      } else {
+        val = rhs / A[i * params.lda + i];
+      }
+      Ainv[ainvBase + localRow * BLOCK_SIZE + col] = val;
+    }
+    storageBarrier();
+    workgroupBarrier();
+  }
+}

package/src/shaders/strsv_update.wgsl

@@ -0,0 +1,75 @@
+// strsv_update: subtracts a solved block's contribution from every
+// remaining row in parallel (one workgroup per row, like strmv.wgsl) —
+// this is what turns strsv's O(n) sequential stages into O(n/blockSize).
+// No diag/masking needed: this region never touches the diagonal.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read_write> x: array<f32>;
+
+struct Params {
+  n:          u32,
+  incx:       u32,
+  lda:        u32,
+  trans:      u32,  // 0 = no-transpose, 1 = transpose
+  uplo:       u32,  // 0 = lower, 1 = upper
+  blockStart: u32,
+  blockEnd:   u32,  // exclusive
+}
+
+@group(0) @binding(2) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> scratch: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn strsv_update_main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  // forward: remaining rows are [blockEnd,n); backward: [0,blockStart).
+  let forward = (params.trans == 0u) == (params.uplo == 0u);
+
+  var rangeStart: u32;
+  var rangeEnd: u32;
+
+  if forward {
+    rangeStart = params.blockEnd;
+    rangeEnd = params.n;
+  } else {
+    rangeStart = 0u;
+    rangeEnd = params.blockStart;
+  }
+  
+  if (rangeStart >= rangeEnd) { return; }
+  let count = rangeEnd - rangeStart;
+
+  for (var idx = wgid.x; idx < count; idx += nwg.x) {
+    let i = rangeStart + idx;
+
+    // No-trans reads A[i,j]; transpose reads A[j,i] — uplo only sets the range above.
+    var acc = 0.0f;
+    if params.trans == 0u {
+      for (var j = params.blockStart + lid.x; j < params.blockEnd; j += WGS) {
+        acc += A[i * params.lda + j] * x[j * params.incx];
+      }
+    } else {
+      for (var j = params.blockStart + lid.x; j < params.blockEnd; j += WGS) {
+        acc += A[j * params.lda + i] * x[j * params.incx];
+      }
+    }
+
+    // Parallel reduction: 64 → 1
+    scratch[lid.x] = acc;
+    workgroupBarrier();
+    for (var stride = WGS >> 1u; stride > 0u; stride >>= 1u) {
+      if lid.x < stride { scratch[lid.x] += scratch[lid.x + stride]; }
+      workgroupBarrier();
+    }
+
+    if lid.x == 0u {
+      x[i * params.incx] -= scratch[0];
+    }
+    workgroupBarrier();
+  }
+}

package/src/snrm2/snrm2.mjs

@@ -34,67 +34,71 @@ export async function snrm2(device, n, x, incx) {
   const pipelineMain = await getPipeline(device, "snrm2");
   const pipelineReduce = await getPipeline(device, "reduction/sum");
 
-  const xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "snrm2-x", false);
-  const partialsBuffer = createStorageBuffer(2 * WGS * 4, "snrm2-partials"); // 2*WGS partial sums of f32
-  const resultBuffer = createResultBuffer(4, "snrm2-result"); // final f32 scalar
-  const paramsBuffer = createParamsBuffer(
-    [
-      { value: n, type: "u32" },
-      { value: incx, type: "u32" },
-    ],
-    "snrm2-params",
-  );
+  let xBuffer = null;
+  let partialsBuffer = null;
+  let resultBuffer = null;
+  let paramsBuffer = null;
+  let readBuffer = null;
 
-  const bgMain = createBindGroup(pipelineMain.getBindGroupLayout(0), [
-    xBuffer,
-    partialsBuffer,
-    paramsBuffer,
-  ]);
-  const { commandEncoder: enc1, ts: ts1 } = runComputePass(
-    pipelineMain,
-    bgMain,
-    2 * WGS,
-  ); // dispatch 2*WGS workgroups
+  try {
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "snrm2-x", false);
+    partialsBuffer = createStorageBuffer(2 * WGS * 4, "snrm2-partials"); // 2*WGS partial sums of f32
+    resultBuffer = createResultBuffer(4, "snrm2-result"); // final f32 scalar
+    paramsBuffer = createParamsBuffer(
+      [
+        { value: n, type: "u32" },
+        { value: incx, type: "u32" },
+      ],
+      "snrm2-params",
+    );
+
+    const bgMain = createBindGroup(pipelineMain.getBindGroupLayout(0), [
+      xBuffer,
+      partialsBuffer,
+      paramsBuffer,
+    ]);
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+      pipelineMain,
+      bgMain,
+      2 * WGS,
+    ); // dispatch 2*WGS workgroups
 
-  submit(enc1);
+    submit(enc1);
 
-  const bgReduce = createBindGroup(pipelineReduce.getBindGroupLayout(0), [
-    partialsBuffer,
-    resultBuffer,
-  ]);
-  const { commandEncoder: enc2, ts: ts2 } = runComputePass(
-    pipelineReduce,
-    bgReduce,
-    1,
-  ); // reduce partials to single result
-  const readBuffer = stageReadback(enc2, resultBuffer);
+    const bgReduce = createBindGroup(pipelineReduce.getBindGroupLayout(0), [
+      partialsBuffer,
+      resultBuffer,
+    ]);
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+      pipelineReduce,
+      bgReduce,
+      1,
+    ); // reduce partials to single result
+    readBuffer = stageReadback(enc2, resultBuffer);
 
-  submit(enc2);
+    submit(enc2);
 
-  const [gpuTime1, gpuTime2, sqsumArr] = await Promise.all([
-    extractTimestamp(ts1),
-    extractTimestamp(ts2),
-    extractResult(readBuffer, Float32Array),
-  ]);
+    const resultPromise = extractResult(readBuffer, Float32Array);
+    readBuffer = null; // ownership transferred — extractResult's own finally destroys it
 
-  // sqrt is taken on CPU after the GPU sum-of-squares reduction
-  const nrm2 = Math.sqrt(sqsumArr[0]);
+    const [gpuTime1, gpuTime2, sqsumArr] = await Promise.all([
+      extractTimestamp(ts1),
+      extractTimestamp(ts2),
+      resultPromise,
+    ]);
+
+    // sqrt is taken on CPU after the GPU sum-of-squares reduction
+    const nrm2 = Math.sqrt(sqsumArr[0]);
 
-  if (xIsGpu) {
-    destroyBuffers(partialsBuffer, resultBuffer, paramsBuffer, readBuffer);
     if (gpuTime1 !== undefined && gpuTime2 !== undefined)
       return { nrm2, gpuTimeMs: gpuTime1 + gpuTime2 };
     return { nrm2 };
+  } finally {
+    if (!xIsGpu && xBuffer) destroyBuffers(xBuffer);
+    if (partialsBuffer) destroyBuffers(partialsBuffer);
+    if (resultBuffer) destroyBuffers(resultBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if submit(enc2) threw before ownership was transferred above.
+    if (readBuffer) destroyBuffers(readBuffer);
   }
-
-  destroyBuffers(
-    xBuffer,
-    partialsBuffer,
-    resultBuffer,
-    paramsBuffer,
-    readBuffer,
-  );
-  if (gpuTime1 !== undefined && gpuTime2 !== undefined)
-    return { nrm2, gpuTimeMs: gpuTime1 + gpuTime2 };
-  return { nrm2 };
 }