wgblas 2.0.0 → 2.2.0

package/src/srotm/srotm.mjs

@@ -11,13 +11,14 @@ 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 { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 export async function srotm(device, n, x, incx, y, incy, param) {
   const xIsGpu = x instanceof GpuVector;
   const yIsGpu = y instanceof GpuVector;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
+  requireSameDevice(device, "srotm", { x, y });
   if (
     !Number.isInteger(n) ||
     !Number.isInteger(incx) ||
@@ -26,6 +27,8 @@ 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 +59,11 @@ 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);
+    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,24 +72,26 @@ 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(
+      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);
 
-    if (xIsGpu && yIsGpu) {
+    if (xIsGpu) {
+      // xIsGpu === yIsGpu, enforced above
       if (gpuTimeMs !== undefined) return { gpuTimeMs };
       return {};
     }

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,22 +11,22 @@ 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 { requireGpuDevice, 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.");
+
+  requireGpuDevice(device);
+  requireSameDevice(device, "sscal", { x });
   if (!Number.isInteger(n) || !Number.isInteger(incx))
     throw new Error("n and incx must be integers.");
-  if (typeof alpha !== "number")
-    throw new Error("alpha must be a number.");
+  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.");
-  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 +39,9 @@ export async function sscal(device, n, alpha, x, incx) {
   let readBuffer = null;
 
   try {
-    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "sscal-x", true);
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "sscal-x", true);
     paramsBuffer = createParamsBuffer(
+      device,
       [
         { value: n, type: "u32" },
         { value: alpha, type: "f32" },
@@ -49,18 +50,19 @@ 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(
+      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,13 +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 { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 export async function sswap(device, n, x, incx, y, incy) {
   const xIsGpu = x instanceof GpuVector;
   const yIsGpu = y instanceof GpuVector;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
+  requireSameDevice(device, "sswap", { x, y });
   if (
     !Number.isInteger(n) ||
     !Number.isInteger(incx) ||
@@ -53,9 +54,10 @@ 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);
+    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,24 +66,30 @@ 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(
+      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);
 
-    if (xIsGpu && yIsGpu) {
+    if (xIsGpu) {
+      // xIsGpu === yIsGpu, enforced above (x.constructor !== y.constructor throws)
       if (gpuTimeMs !== undefined) return { gpuTimeMs };
       return {};
     }

package/src/ssymm/ssymm.d.mts

@@ -2,8 +2,9 @@ import { GpuMatrix } from "../classes/GpuMatrix.mjs";
 
 /**
  * Performs the symmetric matrix-matrix operation
- * C := alpha * A * B + beta * C (`side='left'`) or
- * C := alpha * B * A + beta * C (`side='right'`) — `A` is symmetric, only
+ * $$C \leftarrow \alpha A B + \beta C \quad (\texttt{side='left'})$$
+ * $$C \leftarrow \alpha B A + \beta C \quad (\texttt{side='right'})$$
+ * `A` is symmetric, only
  * its `uplo` triangle stored; `B` and `C` are general m×n matrices.
  *
  * - `side='left'`:  `A` is m×m — `A` premultiplies `B`
@@ -59,8 +60,8 @@ export declare function ssymm(
 
 /**
  * Performs the symmetric matrix-matrix operation
- * C := alpha * A * B + beta * C (`side='left'`) or
- * C := alpha * B * A + beta * C (`side='right'`)
+ * $$C \leftarrow \alpha A B + \beta C \quad (\texttt{side='left'})$$
+ * $$C \leftarrow \alpha B A + \beta C \quad (\texttt{side='right'})$$
  *
  * A, B, and C are all kept GPU-resident. Each matrix's own `layout` (set at
  * `GpuMatrix.from` time) determines the operation — there is no separate

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,41 +12,60 @@ 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";
-
-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)
+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 { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 // 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,
 // both on one command encoder. See symmetrize.wgsl.
 export async function ssymm(
-  device, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, layout = "row-major",
+  device,
+  side,
+  uplo,
+  m,
+  n,
+  alpha,
+  A,
+  lda,
+  B,
+  ldb,
+  beta,
+  C,
+  ldc,
+  layout = "row-major",
 ) {
   const AIsGpu = A instanceof GpuMatrix;
   const BIsGpu = B instanceof GpuMatrix;
   const CIsGpu = C instanceof GpuMatrix;
 
-  if (!(device instanceof GPUDevice))
-    throw new Error("device must be a GPUDevice.");
+  requireGpuDevice(device);
+  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")
     throw new Error("uplo must be 'lower' or 'upper'.");
   if (layout !== "row-major" && layout !== "column-major")
     throw new Error("layout must be 'row-major' or 'column-major'.");
-  if (typeof alpha !== "number")
-    throw new Error("alpha must be a number.");
+  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 (typeof beta !== "number")
-    throw new Error("beta must be a number.");
+  if (typeof beta !== "number") throw new Error("beta must be a number.");
   if (Number.isNaN(beta)) throw new Error("beta must not be NaN.");
   if (!Number.isFinite(beta)) throw new Error("beta must be finite.");
   if (
-    !Number.isInteger(m) || !Number.isInteger(n) ||
-    !Number.isInteger(lda) || !Number.isInteger(ldb) || !Number.isInteger(ldc)
+    !Number.isInteger(m) ||
+    !Number.isInteger(n) ||
+    !Number.isInteger(lda) ||
+    !Number.isInteger(ldb) ||
+    !Number.isInteger(ldc)
   )
     throw new Error("m, n, lda, ldb, and ldc must be integers.");
   if (!AIsGpu && !(A instanceof Float32Array))
@@ -67,48 +87,71 @@ export async function ssymm(
 
   // A: symmetric, order = m (side='left') or n (side='right').
   const aOrder = side === "left" ? m : n;
-  if (lda < aOrder) throw new Error("lda must be >= " + (side === "left" ? "m" : "n") + ".");
+  if (lda < aOrder)
+    throw new Error("lda must be >= " + (side === "left" ? "m" : "n") + ".");
   if (AIsGpu) {
-    if (lda !== A.lda) throw new Error("lda must match A.lda when A is a GpuMatrix.");
-    if (A.rows < aOrder || A.cols < aOrder) throw new Error("A is too small for the given m/n and side.");
+    if (lda !== A.lda)
+      throw new Error("lda must match A.lda when A is a GpuMatrix.");
+    if (A.rows < aOrder || A.cols < aOrder)
+      throw new Error("A is too small for the given m/n and side.");
   } else if (A.length < (aOrder - 1) * lda + aOrder) {
-    throw new Error("A does not have enough elements for the given dimensions and lda.");
+    throw new Error(
+      "A does not have enough elements for the given dimensions and lda.",
+    );
   }
 
   // B: always m x n, no trans flag — same shape rule as sgemm's C.
   const bOuter = effLayoutB === "column-major" ? n : m;
   const bInner = effLayoutB === "column-major" ? m : n;
   if (ldb < bInner)
-    throw new Error(`ldb must be >= ${effLayoutB === "column-major" ? "rows" : "cols"} of B as stored.`);
+    throw new Error(
+      `ldb must be >= ${effLayoutB === "column-major" ? "rows" : "cols"} of B as stored.`,
+    );
   if (BIsGpu) {
-    if (ldb !== B.lda) throw new Error("ldb must match B.lda when B is a GpuMatrix.");
-    if (B.rows < m || B.cols < n) throw new Error("B is too small for the given m and n.");
+    if (ldb !== B.lda)
+      throw new Error("ldb must match B.lda when B is a GpuMatrix.");
+    if (B.rows < m || B.cols < n)
+      throw new Error("B is too small for the given m and n.");
   } else if (B.length < (bOuter - 1) * ldb + bInner) {
-    throw new Error("B does not have enough elements for the given dimensions and ldb.");
+    throw new Error(
+      "B does not have enough elements for the given dimensions and ldb.",
+    );
   }
 
   // C: always m x n.
   const cOuter = effLayoutC === "column-major" ? n : m;
   const cInner = effLayoutC === "column-major" ? m : n;
   if (ldc < cInner)
-    throw new Error(`ldc must be >= ${effLayoutC === "column-major" ? "rows" : "cols"} of C as stored.`);
+    throw new Error(
+      `ldc must be >= ${effLayoutC === "column-major" ? "rows" : "cols"} of C as stored.`,
+    );
   if (CIsGpu) {
-    if (ldc !== C.lda) throw new Error("ldc must match C.lda when C is a GpuMatrix.");
-    if (C.rows < m || C.cols < n) throw new Error("C is too small for the given m and n.");
+    if (ldc !== C.lda)
+      throw new Error("ldc must match C.lda when C is a GpuMatrix.");
+    if (C.rows < m || C.cols < n)
+      throw new Error("C is too small for the given m and n.");
   } else if (C.length < (cOuter - 1) * ldc + cInner) {
-    throw new Error("C does not have enough elements for the given dimensions and ldc.");
+    throw new Error(
+      "C does not have enough elements for the given dimensions and ldc.",
+    );
   }
 
   // A = A^T, so column-major storage is still A, but the populated
   // triangle swaps — uplo flips (same reasoning ssyr/ssyrk use).
-  const uploEffA = effLayoutA === "column-major" ? (uplo === "lower" ? "upper" : "lower") : uplo;
+  const uploEffA =
+    effLayoutA === "column-major"
+      ? uplo === "lower"
+        ? "upper"
+        : "lower"
+      : uplo;
 
   const transB = effLayoutB === "column-major" ? "transpose" : "no-transpose";
   const transDense = "no-transpose"; // Adense is always row-major
 
   // X*Y (X=Adense,Y=B for side='left', swapped for 'right'). Column-major
   // C: compute C^T instead (swap X/Y, flip trans, swap m_g/n_g) — sgemm's own trick.
-  let mg = m, ng = n;
+  let mg = m,
+    ng = n;
   const kg = aOrder;
   let transX = side === "left" ? transDense : transB;
   let transY = side === "left" ? transB : transDense;
@@ -124,26 +167,45 @@ export async function ssymm(
   const largeWgX = Math.ceil(ng / BN_LARGE);
   const largeWgY = Math.ceil(mg / BM_LARGE);
   const useLargeTile = largeWgX * largeWgY >= LARGE_TILE_WORKGROUP_THRESHOLD;
-  const gemmPipeline = await getPipeline(device, useLargeTile ? "sgemm_large" : "sgemm_small");
+  const gemmPipeline = await getPipeline(
+    device,
+    useLargeTile ? "sgemm_large" : "sgemm_small",
+  );
   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");
-  let symParams = null, gemmParams = null;
+  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(
+      device,
       [
         { value: aOrder, type: "u32" },
         { value: lda, type: "u32" },
@@ -152,7 +214,11 @@ 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;
@@ -161,12 +227,13 @@ export async function ssymm(
     const ldY = swapXY ? ldDense : ldb;
 
     gemmParams = createParamsBuffer(
+      device,
       [
-        { value: mg,  type: "u32" },
-        { value: ng,  type: "u32" },
-        { value: kg,  type: "u32" },
+        { value: mg, type: "u32" },
+        { value: ng, type: "u32" },
+        { value: kg, type: "u32" },
         { value: alpha, type: "f32" },
-        { value: beta,  type: "f32" },
+        { value: beta, type: "f32" },
         { value: ldX, type: "u32" },
         { value: ldY, type: "u32" },
         { value: ldc, type: "u32" },
@@ -175,18 +242,47 @@ export async function ssymm(
       ],
       "ssymm-gemm-params",
     );
-    const gemmBindGroup = createBindGroup(gemmPipeline.getBindGroupLayout(0), [XBuffer, YBuffer, CBuffer, gemmParams]);
+    const gemmBindGroup = createBindGroup(
+      device,
+      gemmPipeline.getBindGroupLayout(0),
+      [
+        XBuffer,
+        vec4ViewBinding(device, XBuffer),
+        YBuffer,
+        vec4ViewBinding(device, YBuffer),
+        CBuffer,
+        gemmParams,
+      ],
+    );
 
-    const { commandEncoder, querySet } = beginTimedEncoder();
-    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, gemmPipeline, gemmBindGroup, gemmWgCount, gemmDesc);
+    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 / 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.d.mts

@@ -2,7 +2,7 @@ import { GpuVector } from "../classes/GpuVector.mjs";
 import { GpuMatrix } from "../classes/GpuMatrix.mjs";
 
 /**
- * Performs the symmetric matrix-vector operation y = alpha * A * x + beta * y
+ * Performs the symmetric matrix-vector operation $$y \leftarrow \alpha A x + \beta y$$
  *
  * A is an n×n symmetric matrix stored in row-major order. Only the triangle
  * specified by `uplo` is referenced; the other triangle is inferred by symmetry.
@@ -45,7 +45,7 @@ export declare function ssymv(
 ): Promise<{ y: Float32Array; gpuTimeMs?: number }>;
 
 /**
- * Performs the symmetric matrix-vector operation y = alpha * A * x + beta * y
+ * Performs the symmetric matrix-vector operation $$y \leftarrow \alpha A x + \beta y$$
  *
  * x and y are kept resident on the GPU. A must be a GpuMatrix; its own
  * `layout` (set at `GpuMatrix.from` time) determines the operation — there is