wgblas 2.1.0 → 2.2.1

package/src/ddot/ddot.mjs

@@ -0,0 +1,184 @@
+import {
+  createStorageBuffer,
+  createParamsBuffer,
+  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 { GpuVector } from "../classes/GpuVector.mjs";
+import { splitDoubleDouble, mergeDoubleDouble } from "../util/f64.mjs";
+import { WGS } from "../util/constants.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
+
+export async function ddot(device, n, x, incx, y, incy) {
+  const xIsGpu = x instanceof GpuVector;
+  const yIsGpu = y instanceof GpuVector;
+
+  requireGpuDevice(device);
+  requireSameDevice(device, "ddot", { x, y });
+  if (
+    !Number.isInteger(n) ||
+    !Number.isInteger(incx) ||
+    !Number.isInteger(incy)
+  )
+    throw new Error("n, incx, and incy must be integers.");
+  if (incx <= 0 || incy <= 0)
+    throw new Error("incx and incy must be positive.");
+  if (!xIsGpu && !(x instanceof Float64Array))
+    throw new Error("x must be a Float64Array or GpuVector.");
+  if (!yIsGpu && !(y instanceof Float64Array))
+    throw new Error("y must be a Float64Array or GpuVector.");
+  if (xIsGpu && x.dtype !== Float64Array)
+    throw new Error("x must be a Float64Array-backed GpuVector.");
+  if (yIsGpu && y.dtype !== Float64Array)
+    throw new Error("y must be a Float64Array-backed GpuVector.");
+  if (xIsGpu !== yIsGpu)
+    throw new Error(
+      "x and y must be the same type (both Float64Array or both GpuVector).",
+    );
+  if (n <= 0) return { dot: 0 };
+  if (x.length < (n - 1) * incx + 1)
+    throw new Error(
+      "x does not have enough elements for the given n and incx.",
+    );
+  if (y.length < (n - 1) * incy + 1)
+    throw new Error(
+      "y does not have enough elements for the given n and incy.",
+    );
+
+  // Concatenated with f64/dekker.wgsl (DD struct) and f64/utils/add.wgsl
+  // (ddAddProtected) — WGSL has no #include; entryPoint omitted since each
+  // module has only one @compute. Only the first pass multiplies, so
+  // f64/utils/multiply.wgsl is left out of the reduction's module.
+  const ddCore = ["f64/dekker", "f64/utils/add"];
+  const pipelineMain = await getPipeline(device, [
+    ...ddCore,
+    "f64/utils/multiply",
+    "ddot",
+  ]);
+  const pipelineReduce = await getPipeline(device, [
+    ...ddCore,
+    "reduction/sumF64",
+  ]);
+
+  let xHiBuffer = null;
+  let xLoBuffer = null;
+  let yHiBuffer = null;
+  let yLoBuffer = null;
+  let partialsHiBuffer = null;
+  let partialsLoBuffer = null;
+  let resultHiBuffer = null;
+  let resultLoBuffer = null;
+  let paramsBuffer = null;
+  let readHiBuffer = null;
+  let readLoBuffer = null;
+
+  try {
+    if (xIsGpu) {
+      xHiBuffer = x._buf;
+      xLoBuffer = x._loBuf;
+      yHiBuffer = y._buf;
+      yLoBuffer = y._loBuf;
+    } else {
+      // No abs here (unlike dasum) — the product carries its own sign.
+      const xSplit = splitDoubleDouble(x);
+      const ySplit = splitDoubleDouble(y);
+      xHiBuffer = uploadBuffer(device, xSplit.hi, "ddot-xHi", false);
+      xLoBuffer = uploadBuffer(device, xSplit.lo, "ddot-xLo", false);
+      yHiBuffer = uploadBuffer(device, ySplit.hi, "ddot-yHi", false);
+      yLoBuffer = uploadBuffer(device, ySplit.lo, "ddot-yLo", false);
+    }
+    partialsHiBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "ddot-partialsHi",
+    );
+    partialsLoBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "ddot-partialsLo",
+    );
+    resultHiBuffer = createResultBuffer(device, 4, "ddot-result-hi");
+    resultLoBuffer = createResultBuffer(device, 4, "ddot-result-lo");
+    paramsBuffer = createParamsBuffer(
+      device,
+      [
+        { value: n, type: "u32" },
+        { value: incx, type: "u32" },
+        { value: incy, type: "u32" },
+      ],
+      "ddot-params",
+    );
+
+    const bgMain = createBindGroup(device, pipelineMain.getBindGroupLayout(0), [
+      xHiBuffer,
+      xLoBuffer,
+      yHiBuffer,
+      yLoBuffer,
+      partialsHiBuffer,
+      partialsLoBuffer,
+      paramsBuffer,
+    ]);
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+      device,
+      pipelineMain,
+      bgMain,
+      2 * WGS,
+    ); // dispatch 2*WGS workgroups — one partial per workgroup
+
+    submit(device, enc1);
+
+    const bgReduce = createBindGroup(
+      device,
+      pipelineReduce.getBindGroupLayout(0),
+      [partialsHiBuffer, partialsLoBuffer, resultHiBuffer, resultLoBuffer],
+    );
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+      device,
+      pipelineReduce,
+      bgReduce,
+      1,
+    ); // dispatch 1 workgroup to reduce the partial sums to a single result
+    readHiBuffer = stageReadback(device, enc2, resultHiBuffer);
+    readLoBuffer = stageReadback(device, enc2, resultLoBuffer);
+
+    submit(device, enc2);
+
+    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, hiArr, loArr] = await Promise.all([
+      extractTimestamp(ts1),
+      extractTimestamp(ts2),
+      hiPromise,
+      loPromise,
+    ]);
+
+    // dot is always a scalar readback — both paths return { dot }
+    const dot = mergeDoubleDouble(hiArr, loArr)[0];
+    if (gpuTime1 !== undefined && gpuTime2 !== undefined)
+      return { dot, gpuTimeMs: gpuTime1 + gpuTime2 };
+    return { dot };
+  } finally {
+    if (!xIsGpu && xHiBuffer) destroyBuffers(xHiBuffer);
+    if (!xIsGpu && xLoBuffer) destroyBuffers(xLoBuffer);
+    if (!yIsGpu && yHiBuffer) destroyBuffers(yHiBuffer);
+    if (!yIsGpu && yLoBuffer) destroyBuffers(yLoBuffer);
+    if (partialsHiBuffer) destroyBuffers(partialsHiBuffer);
+    if (partialsLoBuffer) destroyBuffers(partialsLoBuffer);
+    if (resultHiBuffer) destroyBuffers(resultHiBuffer);
+    if (resultLoBuffer) destroyBuffers(resultLoBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if submit(device, enc2) threw before ownership was transferred above.
+    if (readHiBuffer) destroyBuffers(readHiBuffer);
+    if (readLoBuffer) destroyBuffers(readLoBuffer);
+  }
+}

