wgblas 0.1.2 → 1.0.0

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 };
 }

package/src/srot/srot.mjs

@@ -24,9 +24,11 @@ export async function srot(device, n, x, incx, y, incy, c, s) {
     !Number.isInteger(incy)
   )
     throw new Error("n, incx, and incy must be integers.");
-  if (isNaN(c) || isNaN(s)) throw new Error("c and s must not be NaN.");
-  if (!isFinite(c)) throw new Error("c must be finite.");
-  if (!isFinite(s)) throw new Error("s must be finite.");
+  if (typeof c !== "number") throw new Error("c must be a number.");
+  if (typeof s !== "number") throw new Error("s must be a number.");
+  if (Number.isNaN(c) || Number.isNaN(s)) throw new Error("c and s must not be NaN.");
+  if (!Number.isFinite(c)) throw new Error("c must be finite.");
+  if (!Number.isFinite(s)) throw new Error("s must be finite.");
   if (incx <= 0 || incy <= 0)
     throw new Error("incx and incy must be positive.");
   if (!xIsGpu && !(x instanceof Float32Array))
@@ -49,47 +51,61 @@ export async function srot(device, n, x, incx, y, incy, c, s) {
 
   const pipeline = await getPipeline(device, "srot");
 
-  const xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "srot-x", true);
-  const yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "srot-y", true);
-  const paramsBuffer = createParamsBuffer(
-    [
-      { value: n, type: "u32" },
-      { value: c, type: "f32" },
-      { value: s, type: "f32" },
-      { value: incx, type: "u32" },
-      { value: incy, type: "u32" },
-    ],
-    "srot-params",
-  );
+  let xBuffer = null;
+  let yBuffer = null;
+  let paramsBuffer = null;
+  let readX = null;
+  let readY = null;
 
-  const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
-    xBuffer,
-    yBuffer,
-    paramsBuffer,
-  ]);
-  const { commandEncoder, ts } = runComputePass(
-    pipeline,
-    bindGroup,
-    calcWorkgroups(n),
-  );
-  const readX = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
-  const readY = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
-  submit(commandEncoder);
+  try {
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "srot-x", true);
+    yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "srot-y", true);
+    paramsBuffer = createParamsBuffer(
+      [
+        { value: n, type: "u32" },
+        { value: c, type: "f32" },
+        { value: s, type: "f32" },
+        { value: incx, type: "u32" },
+        { value: incy, type: "u32" },
+      ],
+      "srot-params",
+    );
 
-  const gpuTimeMs = await extractTimestamp(ts);
+    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+      xBuffer,
+      yBuffer,
+      paramsBuffer,
+    ]);
+    const { commandEncoder, ts } = runComputePass(
+      pipeline,
+      bindGroup,
+      calcWorkgroups(n),
+    );
+    readX = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
+    readY = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
+    submit(commandEncoder);
 
-  if (xIsGpu && yIsGpu) {
-    destroyBuffers(paramsBuffer);
-    if (gpuTimeMs !== undefined) return { gpuTimeMs };
-    return {};
-  }
+    const gpuTimeMs = await extractTimestamp(ts);
 
-  const [xResult, yResult] = await Promise.all([
-    extractResult(readX, Float32Array),
-    extractResult(readY, Float32Array),
-  ]);
-  destroyBuffers(xBuffer, yBuffer, paramsBuffer, readX, readY);
+    if (xIsGpu && yIsGpu) {
+      if (gpuTimeMs !== undefined) return { gpuTimeMs };
+      return {};
+    }
 
-  if (gpuTimeMs !== undefined) return { x: xResult, y: yResult, gpuTimeMs };
-  return { x: xResult, y: yResult };
+    const xPromise = extractResult(readX, Float32Array);
+    const yPromise = extractResult(readY, Float32Array);
+    readX = null; // ownership transferred — extractResult's own finally destroys it
+    readY = null;
+    const [xResult, yResult] = await Promise.all([xPromise, yPromise]);
+
+    if (gpuTimeMs !== undefined) return { x: xResult, y: yResult, gpuTimeMs };
+    return { x: xResult, y: yResult };
+  } finally {
+    if (!xIsGpu && xBuffer) destroyBuffers(xBuffer);
+    if (!yIsGpu && yBuffer) destroyBuffers(yBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if extractTimestamp threw before ownership was transferred above.
+    if (readX) destroyBuffers(readX);
+    if (readY) destroyBuffers(readY);
+  }
 }

package/src/srotm/srotm.mjs

@@ -48,47 +48,63 @@ export async function srotm(device, n, x, incx, y, incy, param) {
 
   const pipeline = await getPipeline(device, "srotm");
 
-  const xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "srotm-x", true);
-  const yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "srotm-y", true);
-  const paramBuffer = uploadBuffer(param, "srotm-param", false);
-  const paramsBuffer = createParamsBuffer(
-    [
-      { value: n, type: "u32" },
-      { value: incx, type: "u32" },
-      { value: incy, type: "u32" },
-    ],
-    "srotm-params",
-  );
+  let xBuffer = null;
+  let yBuffer = null;
+  let paramBuffer = null;
+  let paramsBuffer = null;
+  let readX = null;
+  let readY = null;
 
