wgblas 1.2.0 → 2.0.0

package/src/ssymm/ssymm.mjs

@@ -0,0 +1,209 @@
+import {
+  uploadBuffer,
+  createParamsBuffer,
+  createStorageBuffer,
+  stageReadback,
+  destroyBuffers,
+} 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";
+
+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,
+// 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.");
+  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: Math.min(largeWgX, device.limits.maxComputeWorkgroupsPerDimension),
+      y: Math.min(largeWgY, device.limits.maxComputeWorkgroupsPerDimension),
+    }
+    : {
+      x: Math.min(Math.ceil(ng / BN_SMALL), device.limits.maxComputeWorkgroupsPerDimension),
+      y: Math.min(Math.ceil(mg / BM_SMALL), device.limits.maxComputeWorkgroupsPerDimension),
+    };
+
+  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;
+
+  try {
+    symParams = createParamsBuffer(
+      [
+        { 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(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(
+      [
+        { 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(gemmPipeline.getBindGroupLayout(0), [XBuffer, 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 ts = resolveTimestamp(commandEncoder, querySet);
+    const readBuffer = CIsGpu ? null : stageReadback(commandEncoder, CBuffer);
+
+    submit(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

@@ -53,6 +53,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)

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

@@ -36,6 +36,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)

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

package/src/ssyr2/ssyr2.mjs

@@ -49,6 +49,8 @@ export async function ssyr2(device, uplo, n, alpha, x, incx, y, incy, A, lda, la
     );
   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 (AIsGpu && xIsGpu && A._buf === x._buf)
     throw new Error("A and x must not reference the same GPU buffer.");
   if (AIsGpu && yIsGpu && A._buf === y._buf)

package/src/ssyr2k/ssyr2k.d.mts

@@ -0,0 +1,100 @@
+import { GpuMatrix } from "../classes/GpuMatrix.mjs";
+
+/**
+ * Performs the symmetric rank-2k update
+ * C := uplo(alpha * op(A) * op(B)^T + alpha * op(B) * op(A)^T + beta * C) —
+ * only the triangle of C named by `uplo` is read or written (`'lower'`:
+ * `col <= row`, `'upper'`: `col >= row`). C is always n×n.
+ *
+ * - `trans='no-transpose'`: op(A) = A, op(B) = B (both n×k)
+ * - `trans='transpose'`:    op(A) = A^T, op(B) = B^T (A, B stored k×n)
+ *
+ * No dedicated kernel — two passes of `sgemmtr`'s kernel
+ * (`sgemmtr_small.wgsl`/`sgemmtr_large.wgsl`) on one command encoder, the
+ * second accumulating with `beta=1` so C never leaves the GPU between them.
+ *
+ * {@includeCode ../../examples/ssyr2k/ssyr2k.js}
+ *
+ * **Browser (standalone HTML):**
+ * {@includeCode ../../examples/ssyr2k/web/ssyr2k.html}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param uplo   - `'lower'` to update only `col <= row`, `'upper'` for `col >= row`
+ * @param trans  - `'no-transpose'` for A*B^T + B*A^T, `'transpose'` for A^T*B + B^T*A
+ * @param n      - order of C (C is n×n); rows of op(A) and op(B)
+ * @param k      - columns of op(A) and op(B) — the shared/contracted dimension
+ * @param alpha  - scalar multiplier for both rank-k terms
+ * @param A      - Float32Array, 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'`) — same handling as `sgemmtr`; column-major C
+ *   flips `uplo` internally so it still names the triangle you asked for
+ * @returns updated C as a Float32Array (only the requested triangle changed)
+ * @see <a href="https://github.com/manit2004/wgblas/blob/main/src/ssyr2k/ssyr2k.mjs#L20">Source code: ssyr2k.mjs (L20)</a>
+ * @category BLAS Level 3
+ */
+export declare function ssyr2k(
+  device: GPUDevice,
+  uplo: 'lower' | 'upper',
+  trans: 'no-transpose' | 'transpose',
+  n: number,
+  k: 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 rank-2k update
+ * C := uplo(alpha * op(A) * op(B)^T + alpha * op(B) * op(A)^T + beta * C)
+ *
+ * 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/ssyr2k/gpu.ssyr2k.js}
+ *
+ * @param device - GPUDevice from `init()`
+ * @param uplo   - `'lower'` to update only `col <= row`, `'upper'` for `col >= row`
+ * @param trans  - `'no-transpose'` for A*B^T + B*A^T, `'transpose'` for A^T*B + B^T*A
+ * @param n      - order of C (C is n×n); rows of op(A) and op(B)
+ * @param k      - columns of op(A) and op(B) — the shared/contracted dimension
+ * @param alpha  - scalar multiplier for both rank-k terms
+ * @param A      - GpuMatrix
+ * @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; only the requested triangle changes)
+ * @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/ssyr2k/ssyr2k.mjs#L20">Source code: ssyr2k.mjs (L20)</a>
+ * @category BLAS Level 3
+ */
+export declare function ssyr2k(
+  device: GPUDevice,
+  uplo: 'lower' | 'upper',
+  trans: 'no-transpose' | 'transpose',
+  n: number,
+  k: number,
+  alpha: number,
+  A: GpuMatrix,
+  lda: number,
+  B: GpuMatrix,
+  ldb: number,
+  beta: number,
+  C: GpuMatrix,
+  ldc: number,
+): Promise<{ gpuTimeMs?: number }>;