package/src/dnrm2/dnrm2.d.mts

@@ -0,0 +1,50 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Computes the Euclidean norm of a double-precision vector:
+ * $$\text{result} = \sqrt{\sum_{i} x_i^2}$$
+ * — double-double (Dekker) f64 emulation of {@link snrm2}, since WGSL has
+ * no native f64 type.
+ *
+ * {@includeCode ../../examples/dnrm2/dnrm2.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/dnrm2/web/dnrm2.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - Float64Array input vector
+ * @param incx - stride for x (must be a positive integer)
+ * @returns Euclidean norm scalar — always a CPU readback, even for GpuVector inputs
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/dnrm2/dnrm2.mjs#L21">Source code: dnrm2.mjs (L21)</a>
+ * @category BLAS Level 1
+ */
+export declare function dnrm2(
+  device: GPUDevice,
+  n: number,
+  x: Float64Array,
+  incx: number,
+): Promise<{ nrm2: number } | { nrm2: number; gpuTimeMs: number }>;
+
+/**
+ * Computes the Euclidean norm of a double-precision vector:
+ * $$\text{result} = \sqrt{\sum_{i} x_i^2}$$
+ * — GPU-resident overload; see the Float64Array overload above for the
+ * routine itself.
+ *
+ * {@includeCode ../../examples/dnrm2/gpu.dnrm2.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - GpuVector input vector (must be Float64Array-backed)
+ * @param incx - stride for x (must be a positive integer)
+ * @returns Euclidean norm scalar — always a CPU readback, even for GpuVector inputs
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/dnrm2/dnrm2.mjs#L21">Source code: dnrm2.mjs (L21)</a>
+ * @category BLAS Level 1
+ */
+export declare function dnrm2(
+  device: GPUDevice,
+  n: number,
+  x: GpuVector,
+  incx: number,
+): Promise<{ nrm2: number } | { nrm2: number; gpuTimeMs: number }>;

package/src/dnrm2/dnrm2.mjs

@@ -0,0 +1,189 @@
+import {
+  uploadBuffer,
+  createStorageBuffer,
+  createParamsBuffer,
+  createResultBuffer,
+  stageReadback,
+  destroyBuffers,
+} 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 { GpuVector } from "../classes/GpuVector.mjs";
+import { splitDoubleDouble, mergeDoubleDouble } from "../util/f64.mjs";
+import { WGS } from "../util/constants.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
+
+// dnrm2: sqrt(sum(x[i]*x[i])), double-double (Dekker) f64 emulation of
+// snrm2 — same scaled accumulation (Blue's algorithm) snrm2 uses to avoid
+// overflow, with (scale, ssq) as double-double pairs instead of plain f32.
+// See dnrm2.wgsl for why the per-element branch that algorithm needs had to
+// become branch-free (select()-based) here.
+export async function dnrm2(device, n, x, incx) {
+  const xIsGpu = x instanceof GpuVector;
+
+  requireGpuDevice(device);
+  requireSameDevice(device, "dnrm2", { x });
+  if (!Number.isInteger(n) || !Number.isInteger(incx))
+    throw new Error("n and incx must be integers.");
+  if (incx <= 0) throw new Error("incx must be positive.");
+  if (!xIsGpu && !(x instanceof Float64Array))
+    throw new Error("x must be a Float64Array or GpuVector.");
+  if (xIsGpu && x.dtype !== Float64Array)
+    throw new Error("x must be a Float64Array-backed GpuVector.");
+  if (n <= 0) return { nrm2: 0 };
+  if (x.length < (n - 1) * incx + 1)
+    throw new Error(
+      "x does not have enough elements for the given n and incx.",
+    );
+
+  // Concatenated with f64/dekker.wgsl (DD struct), f64/utils/abs.wgsl
+  // (ddAbs), f64/utils/greater.wgsl (ddGreater), f64/utils/add.wgsl
+  // (ddAddProtected), f64/utils/multiply.wgsl (ddMulProtected),
+  // f64/utils/divide.wgsl (ddDivProtected), and f64/utils/sqrt.wgsl
+  // (ddSqrtProtected) — WGSL has no #include.
+  const f64Deps = [
+    "f64/dekker",
+    "f64/utils/abs",
+    "f64/utils/greater",
+    "f64/utils/add",
+    "f64/utils/multiply",
+    "f64/utils/divide",
+    "f64/utils/sqrt",
+  ];
+  const pipelineMain = await getPipeline(device, [...f64Deps, "dnrm2"]);
+  const pipelineReduce = await getPipeline(device, [
+    ...f64Deps,
+    "reduction/scaledSumF64",
+  ]);
+
+  let xHiBuffer = null;
+  let xLoBuffer = null;
+  let partialsScaleHiBuffer = null;
+  let partialsScaleLoBuffer = null;
+  let partialsSsqHiBuffer = null;
+  let partialsSsqLoBuffer = null;
+  let resultHiBuffer = null;
+  let resultLoBuffer = null;
+  let paramsBuffer = null;
+  let readHiBuffer = null;
+  let readLoBuffer = null;
+
+  try {
+    if (xIsGpu) {
+      xHiBuffer = x._buf;
+      xLoBuffer = x._loBuf;
+    } else {
+      const { hi, lo } = splitDoubleDouble(x);
+      xHiBuffer = uploadBuffer(device, hi, "dnrm2-xHi", false);
+      xLoBuffer = uploadBuffer(device, lo, "dnrm2-xLo", false);
+    }
+    // 2*WGS partial (scale, ssq) DD pairs — see dnrm2.wgsl for what they represent.
+    partialsScaleHiBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "dnrm2-partials-scaleHi",
+    );
+    partialsScaleLoBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "dnrm2-partials-scaleLo",
+    );
+    partialsSsqHiBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "dnrm2-partials-ssqHi",
+    );
+    partialsSsqLoBuffer = createStorageBuffer(
+      device,
+      2 * WGS * 4,
+      "dnrm2-partials-ssqLo",
+    );
+    resultHiBuffer = createResultBuffer(device, 4, "dnrm2-result-hi");
+    resultLoBuffer = createResultBuffer(device, 4, "dnrm2-result-lo");
+    paramsBuffer = createParamsBuffer(
+      device,
+      [
+        { value: n, type: "u32" },
+        { value: incx, type: "u32" },
+      ],
+      "dnrm2-params",
+    );
+
+    const bgMain = createBindGroup(device, pipelineMain.getBindGroupLayout(0), [
+      xHiBuffer,
+      xLoBuffer,
+      partialsScaleHiBuffer,
+      partialsScaleLoBuffer,
+      partialsSsqHiBuffer,
+      partialsSsqLoBuffer,
+      paramsBuffer,
+    ]);
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+      device,
+      pipelineMain,
+      bgMain,
+      2 * WGS,
+    ); // dispatch 2*WGS workgroups
+
+    submit(device, enc1);
+
+    const bgReduce = createBindGroup(
+      device,
+      pipelineReduce.getBindGroupLayout(0),
+      [
+        partialsScaleHiBuffer,
+        partialsScaleLoBuffer,
+        partialsSsqHiBuffer,
+        partialsSsqLoBuffer,
+        resultHiBuffer,
+        resultLoBuffer,
+      ],
+    );
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+      device,
+      pipelineReduce,
+      bgReduce,
+      1,
+    ); // reduce partials to a single result
+    readHiBuffer = stageReadback(device, enc2, resultHiBuffer);
+    readLoBuffer = stageReadback(device, enc2, resultLoBuffer);
+
+    submit(device, enc2);
+
+    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, hiArr, loArr] = await Promise.all([
+      extractTimestamp(ts1),
+      extractTimestamp(ts2),
+      hiPromise,
+      loPromise,
+    ]);
+
+    // reduction/scaledSumF64.wgsl already computes scale·sqrt(ssq) on the
+    // GPU — no separate sqrt step here.
+    const nrm2 = mergeDoubleDouble(hiArr, loArr)[0];
+
+    if (gpuTime1 !== undefined && gpuTime2 !== undefined)
+      return { nrm2, gpuTimeMs: gpuTime1 + gpuTime2 };
+    return { nrm2 };
+  } finally {
+    if (!xIsGpu && xHiBuffer) destroyBuffers(xHiBuffer);
+    if (!xIsGpu && xLoBuffer) destroyBuffers(xLoBuffer);
+    if (partialsScaleHiBuffer) destroyBuffers(partialsScaleHiBuffer);
+    if (partialsScaleLoBuffer) destroyBuffers(partialsScaleLoBuffer);
+    if (partialsSsqHiBuffer) destroyBuffers(partialsSsqHiBuffer);
+    if (partialsSsqLoBuffer) destroyBuffers(partialsSsqLoBuffer);
+    if (resultHiBuffer) destroyBuffers(resultHiBuffer);
+    if (resultLoBuffer) destroyBuffers(resultLoBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if submit(device, enc2) threw before ownership was transferred above.
+    if (readHiBuffer) destroyBuffers(readHiBuffer);
+    if (readLoBuffer) destroyBuffers(readLoBuffer);
+  }
+}

