wgblas 1.2.1 → 2.1.0

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.d.mts

@@ -0,0 +1,103 @@
+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
+ * its `uplo` triangle stored; `B` and `C` are general m×n matrices.
+ *
+ * - `side='left'`:  `A` is m×m — `A` premultiplies `B`
+ * - `side='right'`: `A` is n×n — `A` postmultiplies `B`
+ *
+ * No dedicated fused kernel — a `symmetrize` pass materializes a dense
+ * copy of `A` (mirroring the unstored triangle), then a plain `sgemm`
+ * pass (`sgemm_small.wgsl`/`sgemm_large.wgsl`, unmodified) does the
+ * actual multiply, both on one command encoder.
+ *
+ * {@includeCode ../../examples/ssymm/ssymm.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/ssymm/web/ssymm.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param side   - `'left'` for A*B, `'right'` for B*A
+ * @param uplo   - `'lower'` if only `A`'s lower triangle is stored, `'upper'` for upper
+ * @param m      - rows of B and C
+ * @param n      - columns of B and C
+ * @param alpha  - scalar multiplier for the matrix product
+ * @param A      - Float32Array, symmetric, row-major or column-major (see `layout`)
+ * @param lda    - leading dimension of A as stored
+ * @param B      - Float32Array, row-major or column-major (see `layout`)
+ * @param ldb    - leading dimension of B as stored
+ * @param beta   - scalar multiplier for C
+ * @param C      - Float32Array input/output matrix, row-major or column-major
+ * @param ldc    - leading dimension of C as stored
+ * @param layout - storage layout shared by A/B/C when they're Float32Array
+ *   (default: `'row-major'`) — column-major A keeps representing the same
+ *   symmetric matrix but flips which physical triangle looks stored, so
+ *   `uplo` is adjusted internally to compensate
+ * @returns updated C as a Float32Array
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/ssymm/ssymm.mjs#L23">Source code: ssymm.mjs (L23)</a>
+ * @category BLAS Level 3
+ */
+export declare function ssymm(
+  device: GPUDevice,
+  side: 'left' | 'right',
+  uplo: 'lower' | 'upper',
+  m: number,
+  n: number,
+  alpha: number,
+  A: Float32Array,
+  lda: number,
+  B: Float32Array,
+  ldb: number,
+  beta: number,
+  C: Float32Array,
+  ldc: number,
+  layout?: 'row-major' | 'column-major',
+): Promise<{ C: Float32Array; gpuTimeMs?: number }>;
+
+/**
+ * Performs the symmetric matrix-matrix operation
+ * C := alpha * A * B + beta * C (`side='left'`) or
+ * C := alpha * B * A + beta * C (`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
+ * `layout` argument here. A and B must be GpuMatrix whenever C is, and vice
+ * versa — mixing a GpuMatrix with a plain Float32Array is not supported.
+ *
+ * {@includeCode ../../examples/ssymm/gpu.ssymm.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param side   - `'left'` for A*B, `'right'` for B*A
+ * @param uplo   - `'lower'` if only `A`'s lower triangle is stored, `'upper'` for upper
+ * @param m      - rows of B and C
+ * @param n      - columns of B and C
+ * @param alpha  - scalar multiplier for the matrix product
+ * @param A      - GpuMatrix, symmetric
+ * @param lda    - leading dimension of A (must equal A.lda)
+ * @param B      - GpuMatrix
+ * @param ldb    - leading dimension of B (must equal B.lda)
+ * @param beta   - scalar multiplier for C
+ * @param C      - GpuMatrix (mutated in place)
+ * @param ldc    - leading dimension of C (must equal C.lda)
+ * @returns no C — it stays GPU-resident; call `C.read()` yourself for a CPU readback (see the example)
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/ssymm/ssymm.mjs#L23">Source code: ssymm.mjs (L23)</a>
+ * @category BLAS Level 3
+ */
+export declare function ssymm(
+  device: GPUDevice,
+  side: 'left' | 'right',
+  uplo: 'lower' | 'upper',
+  m: number,
+  n: number,
+  alpha: number,
+  A: GpuMatrix,
+  lda: number,
+  B: GpuMatrix,
+  ldb: number,
+  beta: number,
+  C: GpuMatrix,
+  ldc: number,
+): Promise<{ gpuTimeMs?: number }>;

package/src/ssymm/ssymm.mjs

@@ -0,0 +1,218 @@
+import {
+  uploadBuffer,
+  createParamsBuffer,
+  createStorageBuffer,
+  stageReadback,
+  destroyBuffers,
+  vec4ViewBinding,
+} from "../util/buffer.mjs";
+import { createBindGroup } from "../util/bindgroup.mjs";
+import { beginTimedEncoder, encodePass, submit } from "../util/compute.mjs";
+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";
+
+
+// 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",
+) {
+  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.");
+  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 (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 (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)
+  )
+    throw new Error("m, n, lda, ldb, and ldc must be integers.");
+  if (!AIsGpu && !(A instanceof Float32Array))
+    throw new Error("A must be a Float32Array or GpuMatrix.");
+  if (!BIsGpu && !(B instanceof Float32Array))
+    throw new Error("B must be a Float32Array or GpuMatrix.");
+  if (!CIsGpu && !(C instanceof Float32Array))
+    throw new Error("C must be a Float32Array or GpuMatrix.");
+  if ((AIsGpu || BIsGpu) && !CIsGpu)
+    throw new Error("C must be a GpuMatrix when A or B is a GpuMatrix.");
+  if (CIsGpu && (!AIsGpu || !BIsGpu))
+    throw new Error("A and B must be GpuMatrix when C is a GpuMatrix.");
+  if (m < 0 || n < 0) throw new Error("m and n must be non-negative.");
+  if (m === 0 || n === 0) return CIsGpu ? {} : { C };
+
+  const effLayoutA = AIsGpu ? A.layout : layout;
+  const effLayoutB = BIsGpu ? B.layout : layout;
+  const effLayoutC = CIsGpu ? C.layout : layout;
+
+  // 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 (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.");
+  } else if (A.length < (aOrder - 1) * lda + aOrder) {
+    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.`);
+  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.");
+  } else if (B.length < (bOuter - 1) * ldb + bInner) {
+    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.`);
+  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.");
+  } else if (C.length < (cOuter - 1) * ldc + cInner) {
+    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 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;
+  const kg = aOrder;
+  let transX = side === "left" ? transDense : transB;
+  let transY = side === "left" ? transB : transDense;
+  const flip = (t) => (t === "no-transpose" ? "transpose" : "no-transpose");
+  let swapXY = side === "right"; // which JS buffer plays "X" vs "Y" below
+  if (effLayoutC === "column-major") {
+    [transX, transY] = [flip(transY), flip(transX)];
+    swapXY = !swapXY;
+    [mg, ng] = [ng, mg];
+  }
+
+  const ldDense = aOrder; // Adense is tightly packed, row-major
+  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 symPipeline = await getPipeline(device, "symmetrize");
+  const gemmWgCount = useLargeTile
+    ? {
+      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"),
+    };
+
+  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" },
+        { value: ldDense, type: "u32" },
+        { value: uploEffA === "upper" ? 1 : 0, type: "u32" },
+      ],
+      "ssymm-sym-params",
+    );
+    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;
+    const ldX = swapXY ? ldb : ldDense;
+    const YBuffer = swapXY ? AdenseBuffer : BBuffer;
+    const ldY = swapXY ? ldDense : ldb;
+
+    gemmParams = createParamsBuffer(device,
+      [
+        { value: mg,  type: "u32" },
+        { value: ng,  type: "u32" },
+        { value: kg,  type: "u32" },
+        { value: alpha, type: "f32" },
+        { value: beta,  type: "f32" },
+        { value: ldX, type: "u32" },
+        { value: ldY, type: "u32" },
+        { value: ldc, type: "u32" },
+        { value: transX === "transpose" ? 1 : 0, type: "u32" },
+        { value: transY === "transpose" ? 1 : 0, type: "u32" },
+      ],
+      "ssymm-gemm-params",
+    );
+    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 ts = resolveTimestamp(device, commandEncoder, querySet);
+    const readBuffer = CIsGpu ? null : stageReadback(device, commandEncoder, CBuffer);
+
+    submit(device, commandEncoder);
+
+    const gpuTimeMs = await extractTimestamp(ts);
+
+    if (CIsGpu) {
+      if (gpuTimeMs !== undefined) return { gpuTimeMs };
+      return {};
+    }
+
+    const result = await extractResult(readBuffer, Float32Array);
+    if (gpuTimeMs !== undefined) return { C: result, gpuTimeMs };
+    return { C: result };
+  } finally {
+    if (!AIsGpu) destroyBuffers(ABuffer);
+    if (!BIsGpu) destroyBuffers(BBuffer);
+    if (!CIsGpu) destroyBuffers(CBuffer);
+    destroyBuffers(AdenseBuffer);
+    if (symParams) destroyBuffers(symParams);
+    if (gemmParams) destroyBuffers(gemmParams);
+  }
+}

