wgblas 2.0.0 → 2.1.0

package/src/snrm2/snrm2.mjs

@@ -12,14 +12,16 @@ 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 { WGS } from "../util/constants.mjs";
+import { requireSameDevice } from "../util/device.mjs";
 
-const WGS = 64; // workgroup size
 
 export async function snrm2(device, n, x, incx) {
   const xIsGpu = x instanceof GpuVector;
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "snrm2", { 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.");
@@ -32,19 +34,25 @@ export async function snrm2(device, n, x, incx) {
     );
 
   const pipelineMain = await getPipeline(device, "snrm2");
-  const pipelineReduce = await getPipeline(device, "reduction/sum");
+  const pipelineReduce = await getPipeline(device, "reduction/scaledSum");
 
   let xBuffer = null;
-  let partialsBuffer = null;
+  let partialsScaleBuffer = null;
+  let partialsSsqBuffer = null;
   let resultBuffer = null;
   let paramsBuffer = null;
   let readBuffer = null;
 
   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(
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "snrm2-x", false);
+    // 2*WGS partial (scale, ssq) pairs — see snrm2.wgsl for what they represent.
+    partialsScaleBuffer = createStorageBuffer(device,
+      2 * WGS * 4,
+      "snrm2-partials-scale",
+    );
+    partialsSsqBuffer = createStorageBuffer(device, 2 * WGS * 4, "snrm2-partials-ssq");
+    resultBuffer = createResultBuffer(device, 4, "snrm2-result"); // final f32 scalar
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -52,53 +60,57 @@ export async function snrm2(device, n, x, incx) {
       "snrm2-params",
     );
 
-    const bgMain = createBindGroup(pipelineMain.getBindGroupLayout(0), [
+    const bgMain = createBindGroup(device, pipelineMain.getBindGroupLayout(0), [
       xBuffer,
-      partialsBuffer,
+      partialsScaleBuffer,
+      partialsSsqBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder: enc1, ts: ts1 } = runComputePass(
+    const { commandEncoder: enc1, ts: ts1 } = runComputePass(device,
       pipelineMain,
       bgMain,
       2 * WGS,
     ); // dispatch 2*WGS workgroups
 
-    submit(enc1);
+    submit(device, enc1);
 
-    const bgReduce = createBindGroup(pipelineReduce.getBindGroupLayout(0), [
-      partialsBuffer,
+    const bgReduce = createBindGroup(device, pipelineReduce.getBindGroupLayout(0), [
+      partialsScaleBuffer,
+      partialsSsqBuffer,
       resultBuffer,
     ]);
-    const { commandEncoder: enc2, ts: ts2 } = runComputePass(
+    const { commandEncoder: enc2, ts: ts2 } = runComputePass(device,
       pipelineReduce,
       bgReduce,
       1,
     ); // reduce partials to single result
-    readBuffer = stageReadback(enc2, resultBuffer);
+    readBuffer = stageReadback(device, enc2, resultBuffer);
 
-    submit(enc2);
+    submit(device, enc2);
 
     const resultPromise = extractResult(readBuffer, Float32Array);
     readBuffer = null; // ownership transferred — extractResult's own finally destroys it
 
-    const [gpuTime1, gpuTime2, sqsumArr] = await Promise.all([
+    const [gpuTime1, gpuTime2, resultArr] = 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]);
+    // reduction/scaledSum.wgsl already computes scale·sqrt(ssq) on the GPU —
+    // unlike the old naive-sum version, there's no separate sqrt step here.
+    const nrm2 = resultArr[0];
 
     if (gpuTime1 !== undefined && gpuTime2 !== undefined)
       return { nrm2, gpuTimeMs: gpuTime1 + gpuTime2 };
     return { nrm2 };
   } finally {
     if (!xIsGpu && xBuffer) destroyBuffers(xBuffer);
-    if (partialsBuffer) destroyBuffers(partialsBuffer);
+    if (partialsScaleBuffer) destroyBuffers(partialsScaleBuffer);
+    if (partialsSsqBuffer) destroyBuffers(partialsSsqBuffer);
     if (resultBuffer) destroyBuffers(resultBuffer);
     if (paramsBuffer) destroyBuffers(paramsBuffer);
-    // Only reached if submit(enc2) threw before ownership was transferred above.
+    // Only reached if submit(device, enc2) threw before ownership was transferred above.
     if (readBuffer) destroyBuffers(readBuffer);
   }
 }

package/src/srot/srot.d.mts

@@ -2,8 +2,7 @@ import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
  * Applies a Givens plane rotation to vectors x and y:
- *   x = c*x + s*y
- *   y = -s*x + c*y
+ * $$\begin{aligned} x &\leftarrow cx + sy \\\\ y &\leftarrow -sx + cy \end{aligned}$$
  *
  * {@includeCode ../../examples/srot/srot.js}
  *
@@ -34,8 +33,7 @@ export declare function srot(
 
 /**
  * Applies a Givens plane rotation to vectors x and y:
- *   x = c*x + s*y
- *   y = -s*x + c*y
+ * $$\begin{aligned} x &\leftarrow cx + sy \\\\ y &\leftarrow -sx + cy \end{aligned}$$
  *
  * {@includeCode ../../examples/srot/gpu.srot.js}
  *

package/src/srot/srot.mjs

@@ -11,6 +11,7 @@ import { extractResult } from "../util/result.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { calcWorkgroups } from "../util/workgroup.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
+import { requireSameDevice } from "../util/device.mjs";
 
 export async function srot(device, n, x, incx, y, incy, c, s) {
   const xIsGpu = x instanceof GpuVector;
@@ -18,6 +19,7 @@ export async function srot(device, n, x, incx, y, incy, c, s) {
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "srot", { x, y });
   if (
     !Number.isInteger(n) ||
     !Number.isInteger(incx) ||
@@ -58,9 +60,9 @@ export async function srot(device, n, x, incx, y, incy, c, s) {
   let readY = null;
 
   try {
-    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "srot-x", true);
-    yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "srot-y", true);
-    paramsBuffer = createParamsBuffer(
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "srot-x", true);
+    yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "srot-y", true);
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n, type: "u32" },
         { value: c, type: "f32" },
@@ -71,19 +73,19 @@ export async function srot(device, n, x, incx, y, incy, c, s) {
       "srot-params",
     );
 
-    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+    const bindGroup = createBindGroup(device, pipeline.getBindGroupLayout(0), [
       xBuffer,
       yBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(
+    const { commandEncoder, ts } = runComputePass(device,
       pipeline,
       bindGroup,
-      calcWorkgroups(n),
+      calcWorkgroups(device, n),
     );
-    readX = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
-    readY = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
-    submit(commandEncoder);
+    readX = xIsGpu ? null : stageReadback(device, commandEncoder, xBuffer);
+    readY = yIsGpu ? null : stageReadback(device, commandEncoder, yBuffer);
+    submit(device, commandEncoder);
 
     const gpuTimeMs = await extractTimestamp(ts);
 

package/src/srotm/srotm.d.mts

@@ -2,8 +2,7 @@ import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
  * Applies a modified Givens plane rotation H to vectors x and y:
- *   x = H[0][0]*x + H[0][1]*y
- *   y = H[1][0]*x + H[1][1]*y
+ * $$\begin{pmatrix} x \\\\ y \end{pmatrix} \leftarrow \begin{pmatrix} h_{11} & h_{12} \\\\ h_{21} & h_{22} \end{pmatrix} \begin{pmatrix} x \\\\ y \end{pmatrix}$$
  *
  * {@includeCode ../../examples/srotm/srotm.js}
  *
@@ -33,8 +32,7 @@ export declare function srotm(
 
 /**
  * Applies a modified Givens plane rotation H to vectors x and y:
- *   x = H[0][0]*x + H[0][1]*y
- *   y = H[1][0]*x + H[1][1]*y
+ * $$\begin{pmatrix} x \\\\ y \end{pmatrix} \leftarrow \begin{pmatrix} h_{11} & h_{12} \\\\ h_{21} & h_{22} \end{pmatrix} \begin{pmatrix} x \\\\ y \end{pmatrix}$$
  *
  * {@includeCode ../../examples/srotm/gpu.srotm.js}
  *

package/src/srotm/srotm.mjs

@@ -11,6 +11,7 @@ import { extractResult } from "../util/result.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { calcWorkgroups } from "../util/workgroup.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
+import { requireSameDevice } from "../util/device.mjs";
 
 export async function srotm(device, n, x, incx, y, incy, param) {
   const xIsGpu = x instanceof GpuVector;
@@ -18,6 +19,7 @@ export async function srotm(device, n, x, incx, y, incy, param) {
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "srotm", { x, y });
   if (
     !Number.isInteger(n) ||
     !Number.isInteger(incx) ||
@@ -26,6 +28,13 @@ export async function srotm(device, n, x, incx, y, incy, param) {
     throw new Error("n, incx, and incy must be integers.");
   if (!(param instanceof Float32Array) || param.length !== 5)
     throw new Error("param must be a Float32Array of length 5.");
+  if (
+    param[0] !== -2 &&
+    param[0] !== -1 &&
+    param[0] !== 0 &&
+    param[0] !== 1
+  )
+    throw new Error("param[0] (flag) must be one of -2, -1, 0, or 1.");
   if (incx <= 0 || incy <= 0)
     throw new Error("incx and incy must be positive.");
   if (!xIsGpu && !(x instanceof Float32Array))
@@ -56,10 +65,10 @@ export async function srotm(device, n, x, incx, y, incy, param) {
   let readY = null;
 
   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(
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "srotm-x", true);
+    yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "srotm-y", true);
+    paramBuffer = uploadBuffer(device, param, "srotm-param", false);
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -68,20 +77,20 @@ export async function srotm(device, n, x, incx, y, incy, param) {
       "srotm-params",
     );
 
-    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+    const bindGroup = createBindGroup(device, pipeline.getBindGroupLayout(0), [
       xBuffer,
       yBuffer,
       paramBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(
+    const { commandEncoder, ts } = runComputePass(device,
       pipeline,
       bindGroup,
-      calcWorkgroups(n),
+      calcWorkgroups(device, n),
     );
-    readX = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
-    readY = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
-    submit(commandEncoder);
+    readX = xIsGpu ? null : stageReadback(device, commandEncoder, xBuffer);
+    readY = yIsGpu ? null : stageReadback(device, commandEncoder, yBuffer);
+    submit(device, commandEncoder);
 
     const gpuTimeMs = await extractTimestamp(ts);
 

package/src/sscal/sscal.d.mts

@@ -1,7 +1,7 @@
 import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
- * Scales a single-precision vector by a constant: x = alpha * x
+ * Scales a single-precision vector by a constant: $$x \leftarrow \alpha x$$
  *
  * {@includeCode ../../examples/sscal/sscal.js}
  *
@@ -22,10 +22,10 @@ export declare function sscal(
   alpha: number,
   x: Float32Array,
   incx: number,
-): Promise<Float32Array | { result: Float32Array; gpuTimeMs: number }>;
+): Promise<{ x: Float32Array } | { x: Float32Array; gpuTimeMs: number }>;
 
 /**
- * Scales a single-precision vector by a constant: x = alpha * x
+ * Scales a single-precision vector by a constant: $$x \leftarrow \alpha x$$
  *
  * {@includeCode ../../examples/sscal/gpu.sscal.js}
  *

package/src/sscal/sscal.mjs

@@ -11,12 +11,14 @@ 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 { requireSameDevice } from "../util/device.mjs";
 
 export async function sscal(device, n, alpha, x, incx) {
   const xIsGpu = x instanceof GpuVector;
-  
+
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "sscal", { x });
   if (!Number.isInteger(n) || !Number.isInteger(incx))
     throw new Error("n and incx must be integers.");
   if (typeof alpha !== "number")
@@ -26,7 +28,7 @@ export async function sscal(device, n, alpha, x, incx) {
   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.");
-  if (n <= 0) return xIsGpu ? {} : x;
+  if (n <= 0) return xIsGpu ? {} : { x };
   if (x.length < (n - 1) * incx + 1)
     throw new Error(
       "x does not have enough elements for the given n and incx.",
@@ -39,8 +41,8 @@ export async function sscal(device, n, alpha, x, incx) {
   let readBuffer = null;
 
   try {
-    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "sscal-x", true);
-    paramsBuffer = createParamsBuffer(
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "sscal-x", true);
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n, type: "u32" },
         { value: alpha, type: "f32" },
@@ -49,18 +51,18 @@ export async function sscal(device, n, alpha, x, incx) {
       "sscal-params",
     );
 
-    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+    const bindGroup = createBindGroup(device, pipeline.getBindGroupLayout(0), [
       xBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(
+    const { commandEncoder, ts } = runComputePass(device,
       pipeline,
       bindGroup,
-      calcWorkgroups(n),
+      calcWorkgroups(device, n),
     );
-    readBuffer = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
+    readBuffer = xIsGpu ? null : stageReadback(device, commandEncoder, xBuffer);
 
-    submit(commandEncoder);
+    submit(device, commandEncoder);
 
     const gpuTimeMs = await extractTimestamp(ts);
 
@@ -72,7 +74,7 @@ export async function sscal(device, n, alpha, x, incx) {
     const result = await extractResult(readBuffer, Float32Array);
     readBuffer = null; // extractResult already destroyed it
     if (gpuTimeMs !== undefined) return { x: result, gpuTimeMs };
-    return result;
+    return { x: result };
   } finally {
     if (!xIsGpu && xBuffer) destroyBuffers(xBuffer);
     if (paramsBuffer) destroyBuffers(paramsBuffer);

package/src/sswap/sswap.d.mts

@@ -1,7 +1,7 @@
 import { GpuVector } from "../classes/GpuVector.mjs";
 
 /**
- * Swaps the elements of two single-precision vectors: x <-> y
+ * Swaps the elements of two single-precision vectors: $$x \leftrightarrow y$$
  *
  * {@includeCode ../../examples/sswap/sswap.js}
  *
@@ -27,7 +27,7 @@ export declare function sswap(
 ): Promise<{ x: Float32Array; y: Float32Array } | { x: Float32Array; y: Float32Array; gpuTimeMs: number }>;
 
 /**
- * Swaps the elements of two single-precision vectors: x <-> y
+ * Swaps the elements of two single-precision vectors: $$x \leftrightarrow y$$
  *
  * {@includeCode ../../examples/sswap/gpu.sswap.js}
  *

package/src/sswap/sswap.mjs

@@ -11,6 +11,7 @@ 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 { requireSameDevice } from "../util/device.mjs";
 
 export async function sswap(device, n, x, incx, y, incy) {
   const xIsGpu = x instanceof GpuVector;
@@ -18,6 +19,7 @@ export async function sswap(device, n, x, incx, y, incy) {
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "sswap", { x, y });
   if (
     !Number.isInteger(n) ||
     !Number.isInteger(incx) ||
@@ -53,9 +55,9 @@ export async function sswap(device, n, x, incx, y, incy) {
   let yReadBuffer = null;
 
   try {
-    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "sswap-x", true);
-    yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "sswap-y", true);
-    paramsBuffer = createParamsBuffer(
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "sswap-x", true);
+    yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "sswap-y", true);
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -64,20 +66,20 @@ export async function sswap(device, n, x, incx, y, incy) {
       "sswap-params",
     );
 
-    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+    const bindGroup = createBindGroup(device, pipeline.getBindGroupLayout(0), [
       xBuffer,
       yBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(
+    const { commandEncoder, ts } = runComputePass(device,
       pipeline,
       bindGroup,
-      calcWorkgroups(n),
+      calcWorkgroups(device, n),
     );
-    xReadBuffer = xIsGpu ? null : stageReadback(commandEncoder, xBuffer);
-    yReadBuffer = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
+    xReadBuffer = xIsGpu ? null : stageReadback(device, commandEncoder, xBuffer);
+    yReadBuffer = yIsGpu ? null : stageReadback(device, commandEncoder, yBuffer);
 
-    submit(commandEncoder);
+    submit(device, commandEncoder);
 
     const gpuTimeMs = await extractTimestamp(ts);
 

package/src/ssymm/ssymm.mjs

@@ -4,6 +4,7 @@ import {
   createStorageBuffer,
   stageReadback,
   destroyBuffers,
+  vec4ViewBinding,
 } from "../util/buffer.mjs";
 import { createBindGroup } from "../util/bindgroup.mjs";
 import { beginTimedEncoder, encodePass, submit } from "../util/compute.mjs";
@@ -11,11 +12,11 @@ import { extractResult } from "../util/result.mjs";
 import { resolveTimestamp, extractTimestamp } from "../util/benchmark.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
+import { requireWorkgroupCount } from "../util/workgroup.mjs";
+import { BM_SMALL, BN_SMALL, BM_LARGE, BN_LARGE, LARGE_TILE_WORKGROUP_THRESHOLD } from "../util/constants.mjs";
+import { TILE_WG_2D } from "../util/constants.mjs";
+import { requireSameDevice } from "../util/device.mjs";
 
-const BM_SMALL = 32, BN_SMALL = 32; // sgemm_small.wgsl's block tile
-const BM_LARGE = 64, BN_LARGE = 64; // sgemm_large.wgsl's block tile
-const LARGE_TILE_WORKGROUP_THRESHOLD = 36; // same threshold sgemm/sgemmtr/ssyrk use
-const SYM_WG = 8; // symmetrize.wgsl's @workgroup_size(8, 8)
 
 // ssymm: C := alpha*A*B + beta*C (side='left') or alpha*B*A + beta*C
 // (side='right'), A symmetric. No fused kernel — symmetrize then sgemm,
@@ -29,6 +30,7 @@ export async function ssymm(
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "ssymm", { A, B, C });
   if (side !== "left" && side !== "right")
     throw new Error("side must be 'left' or 'right'.");
   if (uplo !== "lower" && uplo !== "upper")
@@ -128,22 +130,22 @@ export async function ssymm(
   const symPipeline = await getPipeline(device, "symmetrize");
   const gemmWgCount = useLargeTile
     ? {
-      x: Math.min(largeWgX, device.limits.maxComputeWorkgroupsPerDimension),
-      y: Math.min(largeWgY, device.limits.maxComputeWorkgroupsPerDimension),
+      x: requireWorkgroupCount(device, largeWgX, "ssymm", "x"),
+      y: requireWorkgroupCount(device, largeWgY, "ssymm", "y"),
     }
     : {
-      x: Math.min(Math.ceil(ng / BN_SMALL), device.limits.maxComputeWorkgroupsPerDimension),
-      y: Math.min(Math.ceil(mg / BM_SMALL), device.limits.maxComputeWorkgroupsPerDimension),
+      x: requireWorkgroupCount(device, Math.ceil(ng / BN_SMALL), "ssymm", "x"),
+      y: requireWorkgroupCount(device, Math.ceil(mg / BM_SMALL), "ssymm", "y"),
     };
 
-  const ABuffer = AIsGpu ? A._buf : uploadBuffer(A, "ssymm-A", false);
-  const BBuffer = BIsGpu ? B._buf : uploadBuffer(B, "ssymm-B", false);
-  const CBuffer = CIsGpu ? C._buf : uploadBuffer(C, "ssymm-C", true);
-  const AdenseBuffer = createStorageBuffer(aOrder * ldDense * 4, "ssymm-Adense");
+  const ABuffer = AIsGpu ? A._buf : uploadBuffer(device, A, "ssymm-A", false);
+  const BBuffer = BIsGpu ? B._buf : uploadBuffer(device, B, "ssymm-B", false);
+  const CBuffer = CIsGpu ? C._buf : uploadBuffer(device, C, "ssymm-C", true);
+  const AdenseBuffer = createStorageBuffer(device, aOrder * ldDense * 4, "ssymm-Adense");
   let symParams = null, gemmParams = null;
 
   try {
-    symParams = createParamsBuffer(
+    symParams = createParamsBuffer(device,
       [
         { value: aOrder, type: "u32" },
         { value: lda, type: "u32" },
@@ -152,7 +154,7 @@ export async function ssymm(
       ],
       "ssymm-sym-params",
     );
-    const symBindGroup = createBindGroup(symPipeline.getBindGroupLayout(0), [ABuffer, AdenseBuffer, symParams]);
+    const symBindGroup = createBindGroup(device, symPipeline.getBindGroupLayout(0), [ABuffer, AdenseBuffer, symParams]);
 
     // X/Y buffers and their own ld, matching swapXY above.
     const XBuffer = swapXY ? BBuffer : AdenseBuffer;
@@ -160,7 +162,7 @@ export async function ssymm(
     const YBuffer = swapXY ? AdenseBuffer : BBuffer;
     const ldY = swapXY ? ldDense : ldb;
 
-    gemmParams = createParamsBuffer(
+    gemmParams = createParamsBuffer(device,
       [
         { value: mg,  type: "u32" },
         { value: ng,  type: "u32" },
@@ -175,18 +177,25 @@ export async function ssymm(
       ],
       "ssymm-gemm-params",
     );
-    const gemmBindGroup = createBindGroup(gemmPipeline.getBindGroupLayout(0), [XBuffer, YBuffer, CBuffer, gemmParams]);
-
-    const { commandEncoder, querySet } = beginTimedEncoder();
+    const gemmBindGroup = createBindGroup(device, gemmPipeline.getBindGroupLayout(0), [
+      XBuffer,
+      vec4ViewBinding(device, XBuffer),
+      YBuffer,
+      vec4ViewBinding(device, YBuffer),
+      CBuffer,
+      gemmParams,
+    ]);
+
+    const { commandEncoder, querySet } = beginTimedEncoder(device);
     const symDesc = querySet ? { timestampWrites: { querySet, beginningOfPassWriteIndex: 0 } } : undefined;
     const gemmDesc = querySet ? { timestampWrites: { querySet, endOfPassWriteIndex: 1 } } : undefined;
-    encodePass(commandEncoder, symPipeline, symBindGroup, { x: Math.ceil(aOrder / SYM_WG), y: Math.ceil(aOrder / SYM_WG) }, symDesc);
+    encodePass(commandEncoder, symPipeline, symBindGroup, { x: Math.ceil(aOrder / TILE_WG_2D), y: Math.ceil(aOrder / TILE_WG_2D) }, symDesc);
     encodePass(commandEncoder, gemmPipeline, gemmBindGroup, gemmWgCount, gemmDesc);
 
-    const ts = resolveTimestamp(commandEncoder, querySet);
-    const readBuffer = CIsGpu ? null : stageReadback(commandEncoder, CBuffer);
+    const ts = resolveTimestamp(device, commandEncoder, querySet);
+    const readBuffer = CIsGpu ? null : stageReadback(device, commandEncoder, CBuffer);
 
-    submit(commandEncoder);
+    submit(device, commandEncoder);
 
     const gpuTimeMs = await extractTimestamp(ts);
 

package/src/ssymv/ssymv.mjs

@@ -11,6 +11,7 @@ import { extractTimestamp } from "../util/benchmark.mjs";
 import { getPipeline } from "../util/pipeline.mjs";
 import { GpuVector } from "../classes/GpuVector.mjs";
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
+import { requireSameDevice } from "../util/device.mjs";
 
 export async function ssymv(device, uplo, n, alpha, A, lda, x, incx, beta, y, incy, layout = "row-major") {
   const xIsGpu = x instanceof GpuVector;
@@ -19,6 +20,7 @@ export async function ssymv(device, uplo, n, alpha, A, lda, x, incx, beta, y, in
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "ssymv", { A, x, y });
   if (uplo !== "lower" && uplo !== "upper")
     throw new Error("uplo must be 'lower' or 'upper'.");
   if (layout !== "row-major" && layout !== "column-major")
@@ -89,10 +91,10 @@ export async function ssymv(device, uplo, n, alpha, A, lda, x, incx, beta, y, in
   let paramsBuffer = null;
 
   try {
-    ABuffer = AIsGpu ? A._buf : uploadBuffer(A, "ssymv-A", false);
-    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "ssymv-x", false);
-    yBuffer = yIsGpu ? y._buf : uploadBuffer(y, "ssymv-y", true);
-    paramsBuffer = createParamsBuffer(
+    ABuffer = AIsGpu ? A._buf : uploadBuffer(device, A, "ssymv-A", false);
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "ssymv-x", false);
+    yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "ssymv-y", true);
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n,               type: "u32" },
         { value: alpha,           type: "f32" },
@@ -105,7 +107,7 @@ export async function ssymv(device, uplo, n, alpha, A, lda, x, incx, beta, y, in
       "ssymv-params",
     );
 
-    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+    const bindGroup = createBindGroup(device, pipeline.getBindGroupLayout(0), [
       ABuffer,
       xBuffer,
       yBuffer,
@@ -113,10 +115,10 @@ export async function ssymv(device, uplo, n, alpha, A, lda, x, incx, beta, y, in
     ]);
 
     const wgCount = Math.min(n, device.limits.maxComputeWorkgroupsPerDimension);
-    const { commandEncoder, ts } = runComputePass(pipeline, bindGroup, wgCount);
-    const readBuffer = yIsGpu ? null : stageReadback(commandEncoder, yBuffer);
+    const { commandEncoder, ts } = runComputePass(device, pipeline, bindGroup, wgCount);
+    const readBuffer = yIsGpu ? null : stageReadback(device, commandEncoder, yBuffer);
 
-    submit(commandEncoder);
+    submit(device, commandEncoder);
 
     const gpuTimeMs = await extractTimestamp(ts);