wgblas 1.2.0 → 2.0.0

package/src/shaders/sgemm_small.wgsl

@@ -0,0 +1,112 @@
+// sgemm_small: C = alpha * op(A) * op(B) + beta * C — small-tile half of
+// the two-tier autotuned dispatch (see sgemm.mjs and sgemm_large.wgsl).
+// BM=BN=32, BK=8, TM=TN=2 — wins over the large tile below a 6x6=36
+// workgroup grid of 64-tiles, where the large tile doesn't have enough
+// workgroups to fill the GPU. Same structure as sgemm_large.wgsl (2D
+// register-blocked, shared-memory-tiled), just smaller.
+//
+// col mapped to gid.x for coalesced B/C access (row-major: col contiguous).
+
+const BM: u32 = 32u;
+const BN: u32 = 32u;
+const BK: u32 = 8u;
+const TM: u32 = 2u;
+const TN: u32 = 2u;
+const THREADS_X: u32 = BN / TN;
+const THREADS_Y: u32 = BM / TM;
+const NUM_THREADS: u32 = THREADS_X * THREADS_Y; // 256
+const STRIDE_A: u32 = NUM_THREADS / BK;
+const STRIDE_B: u32 = NUM_THREADS / BN;
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read>       B: array<f32>;
+@group(0) @binding(2) var<storage, read_write> C: array<f32>;
+
+struct Params {
+  m:      u32,
+  n:      u32,
+  k:      u32,
+  alpha:  f32,
+  beta:   f32,
+  lda:    u32,
+  ldb:    u32,
+  ldc:    u32,
+  transA: u32, // 0 = no-transpose, 1 = transpose
+  transB: u32,
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+var<workgroup> As: array<f32, BM * BK>;
+var<workgroup> Bs: array<f32, BK * BN>;
+
+@compute @workgroup_size(THREADS_X, THREADS_Y)
+fn main(
+  @builtin(workgroup_id) wid: vec3u,
+  @builtin(local_invocation_id) lid: vec3u,
+  @builtin(local_invocation_index) tid: u32,
+) {
+  let blockRow = wid.y * BM;
+  let blockCol = wid.x * BN;
+  let threadCol = lid.x;
+  let threadRow = lid.y;
+
+  let innerRowA = tid / BK;
+  let innerColA = tid % BK;
+  let innerRowB = tid / BN;
+  let innerColB = tid % BN;
+
+  var threadResults: array<f32, TM * TN>;
+  for (var i = 0u; i < TM * TN; i++) {
+    threadResults[i] = 0.0;
+  }
+  var regM: array<f32, TM>;
+  var regN: array<f32, TN>;
+
+  let numTiles = (params.k + BK - 1u) / BK;
+  for (var t = 0u; t < numTiles; t++) {
+    for (var loadOffset = 0u; loadOffset < BM; loadOffset += STRIDE_A) {
+      let gRowA = blockRow + innerRowA + loadOffset;
+      let gColA = t * BK + innerColA;
+      let aIdx = select(gRowA * params.lda + gColA, gColA * params.lda + gRowA, params.transA != 0u);
+      As[(innerRowA + loadOffset) * BK + innerColA] = select(0.0, A[aIdx], gRowA < params.m && gColA < params.k);
+    }
+    for (var loadOffset = 0u; loadOffset < BK; loadOffset += STRIDE_B) {
+      let gRowB = t * BK + innerRowB + loadOffset;
+      let gColB = blockCol + innerColB;
+      let bIdx = select(gRowB * params.ldb + gColB, gColB * params.ldb + gRowB, params.transB != 0u);
+      Bs[(innerRowB + loadOffset) * BN + innerColB] = select(0.0, B[bIdx], gRowB < params.k && gColB < params.n);
+    }
+
+    workgroupBarrier();
+
+    for (var dotIdx = 0u; dotIdx < BK; dotIdx++) {
+      for (var i = 0u; i < TM; i++) {
+        regM[i] = As[(threadRow * TM + i) * BK + dotIdx];
+      }
+      for (var i = 0u; i < TN; i++) {
+        regN[i] = Bs[dotIdx * BN + threadCol * TN + i];
+      }
+      for (var resIdxM = 0u; resIdxM < TM; resIdxM++) {
+        for (var resIdxN = 0u; resIdxN < TN; resIdxN++) {
+          threadResults[resIdxM * TN + resIdxN] += regM[resIdxM] * regN[resIdxN];
+        }
+      }
+    }
+
+    workgroupBarrier();
+  }
+
+  for (var resIdxM = 0u; resIdxM < TM; resIdxM++) {
+    let row = blockRow + threadRow * TM + resIdxM;
+    if (row < params.m) {
+      for (var resIdxN = 0u; resIdxN < TN; resIdxN++) {
+        let col = blockCol + threadCol * TN + resIdxN;
+        if (col < params.n) {
+          let cIdx = row * params.ldc + col;
+          C[cIdx] = params.alpha * threadResults[resIdxM * TN + resIdxN] + params.beta * C[cIdx];
+        }
+      }
+    }
+  }
+}

package/src/shaders/sgemmtr_large.wgsl

@@ -0,0 +1,117 @@
+// sgemmtr_large: C := uplo(alpha * op(A) * op(B) + beta * C) — large-tile
+// half of a two-tier dispatch, identical to sgemm_large.wgsl (see that file
+// for the BM/BN/BK/TM/TN autotuning rationale) except the final output write
+// is gated to one triangle of C by `uplo`, the same convention ssyr/ssyr2
+// use (0 = lower: col <= row, 1 = upper: col >= row). Every other element of
+// C — including inside the compute loop, where the full tile is still
+// computed regardless of uplo, only the write is masked — is left untouched.
+// gemmtr's uplo(C) test is a plain row/col comparison over the full m×n
+// grid, well-defined even when m != n (not restricted to square C).
+
+const BM: u32 = 64u;
+const BN: u32 = 64u;
+const BK: u32 = 8u;
+const TM: u32 = 8u;
+const TN: u32 = 4u;
+const THREADS_X: u32 = BN / TN;
+const THREADS_Y: u32 = BM / TM;
+const NUM_THREADS: u32 = THREADS_X * THREADS_Y; // 128
+const STRIDE_A: u32 = NUM_THREADS / BK; // rows of As covered per load-loop step
+const STRIDE_B: u32 = NUM_THREADS / BN; // rows of Bs covered per load-loop step
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read>       B: array<f32>;
+@group(0) @binding(2) var<storage, read_write> C: array<f32>;
+
+struct Params {
+  m:      u32,
+  n:      u32,
+  k:      u32,
+  alpha:  f32,
+  beta:   f32,
+  lda:    u32,
+  ldb:    u32,
+  ldc:    u32,
+  transA: u32, // 0 = no-transpose, 1 = transpose
+  transB: u32,
+  uplo:   u32, // 0 = lower (col <= row), 1 = upper (col >= row)
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+var<workgroup> As: array<f32, BM * BK>;
+var<workgroup> Bs: array<f32, BK * BN>;
+
+@compute @workgroup_size(THREADS_X, THREADS_Y)
+fn main(
+  @builtin(workgroup_id) wid: vec3u,
+  @builtin(local_invocation_id) lid: vec3u,
+  @builtin(local_invocation_index) tid: u32,
+) {
+  let blockRow = wid.y * BM;
+  let blockCol = wid.x * BN;
+  let threadCol = lid.x;
+  let threadRow = lid.y;
+
+  // Load indices, independent of the compute thread shape — a loop since
+  // NUM_THREADS doesn't match the tile size 1:1 at this config.
+  let innerRowA = tid / BK;
+  let innerColA = tid % BK;
+  let innerRowB = tid / BN;
+  let innerColB = tid % BN;
+
+  var threadResults: array<f32, TM * TN>;
+  for (var i = 0u; i < TM * TN; i++) {
+    threadResults[i] = 0.0;
+  }
+  var regM: array<f32, TM>;
+  var regN: array<f32, TN>;
+
+  let numTiles = (params.k + BK - 1u) / BK;
+  for (var t = 0u; t < numTiles; t++) {
+    for (var loadOffset = 0u; loadOffset < BM; loadOffset += STRIDE_A) {
+      let gRowA = blockRow + innerRowA + loadOffset;
+      let gColA = t * BK + innerColA;
+      let aIdx = select(gRowA * params.lda + gColA, gColA * params.lda + gRowA, params.transA != 0u);
+      As[(innerRowA + loadOffset) * BK + innerColA] = select(0.0, A[aIdx], gRowA < params.m && gColA < params.k);
+    }
+    for (var loadOffset = 0u; loadOffset < BK; loadOffset += STRIDE_B) {
+      let gRowB = t * BK + innerRowB + loadOffset;
+      let gColB = blockCol + innerColB;
+      let bIdx = select(gRowB * params.ldb + gColB, gColB * params.ldb + gRowB, params.transB != 0u);
+      Bs[(innerRowB + loadOffset) * BN + innerColB] = select(0.0, B[bIdx], gRowB < params.k && gColB < params.n);
+    }
+
+    workgroupBarrier();
+
+    for (var dotIdx = 0u; dotIdx < BK; dotIdx++) {
+      for (var i = 0u; i < TM; i++) {
+        regM[i] = As[(threadRow * TM + i) * BK + dotIdx];
+      }
+      for (var i = 0u; i < TN; i++) {
+        regN[i] = Bs[dotIdx * BN + threadCol * TN + i];
+      }
+      for (var resIdxM = 0u; resIdxM < TM; resIdxM++) {
+        for (var resIdxN = 0u; resIdxN < TN; resIdxN++) {
+          threadResults[resIdxM * TN + resIdxN] += regM[resIdxM] * regN[resIdxN];
+        }
+      }
+    }
+
+    workgroupBarrier();
+  }
+
+  for (var resIdxM = 0u; resIdxM < TM; resIdxM++) {
+    let row = blockRow + threadRow * TM + resIdxM;
+    if (row < params.m) {
+      for (var resIdxN = 0u; resIdxN < TN; resIdxN++) {
+        let col = blockCol + threadCol * TN + resIdxN;
+        let inTriangle = select(col >= row, col <= row, params.uplo == 0u);
+        if (col < params.n && inTriangle) {
+          let cIdx = row * params.ldc + col;
+          C[cIdx] = params.alpha * threadResults[resIdxM * TN + resIdxN] + params.beta * C[cIdx];
+        }
+      }
+    }
+  }
+}

package/src/shaders/sgemmtr_small.wgsl

@@ -0,0 +1,110 @@
+// sgemmtr_small: C := uplo(alpha * op(A) * op(B) + beta * C) — small-tile
+// half of a two-tier dispatch, identical to sgemm_small.wgsl except the
+// final output write is gated to one triangle of C by `uplo` — see
+// sgemmtr_large.wgsl for the full rationale (shared by both tiers).
+
+const BM: u32 = 32u;
+const BN: u32 = 32u;
+const BK: u32 = 8u;
+const TM: u32 = 2u;
+const TN: u32 = 2u;
+const THREADS_X: u32 = BN / TN;
+const THREADS_Y: u32 = BM / TM;
+const NUM_THREADS: u32 = THREADS_X * THREADS_Y; // 256
+const STRIDE_A: u32 = NUM_THREADS / BK;
+const STRIDE_B: u32 = NUM_THREADS / BN;
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read>       B: array<f32>;
+@group(0) @binding(2) var<storage, read_write> C: array<f32>;
+
+struct Params {
+  m:      u32,
+  n:      u32,
+  k:      u32,
+  alpha:  f32,
+  beta:   f32,
+  lda:    u32,
+  ldb:    u32,
+  ldc:    u32,
+  transA: u32, // 0 = no-transpose, 1 = transpose
+  transB: u32,
+  uplo:   u32, // 0 = lower (col <= row), 1 = upper (col >= row)
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+var<workgroup> As: array<f32, BM * BK>;
+var<workgroup> Bs: array<f32, BK * BN>;
+
+@compute @workgroup_size(THREADS_X, THREADS_Y)
+fn main(
+  @builtin(workgroup_id) wid: vec3u,
+  @builtin(local_invocation_id) lid: vec3u,
+  @builtin(local_invocation_index) tid: u32,
+) {
+  let blockRow = wid.y * BM;
+  let blockCol = wid.x * BN;
+  let threadCol = lid.x;
+  let threadRow = lid.y;
+
+  let innerRowA = tid / BK;
+  let innerColA = tid % BK;
+  let innerRowB = tid / BN;
+  let innerColB = tid % BN;
+
+  var threadResults: array<f32, TM * TN>;
+  for (var i = 0u; i < TM * TN; i++) {
+    threadResults[i] = 0.0;
+  }
+  var regM: array<f32, TM>;
+  var regN: array<f32, TN>;
+
+  let numTiles = (params.k + BK - 1u) / BK;
+  for (var t = 0u; t < numTiles; t++) {
+    for (var loadOffset = 0u; loadOffset < BM; loadOffset += STRIDE_A) {
+      let gRowA = blockRow + innerRowA + loadOffset;
+      let gColA = t * BK + innerColA;
+      let aIdx = select(gRowA * params.lda + gColA, gColA * params.lda + gRowA, params.transA != 0u);
+      As[(innerRowA + loadOffset) * BK + innerColA] = select(0.0, A[aIdx], gRowA < params.m && gColA < params.k);
+    }
+    for (var loadOffset = 0u; loadOffset < BK; loadOffset += STRIDE_B) {
+      let gRowB = t * BK + innerRowB + loadOffset;
+      let gColB = blockCol + innerColB;
+      let bIdx = select(gRowB * params.ldb + gColB, gColB * params.ldb + gRowB, params.transB != 0u);
+      Bs[(innerRowB + loadOffset) * BN + innerColB] = select(0.0, B[bIdx], gRowB < params.k && gColB < params.n);
+    }
+
+    workgroupBarrier();
+
+    for (var dotIdx = 0u; dotIdx < BK; dotIdx++) {
+      for (var i = 0u; i < TM; i++) {
+        regM[i] = As[(threadRow * TM + i) * BK + dotIdx];
+      }
+      for (var i = 0u; i < TN; i++) {
+        regN[i] = Bs[dotIdx * BN + threadCol * TN + i];
+      }
+      for (var resIdxM = 0u; resIdxM < TM; resIdxM++) {
+        for (var resIdxN = 0u; resIdxN < TN; resIdxN++) {
+          threadResults[resIdxM * TN + resIdxN] += regM[resIdxM] * regN[resIdxN];
+        }
+      }
+    }
+
+    workgroupBarrier();
+  }
+
+  for (var resIdxM = 0u; resIdxM < TM; resIdxM++) {
+    let row = blockRow + threadRow * TM + resIdxM;
+    if (row < params.m) {
+      for (var resIdxN = 0u; resIdxN < TN; resIdxN++) {
+        let col = blockCol + threadCol * TN + resIdxN;
+        let inTriangle = select(col >= row, col <= row, params.uplo == 0u);
+        if (col < params.n && inTriangle) {
+          let cIdx = row * params.ldc + col;
+          C[cIdx] = params.alpha * threadResults[resIdxM * TN + resIdxN] + params.beta * C[cIdx];
+        }
+      }
+    }
+  }
+}

package/src/shaders/symmetrize.wgsl

@@ -0,0 +1,31 @@
+// symmetrize: Adense := full dense expansion of a symmetric matrix stored
+// with only its `uplo` triangle meaningful (the other triangle is implied
+// by symmetry: A[i,j] = A[j,i]). A plain element-wise pass, no tiling or
+// shared memory needed — used to materialize a dense operand for routines
+// that read a symmetric matrix as a normal dense gemm input (e.g. ssymm),
+// rather than teaching the tiled gemm kernel itself to mirror-read.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read_write> Adense: array<f32>;
+
+struct Params {
+  n:    u32,
+  lda:  u32,
+  ldd:  u32, // leading dimension of Adense
+  uplo: u32, // 0 = lower (stored where col <= row), 1 = upper (col >= row)
+}
+
+@group(0) @binding(2) var<uniform> params: Params;
+
+@compute @workgroup_size(8, 8)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+  let row = gid.y;
+  let col = gid.x;
+  if (row >= params.n || col >= params.n) {
+    return;
+  }
+
+  let isStored = select(col >= row, col <= row, params.uplo == 0u);
+  let srcIdx = select(col * params.lda + row, row * params.lda + col, isStored);
+  Adense[row * params.ldd + col] = A[srcIdx];
+}

package/src/shaders/triangularize.wgsl

@@ -0,0 +1,44 @@
+// triangularize: Adense := dense expansion of op(A) (A or A^T per `trans`),
+// zero-filling the unstored triangle (exact for a matmul) so strmm can reuse
+// sgemm's kernel unchanged. `diag=1` substitutes 1.0 on the diagonal.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read_write> Adense: array<f32>;
+
+struct Params {
+  n:     u32,
+  lda:   u32,
+  ldd:   u32, // leading dimension of Adense
+  uplo:  u32, // 0 = lower, 1 = upper
+  trans: u32, // 0 = no-transpose (op(A) = A), 1 = transpose (op(A) = A^T)
+  diag:  u32, // 0 = non-unit, 1 = unit
+}
+
+@group(0) @binding(2) var<uniform> params: Params;
+
+@compute @workgroup_size(8, 8)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+  let row = gid.y;
+  let col = gid.x;
+  if (row >= params.n || col >= params.n) {
+    return;
+  }
+
+  if (row == col) {
+    Adense[row * params.ldd + col] = select(A[row * params.lda + row], 1.0, params.diag == 1u);
+    return;
+  }
+
+  var isMeaningful: bool;
+  var srcRow: u32;
+  var srcCol: u32;
+  if (params.trans == 0u) {
+    isMeaningful = select(col >= row, col <= row, params.uplo == 0u);
+    srcRow = row; srcCol = col;
+  } else {
+    isMeaningful = select(col <= row, col >= row, params.uplo == 0u);
+    srcRow = col; srcCol = row;
+  }
+
+  Adense[row * params.ldd + col] = select(0.0, A[srcRow * params.lda + srcCol], isMeaningful);
+}

package/src/snrm2/snrm2.d.mts

@@ -26,7 +26,7 @@ export declare function snrm2(
 /**
  * Computes the Euclidean norm of a vector: result = sqrt(sum(x[i] * x[i]))
  *
- * {@includeCode ../../examples/snrm2/gpuvec.snrm2.js}
+ * {@includeCode ../../examples/snrm2/gpu.snrm2.js}
  *
  * @param device - GPUDevice from `init()`
  * @param n - number of elements (must be a positive integer)

package/src/srot/srot.d.mts

@@ -37,7 +37,7 @@ export declare function srot(
  *   x = c*x + s*y
  *   y = -s*x + c*y
  *
- * {@includeCode ../../examples/srot/gpuvec.srot.js}
+ * {@includeCode ../../examples/srot/gpu.srot.js}
  *
  * @param device - GPUDevice from `init()`
  * @param n - number of elements (must be a positive integer)

package/src/srotm/srotm.d.mts

@@ -36,7 +36,7 @@ export declare function srotm(
  *   x = H[0][0]*x + H[0][1]*y
  *   y = H[1][0]*x + H[1][1]*y
  *
- * {@includeCode ../../examples/srotm/gpuvec.srotm.js}
+ * {@includeCode ../../examples/srotm/gpu.srotm.js}
  *
  * @param device - GPUDevice from `init()`
  * @param n - number of elements (must be a positive integer)

package/src/sscal/sscal.d.mts

@@ -27,7 +27,7 @@ export declare function sscal(
 /**
  * Scales a single-precision vector by a constant: x = alpha * x
  *
- * {@includeCode ../../examples/sscal/gpuvec.sscal.js}
+ * {@includeCode ../../examples/sscal/gpu.sscal.js}
  *
  * @param device - GPUDevice from `init()`
  * @param n - number of elements to scale (must be a positive integer)

package/src/sswap/sswap.d.mts

@@ -29,7 +29,7 @@ export declare function sswap(
 /**
  * Swaps the elements of two single-precision vectors: x <-> y
  *
- * {@includeCode ../../examples/sswap/gpuvec.sswap.js}
+ * {@includeCode ../../examples/sswap/gpu.sswap.js}
  *
  * @param device - GPUDevice from `init()`
  * @param n - number of elements to swap (must be a positive integer)

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 }>;