wgblas 2.1.0 → 2.2.1

package/src/srot/srot.mjs

@@ -11,14 +11,13 @@ 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";
+import { requireGpuDevice, requireSameDevice } from "../util/device.mjs";
 
 export async function srot(device, n, x, incx, y, incy, c, s) {
   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, "srot", { x, y });
   if (
     !Number.isInteger(n) ||
@@ -28,7 +27,8 @@ export async function srot(device, n, x, incx, y, incy, c, s) {
     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.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)
@@ -62,7 +62,8 @@ export async function srot(device, n, x, incx, y, incy, c, s) {
   try {
     xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "srot-x", true);
     yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "srot-y", true);
-    paramsBuffer = createParamsBuffer(device,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
         { value: n, type: "u32" },
         { value: c, type: "f32" },
@@ -78,7 +79,8 @@ export async function srot(device, n, x, incx, y, incy, c, s) {
       yBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(device,
+    const { commandEncoder, ts } = runComputePass(
+      device,
       pipeline,
       bindGroup,
       calcWorkgroups(device, n),
@@ -89,7 +91,8 @@ export async function srot(device, n, x, incx, y, incy, c, s) {
 
     const gpuTimeMs = await extractTimestamp(ts);
 
-    if (xIsGpu && yIsGpu) {
+    if (xIsGpu) {
+      // xIsGpu === yIsGpu, enforced above
       if (gpuTimeMs !== undefined) return { gpuTimeMs };
       return {};
     }

package/src/srotm/srotm.mjs

@@ -11,14 +11,13 @@ 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";
+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) ||
@@ -28,12 +27,7 @@ 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
-  )
+  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.");
@@ -68,7 +62,8 @@ export async function srotm(device, n, x, incx, y, incy, param) {
     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,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -83,7 +78,8 @@ export async function srotm(device, n, x, incx, y, incy, param) {
       paramBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(device,
+    const { commandEncoder, ts } = runComputePass(
+      device,
       pipeline,
       bindGroup,
       calcWorkgroups(device, n),
@@ -94,7 +90,8 @@ export async function srotm(device, n, x, incx, y, incy, param) {
 
     const gpuTimeMs = await extractTimestamp(ts);
 
-    if (xIsGpu && yIsGpu) {
+    if (xIsGpu) {
+      // xIsGpu === yIsGpu, enforced above
       if (gpuTimeMs !== undefined) return { gpuTimeMs };
       return {};
     }

package/src/sscal/sscal.mjs

@@ -11,18 +11,16 @@ 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";
+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.");
@@ -42,7 +40,8 @@ export async function sscal(device, n, alpha, x, incx) {
 
   try {
     xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "sscal-x", true);
-    paramsBuffer = createParamsBuffer(device,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
         { value: n, type: "u32" },
         { value: alpha, type: "f32" },
@@ -55,7 +54,8 @@ export async function sscal(device, n, alpha, x, incx) {
       xBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(device,
+    const { commandEncoder, ts } = runComputePass(
+      device,
       pipeline,
       bindGroup,
       calcWorkgroups(device, n),

package/src/sswap/sswap.mjs

@@ -11,14 +11,13 @@ 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";
+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) ||
@@ -57,7 +56,8 @@ export async function sswap(device, n, x, incx, y, incy) {
   try {
     xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "sswap-x", true);
     yBuffer = yIsGpu ? y._buf : uploadBuffer(device, y, "sswap-y", true);
-    paramsBuffer = createParamsBuffer(device,
+    paramsBuffer = createParamsBuffer(
+      device,
       [
         { value: n, type: "u32" },
         { value: incx, type: "u32" },
@@ -71,19 +71,25 @@ export async function sswap(device, n, x, incx, y, incy) {
       yBuffer,
       paramsBuffer,
     ]);
-    const { commandEncoder, ts } = runComputePass(device,
+    const { commandEncoder, ts } = runComputePass(
+      device,
       pipeline,
       bindGroup,
       calcWorkgroups(device, n),
     );
-    xReadBuffer = xIsGpu ? null : stageReadback(device, commandEncoder, xBuffer);
-    yReadBuffer = yIsGpu ? null : stageReadback(device, commandEncoder, yBuffer);
+    xReadBuffer = xIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, xBuffer);
+    yReadBuffer = yIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, yBuffer);
 
     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

@@ -13,23 +13,40 @@ 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 {
+  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";
-
+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'.");
@@ -37,17 +54,18 @@ export async function ssymm(
     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))
@@ -69,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;
@@ -126,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: requireWorkgroupCount(device, largeWgX, "ssymm", "x"),
-      y: requireWorkgroupCount(device, largeWgY, "ssymm", "y"),
-    }
+        x: requireWorkgroupCount(device, largeWgX, "ssymm", "x"),
+        y: requireWorkgroupCount(device, largeWgY, "ssymm", "y"),
+      }
     : {
-      x: requireWorkgroupCount(device, Math.ceil(ng / BN_SMALL), "ssymm", "x"),
-      y: requireWorkgroupCount(device, Math.ceil(mg / BM_SMALL), "ssymm", "y"),
-    };
+        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(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;
+  const AdenseBuffer = createStorageBuffer(
+    device,
+    aOrder * ldDense * 4,
+    "ssymm-Adense",
+  );
+  let symParams = null,
+    gemmParams = null;
 
   try {
-    symParams = createParamsBuffer(device,
+    symParams = createParamsBuffer(
+      device,
       [
         { value: aOrder, type: "u32" },
         { value: lda, type: "u32" },
@@ -154,7 +214,11 @@ export async function ssymm(
       ],
       "ssymm-sym-params",
     );
-    const symBindGroup = createBindGroup(device, 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;
@@ -162,13 +226,14 @@ export async function ssymm(
     const YBuffer = swapXY ? AdenseBuffer : BBuffer;
     const ldY = swapXY ? ldDense : ldb;
 
-    gemmParams = createParamsBuffer(device,
+    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" },
@@ -177,23 +242,45 @@ export async function ssymm(
       ],
       "ssymm-gemm-params",
     );
-    const gemmBindGroup = createBindGroup(device, gemmPipeline.getBindGroupLayout(0), [
-      XBuffer,
-      vec4ViewBinding(device, XBuffer),
-      YBuffer,
-      vec4ViewBinding(device, YBuffer),
-      CBuffer,
-      gemmParams,
-    ]);
+    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 / TILE_WG_2D), y: Math.ceil(aOrder / TILE_WG_2D) }, symDesc);
-    encodePass(commandEncoder, gemmPipeline, gemmBindGroup, gemmWgCount, gemmDesc);
+    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(device, commandEncoder, querySet);
-    const readBuffer = CIsGpu ? null : stageReadback(device, commandEncoder, CBuffer);
+    const readBuffer = CIsGpu
+      ? null
+      : stageReadback(device, commandEncoder, CBuffer);
 
     submit(device, commandEncoder);
 

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