package/src/ssymv/ssymv.d.mts

@@ -44,41 +44,6 @@ export declare function ssymv(
   layout?: 'row-major' | 'column-major',
 ): Promise<{ y: Float32Array; gpuTimeMs?: number }>;
 
-/**
- * Performs the symmetric matrix-vector operation y = alpha * A * x + beta * y
- *
- * A is kept GPU-resident; x and y are CPU Float32Arrays. `A`'s own `layout`
- * (set at `GpuMatrix.from` time) determines the operation — there is no
- * separate `layout` argument here.
- *
- * @param device - GPUDevice from `init()`
- * @param uplo   - `'lower'` to use the lower triangle, `'upper'` to use the upper triangle
- * @param n      - order of the matrix A
- * @param alpha  - scalar multiplier for A*x
- * @param A      - GpuMatrix, GPU-resident
- * @param lda    - leading dimension of A (must equal A.lda)
- * @param x      - Float32Array input vector
- * @param incx   - stride for x (must be a positive integer)
- * @param beta   - scalar multiplier for y
- * @param y      - Float32Array input/output vector
- * @param incy   - stride for y (must be a positive integer)
- * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/ssymv/ssymv.mjs#L15">Source code: ssymv.mjs (L15)</a>
- * @category BLAS Level 2
- */
-export declare function ssymv(
-  device: GPUDevice,
-  uplo: 'lower' | 'upper',
-  n: number,
-  alpha: number,
-  A: GpuMatrix,
-  lda: number,
-  x: Float32Array,
-  incx: number,
-  beta: number,
-  y: Float32Array,
-  incy: number,
-): Promise<{ y: Float32Array; gpuTimeMs?: number }>;
-
 /**
  * Performs the symmetric matrix-vector operation y = alpha * A * x + beta * y
  *
@@ -86,7 +51,7 @@ export declare function ssymv(
  * `layout` (set at `GpuMatrix.from` time) determines the operation — there is
  * no separate `layout` argument here.
  *
- * {@includeCode ../../examples/ssymv/gpuvec.ssymv.js}
+ * {@includeCode ../../examples/ssymv/gpu.ssymv.js}
  *
  * @param device - GPUDevice from `init()`
  * @param uplo   - `'lower'` to use the lower triangle, `'upper'` to use the upper triangle

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")
@@ -53,6 +55,8 @@ export async function ssymv(device, uplo, n, alpha, A, lda, x, incx, beta, y, in
     );
   if (xIsGpu && !AIsGpu)
     throw new Error("A must be a GpuMatrix when x and y are GpuVectors.");
+  if (AIsGpu && !xIsGpu)
+    throw new Error("x and y must be GpuVectors when A is a GpuMatrix.");
   if (xIsGpu && x._buf === y._buf)
     throw new Error("x and y must not reference the same GPU buffer when both are GpuVectors.");
   if (AIsGpu && lda !== A.lda)
@@ -87,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" },
@@ -103,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,
@@ -111,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);
 

package/src/ssyr/ssyr.d.mts

@@ -39,35 +39,6 @@ export declare function ssyr(
   layout?: 'row-major' | 'column-major',
 ): Promise<{ A: Float32Array; gpuTimeMs?: number }>;
 
-/**
- * Performs the symmetric rank-1 update A = alpha * x * x^T + A
- *
- * A is kept GPU-resident; x is a CPU Float32Array. `A`'s own `layout` (set at
- * `GpuMatrix.from` time) determines the operation — there is no separate
- * `layout` argument here.
- *
- * @param device - GPUDevice from `init()`
- * @param uplo   - `'lower'` to use the lower triangle, `'upper'` to use the upper triangle
- * @param n      - order of the matrix A
- * @param alpha  - scalar multiplier for x*x^T
- * @param x      - Float32Array input vector
- * @param incx   - stride for x (must be a positive integer)
- * @param A      - GpuMatrix, GPU-resident
- * @param lda    - leading dimension of A (must equal A.lda)
- * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/ssyr/ssyr.mjs#L15">Source code: ssyr.mjs (L15)</a>
- * @category BLAS Level 2
- */
-export declare function ssyr(
-  device: GPUDevice,
-  uplo: 'lower' | 'upper',
-  n: number,
-  alpha: number,
-  x: Float32Array,
-  incx: number,
-  A: GpuMatrix,
-  lda: number,
-): Promise<{ gpuTimeMs?: number }>;
-
 /**
  * Performs the symmetric rank-1 update A = alpha * x * x^T + A
  *
@@ -75,7 +46,7 @@ export declare function ssyr(
  * `GpuMatrix.from` time) determines the operation — there is no separate
  * `layout` argument here.
  *
- * {@includeCode ../../examples/ssyr/gpuvec.ssyr.js}
+ * {@includeCode ../../examples/ssyr/gpu.ssyr.js}
  *
  * @param device - GPUDevice from `init()`
  * @param uplo   - `'lower'` to use the lower triangle, `'upper'` to use the upper triangle

package/src/ssyr/ssyr.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 ssyr(device, uplo, n, alpha, x, incx, A, lda, layout = "row-major") {
   const xIsGpu = x instanceof GpuVector;
@@ -18,6 +19,7 @@ export async function ssyr(device, uplo, n, alpha, x, incx, A, lda, layout = "ro
 
   if (!(device instanceof GPUDevice))
     throw new Error("device must be a GPUDevice.");
+  requireSameDevice(device, "ssyr", { A, x });
   if (uplo !== "lower" && uplo !== "upper")
     throw new Error("uplo must be 'lower' or 'upper'.");
   if (layout !== "row-major" && layout !== "column-major")
@@ -36,6 +38,8 @@ export async function ssyr(device, uplo, n, alpha, x, incx, A, lda, layout = "ro
     throw new Error("x must be a Float32Array or GpuVector.");
   if (xIsGpu && !AIsGpu)
     throw new Error("A must be a GpuMatrix when x is a GpuVector.");
+  if (AIsGpu && !xIsGpu)
+    throw new Error("x must be a GpuVector when A is a GpuMatrix.");
   if (AIsGpu && xIsGpu && A._buf === x._buf)
     throw new Error("A and x must not reference the same GPU buffer.");
   if (AIsGpu && lda !== A.lda)
@@ -61,9 +65,9 @@ export async function ssyr(device, uplo, n, alpha, x, incx, A, lda, layout = "ro
   let paramsBuffer = null;
 
   try {
-    xBuffer = xIsGpu ? x._buf : uploadBuffer(x, "ssyr-x", false);
-    ABuffer = AIsGpu ? A._buf : uploadBuffer(A, "ssyr-A", true);
-    paramsBuffer = createParamsBuffer(
+    xBuffer = xIsGpu ? x._buf : uploadBuffer(device, x, "ssyr-x", false);
+    ABuffer = AIsGpu ? A._buf : uploadBuffer(device, A, "ssyr-A", true);
+    paramsBuffer = createParamsBuffer(device,
       [
         { value: n,               type: "u32" },
         { value: alpha,           type: "f32" },
@@ -74,7 +78,7 @@ export async function ssyr(device, uplo, n, alpha, x, incx, A, lda, layout = "ro
       "ssyr-params",
     );
 
-    const bindGroup = createBindGroup(pipeline.getBindGroupLayout(0), [
+    const bindGroup = createBindGroup(device, pipeline.getBindGroupLayout(0), [
       xBuffer,
       ABuffer,
       paramsBuffer,
@@ -83,10 +87,10 @@ export async function ssyr(device, uplo, n, alpha, x, incx, A, lda, layout = "ro
     // One workgroup per row of A; clamped to device limit — the shader's
     // grid-stride loop handles remaining rows when n > dispatch count.
     const wgCount = Math.min(n, device.limits.maxComputeWorkgroupsPerDimension);
-    const { commandEncoder, ts } = runComputePass(pipeline, bindGroup, wgCount);
-    const readBuffer = AIsGpu ? null : stageReadback(commandEncoder, ABuffer);
+    const { commandEncoder, ts } = runComputePass(device, pipeline, bindGroup, wgCount);
+    const readBuffer = AIsGpu ? null : stageReadback(device, commandEncoder, ABuffer);
 
-    submit(commandEncoder);
+    submit(device, commandEncoder);
 
     const gpuTimeMs = await extractTimestamp(ts);
 

package/src/ssyr2/ssyr2.d.mts

@@ -43,39 +43,6 @@ export declare function ssyr2(
   layout?: 'row-major' | 'column-major',
 ): Promise<{ A: Float32Array; gpuTimeMs?: number }>;
 
-/**
- * Performs the symmetric rank-2 update A = alpha * x * y^T + alpha * y * x^T + A
- *
- * A is kept GPU-resident; x and y are CPU Float32Arrays. `A`'s own `layout`
- * (set at `GpuMatrix.from` time) determines the operation — there is no
- * separate `layout` argument here.
- *
- * @param device - GPUDevice from `init()`
- * @param uplo   - `'lower'` to use the lower triangle, `'upper'` to use the upper triangle
- * @param n      - order of the matrix A
- * @param alpha  - scalar multiplier for x*y^T + y*x^T
- * @param x      - Float32Array input vector
- * @param incx   - stride for x (must be a positive integer)
- * @param y      - Float32Array input vector
- * @param incy   - stride for y (must be a positive integer)
- * @param A      - GpuMatrix, row-major, GPU-resident, Float32-backed
- * @param lda    - leading dimension of A (must equal A.lda)
- * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/ssyr2/ssyr2.mjs#L15">Source code: ssyr2.mjs (L15)</a>
- * @category BLAS Level 2
- */
-export declare function ssyr2(
-  device: GPUDevice,
-  uplo: 'lower' | 'upper',
-  n: number,
-  alpha: number,
-  x: Float32Array,
-  incx: number,
-  y: Float32Array,
-  incy: number,
-  A: GpuMatrix,
-  lda: number,
-): Promise<{ gpuTimeMs?: number }>;
-
 /**
  * Performs the symmetric rank-2 update A = alpha * x * y^T + alpha * y * x^T + A
  *
@@ -83,7 +50,7 @@ export declare function ssyr2(
  * `GpuMatrix.from` time) determines the operation — there is no separate
  * `layout` argument here.
  *
- * {@includeCode ../../examples/ssyr2/gpuvec.ssyr2.js}
+ * {@includeCode ../../examples/ssyr2/gpu.ssyr2.js}
  *
  * @param device - GPUDevice from `init()`
  * @param uplo   - `'lower'` to use the lower triangle, `'upper'` to use the upper triangle