package/src/drot/drot.d.mts

@@ -0,0 +1,67 @@
+import { GpuVector } from "../classes/GpuVector.mjs";
+
+/**
+ * Applies a Givens plane rotation to double-precision vectors x and y:
+ * $$\begin{aligned} x &\leftarrow cx + sy \\\\ y &\leftarrow -sx + cy \end{aligned}$$
+ * — double-double (Dekker) f64 emulation of {@link srot}, since WGSL has no
+ * native f64 type.
+ *
+ * {@includeCode ../../examples/drot/drot.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/drot/web/drot.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - Float64Array input/output vector
+ * @param incx - stride for x (must be a positive integer)
+ * @param y - Float64Array input/output vector
+ * @param incy - stride for y (must be a positive integer)
+ * @param c - cosine of rotation angle
+ * @param s - sine of rotation angle
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/drot/drot.mjs#L19">Source code: drot.mjs (L19)</a>
+ * @category BLAS Level 1
+ */
+export declare function drot(
+  device: GPUDevice,
+  n: number,
+  x: Float64Array,
+  incx: number,
+  y: Float64Array,
+  incy: number,
+  c: number,
+  s: number,
+): Promise<
+  | { x: Float64Array; y: Float64Array }
+  | { x: Float64Array; y: Float64Array; gpuTimeMs: number }
+>;
+
+/**
+ * Applies a Givens plane rotation to double-precision vectors x and y:
+ * $$\begin{aligned} x &\leftarrow cx + sy \\\\ y &\leftarrow -sx + cy \end{aligned}$$
+ * — GPU-resident overload; see the Float64Array overload above for the
+ * routine itself.
+ *
+ * {@includeCode ../../examples/drot/gpu.drot.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param n - number of elements (must be a positive integer)
+ * @param x - GpuVector input/output vector (must be Float64Array-backed, mutated in place)
+ * @param incx - stride for x (must be a positive integer)
+ * @param y - GpuVector input/output vector (must be Float64Array-backed, mutated in place)
+ * @param incy - stride for y (must be a positive integer)
+ * @param c - cosine of rotation angle
+ * @param s - sine of rotation angle
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/drot/drot.mjs#L19">Source code: drot.mjs (L19)</a>
+ * @category BLAS Level 1
+ */
+export declare function drot(
+  device: GPUDevice,
+  n: number,
+  x: GpuVector,
+  incx: number,
+  y: GpuVector,
+  incy: number,
+  c: number,
+  s: number,
+): Promise<{} | { gpuTimeMs: number }>;