-  const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
-    xBuffer,
-    yBuffer,
-    paramBuffer,
-    paramsBuffer,
-  ]);
-  const { commandEncoder, ts } = runComputePass(
-    pipeline,
-    bindGroup,
-    calcWorkgroups(n),
-  );
-  const readX = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
-  const readY = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
-  submit(commandEncoder);
+  try {
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "srotm-x", true);
+    yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "srotm-y", true);
+    paramBuffer = uploadBuffer(param, "srotm-param", false);
+    paramsBuffer = createParamsBuffer(
+      [
+        { value: n, type: "u32" },
+        { value: incx, type: "u32" },
+        { value: incy, type: "u32" },
+      ],
+      "srotm-params",
+    );
 
-  const gpuTimeMs = await extractTimestamp(ts);
+    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+      xBuffer,
+      yBuffer,
+      paramBuffer,
+      paramsBuffer,
+    ]);
+    const { commandEncoder, ts } = runComputePass(
+      pipeline,
+      bindGroup,
+      calcWorkgroups(n),
+    );
+    readX = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
+    readY = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
+    submit(commandEncoder);
 
-  if (xIsGpu && yIsGpu) {
-    destroyBuffers(paramBuffer, paramsBuffer);
-    if (gpuTimeMs !== undefined) return { gpuTimeMs };
-    return {};
-  }
+    const gpuTimeMs = await extractTimestamp(ts);
 
-  const [xResult, yResult] = await Promise.all([
-    extractResult(readX, Float32Array),
-    extractResult(readY, Float32Array),
-  ]);
-  destroyBuffers(xBuffer, yBuffer, paramBuffer, paramsBuffer, readX, readY);
+    if (xIsGpu && yIsGpu) {
+      if (gpuTimeMs !== undefined) return { gpuTimeMs };
+      return {};
+    }
 
-  if (gpuTimeMs !== undefined) return { x: xResult, y: yResult, gpuTimeMs };
-  return { x: xResult, y: yResult };
+    const xPromise = extractResult(readX, Float32Array);
+    const yPromise = extractResult(readY, Float32Array);
+    readX = null; // ownership transferred — extractResult's own finally destroys it
+    readY = null;
+    const [xResult, yResult] = await Promise.all([xPromise, yPromise]);
+
+    if (gpuTimeMs !== undefined) return { x: xResult, y: yResult, gpuTimeMs };
+    return { x: xResult, y: yResult };
+  } finally {
+    if (!xIsGpu && xBuffer) destroyBuffers(xBuffer);
+    if (!yIsGpu && yBuffer) destroyBuffers(yBuffer);
+    if (paramBuffer) destroyBuffers(paramBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if extractTimestamp threw before ownership was transferred above.
+    if (readX) destroyBuffers(readX);
+    if (readY) destroyBuffers(readY);
+  }
 }

package/src/sscal/sscal.mjs

@@ -19,8 +19,10 @@ export async function sscal(device, n, alpha, x, incx) {
     throw new Error("device must be a GPUDevice.");
   if (!Number.isInteger(n) || !Number.isInteger(incx))
     throw new Error("n and incx must be integers.");
-  if (isNaN(alpha)) throw new Error("alpha must not be NaN.");
-  if (!isFinite(alpha)) throw new Error("alpha must be finite.");
+  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 (incx <= 0) throw new Error("incx must be positive.");
   if (!(x instanceof Float32Array) && !(x instanceof GpuVector))
     throw new Error("x must be a Float32Array or GpuVector.");
@@ -32,40 +34,49 @@ export async function sscal(device, n, alpha, x, incx) {
 
   const pipeline = await getPipeline(device, "sscal");
 
-  const xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "sscal-x", true);
-  const paramsBuffer = createParamsBuffer(
-    [
-      { value: n, type: "u32" },
-      { value: alpha, type: "f32" },
-      { value: incx, type: "u32" },
-    ],
-    "sscal-params",
-  );
+  let xBuffer = null;
+  let paramsBuffer = null;
+  let readBuffer = null;
 
-  const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
-    xBuffer,
-    paramsBuffer,
-  ]);
-  const { commandEncoder, ts } = runComputePass(
-    pipeline,
-    bindGroup,
-    calcWorkgroups(n),
-  );
-  const readBuffer = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
+  try {
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "sscal-x", true);
+    paramsBuffer = createParamsBuffer(
+      [
+        { value: n, type: "u32" },
+        { value: alpha, type: "f32" },
+        { value: incx, type: "u32" },
+      ],
+      "sscal-params",
+    );
 