package/src/drot/drot.mjs

@@ -0,0 +1,170 @@
+import {
+  uploadBuffer,
+  createParamsBuffer,
+  stageReadback,
+  destroyBuffers,
+} from "../util/buffer.mjs";
+import { createBindGroup } from "../util/bindgroup.mjs";
+import { runComputePass, submit } from "../util/compute.mjs";
+import { extractResult } from "../util/result.mjs";
+import { extractTimestamp } from "../util/benchmark.mjs";
+import { getPipeline } from "../util/pipeline.mjs";
+import { calcWorkgroups } from "../util/workgroup.mjs";
+import { GpuVector } from "../classes/GpuVector.mjs";
+import { splitDoubleDouble, mergeDoubleDouble } from "../util/f64.mjs";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
+
+// drot: x := c*x + s*y, y := -s*x + c*y, double-double (Dekker) f64
+// emulation of srot — x, y, c, and s are each split into an f32 (hi, lo)
+// pair; WGSL has no f64 type.
+export async function drot(device, n, x, incx, y, incy, c, s) {
+  const xIsGpu = x instanceof GpuVector;
+  const yIsGpu = y instanceof GpuVector;
+
+  requireGpuDevice(device);
+  requireSameDevice(device, "drot", { x, y });
+  if (
+    !Number.isInteger(n) ||
+    !Number.isInteger(incx) ||
+    !Number.isInteger(incy)
+  )
+    throw new Error("n, incx, and incy must be integers.");
+  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 (!(x instanceof Float64Array) && !xIsGpu)
+    throw new Error("x must be a Float64Array or GpuVector.");
+  if (!(y instanceof Float64Array) && !yIsGpu)
+    throw new Error("y must be a Float64Array or GpuVector.");
+  if (xIsGpu && x.dtype !== Float64Array)
+    throw new Error("x must be a Float64Array-backed GpuVector.");
+  if (yIsGpu && y.dtype !== Float64Array)
+    throw new Error("y must be a Float64Array-backed GpuVector.");
+  if (xIsGpu !== yIsGpu)
+    throw new Error(
+      "x and y must be the same type (both Float64Array or both GpuVector).",
+    );
+  if (n <= 0) return xIsGpu ? {} : { x, y };
+  if (x.length < (n - 1) * incx + 1)
+    throw new Error(
+      "x does not have enough elements for the given n and incx.",
+    );
+  if (y.length < (n - 1) * incy + 1)
+    throw new Error(
+      "y does not have enough elements for the given n and incy.",
+    );
+
+  // Concatenated with f64/dekker.wgsl (DD struct), f64/utils/add.wgsl
+  // (fsub/negf/fastTwoSumProtected/ddAddProtected), and f64/utils/multiply.wgsl
+  // (ddMulProtected) — WGSL has no #include.
+  const f64Deps = ["f64/dekker", "f64/utils/add", "f64/utils/multiply"];
+  const pipeline = await getPipeline(device, [...f64Deps, "drot"]);
+
+  const { hi: cHi, lo: cLo } = splitDoubleDouble(new Float64Array([c]));
+  const { hi: sHi, lo: sLo } = splitDoubleDouble(new Float64Array([s]));
+
+  let xHiBuffer = null;
+  let xLoBuffer = null;
+  let yHiBuffer = null;
+  let yLoBuffer = null;
+  let paramsBuffer = null;
+  let xReadHiBuffer = null;
+  let xReadLoBuffer = null;
+  let yReadHiBuffer = null;
+  let yReadLoBuffer = null;
+
+  try {
+    if (xIsGpu) {
+      xHiBuffer = x._buf;
+      xLoBuffer = x._loBuf;
+      yHiBuffer = y._buf;
+      yLoBuffer = y._loBuf;
+    } else {
+      const xSplit = splitDoubleDouble(x);
+      const ySplit = splitDoubleDouble(y);
+      xHiBuffer = uploadBuffer(device, xSplit.hi, "drot-xHi", true);
+      xLoBuffer = uploadBuffer(device, xSplit.lo, "drot-xLo", true);
+      yHiBuffer = uploadBuffer(device, ySplit.hi, "drot-yHi", true);
+      yLoBuffer = uploadBuffer(device, ySplit.lo, "drot-yLo", true);
+    }
+    paramsBuffer = createParamsBuffer(
+      device,
+      [
+        { value: n, type: "u32" },
+        { value: cHi[0], type: "f32" },
+        { value: cLo[0], type: "f32" },
+        { value: sHi[0], type: "f32" },
+        { value: sLo[0], type: "f32" },
+        { value: incx, type: "u32" },
+        { value: incy, type: "u32" },
+      ],
+      "drot-params",
+    );
+
+    const bindGroup = createBindGroup(device, pipeline.getBindGroupLayout(0), [
+      xHiBuffer,
+      xLoBuffer,
+      yHiBuffer,
+      yLoBuffer,
+      paramsBuffer,
+    ]);
+    const { commandEncoder, ts } = runComputePass(
+      device,
+      pipeline,
+      bindGroup,
+      calcWorkgroups(device, n),
+    );
+    xReadHiBuffer = xIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, xHiBuffer);
+    xReadLoBuffer = xIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, xLoBuffer);
+    yReadHiBuffer = yIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, yHiBuffer);
+    yReadLoBuffer = yIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, yLoBuffer);
+
+    submit(device, commandEncoder);
+
+    const gpuTimeMs = await extractTimestamp(ts);
+
+    if (xIsGpu) {
+      // xIsGpu === yIsGpu, enforced above
+      if (gpuTimeMs !== undefined) return { gpuTimeMs };
+      return {};
+    }
+
+    const xHi = await extractResult(xReadHiBuffer, Float32Array);
+    xReadHiBuffer = null; // extractResult already destroyed it
+    const xLo = await extractResult(xReadLoBuffer, Float32Array);
+    xReadLoBuffer = null;
+    const yHi = await extractResult(yReadHiBuffer, Float32Array);
+    yReadHiBuffer = null;
+    const yLo = await extractResult(yReadLoBuffer, Float32Array);
+    yReadLoBuffer = null;
+    const resultX = mergeDoubleDouble(xHi, xLo);
+    const resultY = mergeDoubleDouble(yHi, yLo);
+    if (gpuTimeMs !== undefined) return { x: resultX, y: resultY, gpuTimeMs };
+    return { x: resultX, y: resultY };
+  } finally {
+    if (!xIsGpu && xHiBuffer) destroyBuffers(xHiBuffer);
+    if (!xIsGpu && xLoBuffer) destroyBuffers(xLoBuffer);
+    if (!yIsGpu && yHiBuffer) destroyBuffers(yHiBuffer);
+    if (!yIsGpu && yLoBuffer) destroyBuffers(yLoBuffer);
+    if (paramsBuffer) destroyBuffers(paramsBuffer);
+    // Only reached if extractTimestamp or extractResult threw before
+    // clearing these — on the success path they're already null.
+    if (xReadHiBuffer) destroyBuffers(xReadHiBuffer);
+    if (xReadLoBuffer) destroyBuffers(xReadLoBuffer);
+    if (yReadHiBuffer) destroyBuffers(yReadHiBuffer);
+    if (yReadLoBuffer) destroyBuffers(yReadLoBuffer);
+  }
+}