-  submit(commandEncoder);
+    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+      xBuffer,
+      paramsBuffer,
+    ]);
+    const { commandEncoder, ts } = runComputePass(
+      pipeline,
+      bindGroup,
+      calcWorkgroups(n),
+    );
+    readBuffer = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
 
-  const gpuTimeMs = await extractTimestamp(ts);
+    submit(commandEncoder);
 
-  if (xIsGpu) {
-    destroyBuffers(paramsBuffer);
-    if (gpuTimeMs !== undefined) return { gpuTimeMs };
-    return {};
-  }
+    const gpuTimeMs = await extractTimestamp(ts);
 
-  const result = await extractResult(readBuffer, Float32Array);
-  destroyBuffers(xBuffer, paramsBuffer, readBuffer);
+    if (xIsGpu) {
+      if (gpuTimeMs !== undefined) return { gpuTimeMs };
+      return {};
+    }
 
-  if (gpuTimeMs !== undefined) return { result, gpuTimeMs };
-  return result;
+    const result = await extractResult(readBuffer, Float32Array);
+    readBuffer = null; // extractResult already destroyed it
+    if (gpuTimeMs !== undefined) return { x: result, gpuTimeMs };
+    return result;
+  } finally {
+    if (!xIsGpu && xBuffer) destroyBuffers(xBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if extractTimestamp threw before extractResult ran.
+    if (readBuffer) destroyBuffers(readBuffer);
+  }
 }

package/src/sswap/sswap.mjs

@@ -46,45 +46,60 @@ export async function sswap(device, n, x, incx, y, incy) {
 
   const pipeline = await getPipeline(device, "sswap");
 
-  const xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "sswap-x", true);
-  const yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "sswap-y", true);
-  const paramsBuffer = createParamsBuffer(
-    [
-      { value: n, type: "u32" },
-      { value: incx, type: "u32" },
-      { value: incy, type: "u32" },
-    ],
-    "sswap-params",
-  );
+  let xBuffer = null;
+  let yBuffer = null;
+  let paramsBuffer = null;
+  let xReadBuffer = null;
+  let yReadBuffer = null;
 
-  const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
-    xBuffer,
-    yBuffer,
-    paramsBuffer,
-  ]);
-  const { commandEncoder, ts } = runComputePass(
-    pipeline,
-    bindGroup,
-    calcWorkgroups(n),
-  );
-  const xReadBuffer = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
-  const yReadBuffer = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
+  try {
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "sswap-x", true);
+    yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "sswap-y", true);
+    paramsBuffer = createParamsBuffer(
+      [
+        { value: n, type: "u32" },
+        { value: incx, type: "u32" },
+        { value: incy, type: "u32" },
+      ],
+      "sswap-params",
+    );
 
-  submit(commandEncoder);
+    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+      xBuffer,
+      yBuffer,
+      paramsBuffer,
+    ]);
+    const { commandEncoder, ts } = runComputePass(
+      pipeline,
+      bindGroup,
+      calcWorkgroups(n),
+    );
+    xReadBuffer = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
+    yReadBuffer = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
 
-  const gpuTimeMs = await extractTimestamp(ts);
+    submit(commandEncoder);
 
-  if (xIsGpu && yIsGpu) {
-    destroyBuffers(paramsBuffer);
-    if (gpuTimeMs !== undefined) return { gpuTimeMs };
-    return {};
-  }
+    const gpuTimeMs = await extractTimestamp(ts);
 
-  const resultX = await extractResult(xReadBuffer, Float32Array);
-  const resultY = await extractResult(yReadBuffer, Float32Array);
+    if (xIsGpu && yIsGpu) {
+      if (gpuTimeMs !== undefined) return { gpuTimeMs };
+      return {};
+    }
 
-  destroyBuffers(xBuffer, xReadBuffer, yBuffer, yReadBuffer, paramsBuffer);
+    const resultX = await extractResult(xReadBuffer, Float32Array);
+    xReadBuffer = null; // extractResult already destroyed it
+    const resultY = await extractResult(yReadBuffer, Float32Array);
+    yReadBuffer = null; // extractResult already destroyed it
 
-  if (gpuTimeMs !== undefined) return { x: resultX, y: resultY, gpuTimeMs };
-  return { x: resultX, y: resultY };
+    if (gpuTimeMs !== undefined) return { x: resultX, y: resultY, gpuTimeMs };
+    return { x: resultX, y: resultY };
+  } finally {
+    if (!xIsGpu && xBuffer) destroyBuffers(xBuffer);
+    if (!yIsGpu && yBuffer) destroyBuffers(yBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if extractTimestamp or extractResult threw before
+    // clearing these — on the success path they're already null.
+    if (xReadBuffer) destroyBuffers(xReadBuffer);
+    if (yReadBuffer) destroyBuffers(yReadBuffer);
+  }
 }