wgblas 0.1.2 → 1.1.0

package/src/shaders/f64add.wgsl

@@ -0,0 +1,281 @@
+// f64add: adds two doubles, each packed as a [main, aux] pair (main: f32
+// value, aux: raw u32 bits — see src/util/f64pack.mjs; decode()/encode()
+// below are the WGSL mirror of that file's packedToFields()/fieldsToPacked()),
+// producing the sum as another [main, aux] pair.
+//
+// Implements IEEE-754 binary64 addition (align, add/subtract significands,
+// normalize, round-to-nearest-even) using only u32 bitwise/integer
+// arithmetic — WGSL has no 64-bit integer type or arbitrary-precision
+// integers, so each operand's 53-bit significand is carried as a two-word
+// (hi, lo) pair, widened by 3 bits at the bottom to hold guard/round/sticky
+// information while aligning exponents.
+
+const EXP_ALL_ONES: u32 = 0x7ffu;
+const BIAS: i32 = 1023;
+const QUIET_NAN_MANTISSA_HI: u32 = 1u << 19u; // bit51 of the 52-bit mantissa -> canonical quiet NaN
+
+struct Fields {
+  sign: u32,
+  rawExp: u32,
+  mantissaHi: u32, // 20 bits
+  lo: u32,         // 32 bits
+}
+
+// A packed [main, aux] result — aux stays a raw u32; it must never be stored
+// as an array<f32>/treated as a real float (bit pattern can land on a NaN/
+// Infinity exponent for perfectly ordinary doubles — an f32-typed storage
+// slot canonicalizes/corrupts that on any round-trip). See f64pack.mjs's
+// comment above fieldsToPacked, and dasum.wgsl's xAux/partialsAux bindings.
+struct Packed {
+  main: f32,
+  aux:  u32,
+}
+
+// Mirrors packedToFields() in f64pack.mjs.
+fn decode(mainBits: u32, auxBits: u32) -> Fields {
+  let sign = mainBits >> 31u;
+  let expMain = (mainBits >> 23u) & 0xffu;
+  let mantMain = mainBits & 0x7fffffu;
+
+  let auxSign = auxBits >> 31u;
+  let auxExp8 = (auxBits >> 23u) & 0xffu;
+  let auxMant23 = auxBits & 0x7fffffu;
+
+  let expExtra = (auxSign << 2u) | (auxExp8 >> 6u);
+  let mantExtra29 = ((auxExp8 & 0x3fu) << 23u) | auxMant23;
+
+  let rawExp = (expMain << 3u) | expExtra;
+  let mantissaHi = mantMain >> 3u;
+  let mantTop3 = mantMain & 0x7u;
+  let lo = (mantTop3 << 29u) | mantExtra29;
+
+  return Fields(sign, rawExp, mantissaHi, lo);
+}
+
+// Mirrors fieldsToPacked() in f64pack.mjs.
+fn encode(sign: u32, rawExp: u32, mantissaHi: u32, lo: u32) -> Packed {
+  let expMain = rawExp >> 3u;
+  let expExtra = rawExp & 0x7u;
+
+  let mantTop3 = lo >> 29u;
+  let mantMain = (mantissaHi << 3u) | mantTop3;
+  let mantExtra29 = lo & 0x1fffffffu;
+
+  let mainBits = (sign << 31u) | (expMain << 23u) | mantMain;
+
+  let auxSign = (expExtra >> 2u) & 0x1u;
+  let auxExpTop2 = expExtra & 0x3u;
+  let auxExpBot6 = mantExtra29 >> 23u;
+  let auxMant23 = mantExtra29 & 0x7fffffu;
+  let auxExp8 = (auxExpTop2 << 6u) | auxExpBot6;
+
+  let auxBits = (auxSign << 31u) | (auxExp8 << 23u) | auxMant23;
+
+  return Packed(bitcast<f32>(mainBits), auxBits);
+}
+
+struct Pair { hi: u32, lo: u32 }
+struct Shifted { hi: u32, lo: u32, sticky: u32 }
+
+// Two-word right shift by 0..64+ bits, folding every shifted-out 1 bit into
+// a returned sticky flag — used only for the (potentially huge) exponent
+// alignment shift, where exact bits can't all be kept.
+fn shr_sticky(hi: u32, lo: u32, n: u32) -> Shifted {
+  if (n == 0u) {
+    return Shifted(hi, lo, 0u);
+  }
+  if (n >= 64u) {
+    return Shifted(0u, 0u, select(0u, 1u, hi != 0u || lo != 0u));
+  }
+  if (n < 32u) {
+    let stickyBits = lo & ((1u << n) - 1u);
+    let newLo = (lo >> n) | (hi << (32u - n));
+    let newHi = hi >> n;
+    return Shifted(newHi, newLo, select(0u, 1u, stickyBits != 0u));
+  }
+  if (n == 32u) {
+    return Shifted(0u, hi, select(0u, 1u, lo != 0u));
+  }
+  let m = n - 32u;
+  let stickyBits = lo | (hi & ((1u << m) - 1u));
+  let newLo = hi >> m;
+  return Shifted(0u, newLo, select(0u, 1u, stickyBits != 0u));
+}
+
+// Two-word left shift by 0..63 bits — used only to renormalize after
+// cancellation, by an amount that exactly matches the leading-zero count,
+// so nothing meaningful is ever lost off the top.
+fn shl(hi: u32, lo: u32, n: u32) -> Pair {
+  if (n == 0u) {
+    return Pair(hi, lo);
+  }
+  if (n < 32u) {
+    let newHi = (hi << n) | (lo >> (32u - n));
+    let newLo = lo << n;
+    return Pair(newHi, newLo);
+  }
+  if (n == 32u) {
+    return Pair(lo, 0u);
+  }
+  let m = n - 32u;
+  return Pair(lo << m, 0u);
+}
+
+fn add64(aHi: u32, aLo: u32, bHi: u32, bLo: u32) -> Pair {
+  let sumLo = aLo + bLo;
+  let carry = select(0u, 1u, sumLo < aLo); // wrapped around -> there was a carry
+  let sumHi = aHi + bHi + carry;
+  return Pair(sumHi, sumLo);
+}
+
+// Assumes (aHi:aLo) >= (bHi:bLo) — callers guarantee this so no sign handling is needed.
+fn sub64(aHi: u32, aLo: u32, bHi: u32, bLo: u32) -> Pair {
+  let borrow = select(0u, 1u, aLo < bLo);
+  let diffLo = aLo - bLo;
+  let diffHi = aHi - bHi - borrow;
+  return Pair(diffHi, diffLo);
+}
+
+fn ge64(aHi: u32, aLo: u32, bHi: u32, bLo: u32) -> bool {
+  return aHi > bHi || (aHi == bHi && aLo >= bLo);
+}
+
+// The actual IEEE-754 addition, returning decoded Fields rather than an
+// encoded Packed pair — lets a caller that's accumulating many values in a
+// row (e.g. dasum.wgsl's per-thread reduction loop) keep the running total
+// in Fields form the whole time, only encoding once at the very end, instead
+// of paying a decode+encode round-trip on every single addition. computeSum
+// (below) is the Packed-in/Packed-out convenience wrapper around this.
+fn addFields(a: Fields, b: Fields) -> Fields {
+  let aIsNaN = a.rawExp == EXP_ALL_ONES && (a.mantissaHi != 0u || a.lo != 0u);
+  let bIsNaN = b.rawExp == EXP_ALL_ONES && (b.mantissaHi != 0u || b.lo != 0u);
+  if (aIsNaN || bIsNaN) {
+    return Fields(0u, EXP_ALL_ONES, QUIET_NAN_MANTISSA_HI, 0u);
+  }
+
+  let aIsInf = a.rawExp == EXP_ALL_ONES; // mantissa==0 here since NaN is excluded above
+  let bIsInf = b.rawExp == EXP_ALL_ONES;
+  if (aIsInf && bIsInf) {
+    if (a.sign != b.sign) {
+      return Fields(0u, EXP_ALL_ONES, QUIET_NAN_MANTISSA_HI, 0u);
+    }
+    return Fields(a.sign, EXP_ALL_ONES, 0u, 0u);
+  }
+  if (aIsInf) { return Fields(a.sign, EXP_ALL_ONES, 0u, 0u); }
+  if (bIsInf) { return Fields(b.sign, EXP_ALL_ONES, 0u, 0u); }
+
+  let aIsZero = a.rawExp == 0u && a.mantissaHi == 0u && a.lo == 0u;
+  let bIsZero = b.rawExp == 0u && b.mantissaHi == 0u && b.lo == 0u;
+  if (aIsZero && bIsZero) {
+    return Fields(a.sign & b.sign, 0u, 0u, 0u);
+  }
+  if (aIsZero) { return Fields(b.sign, b.rawExp, b.mantissaHi, b.lo); }
+  if (bIsZero) { return Fields(a.sign, a.rawExp, a.mantissaHi, a.lo); }
+
+  // Effective (unbiased) exponent — subnormals share the smallest normal
+  // exponent for alignment purposes and have no implicit leading 1.
+  var expA = i32(a.rawExp) - BIAS;
+  if (a.rawExp == 0u) { expA = 1 - BIAS; }
+  var expB = i32(b.rawExp) - BIAS;
+  if (b.rawExp == 0u) { expB = 1 - BIAS; }
+
+  let implicitA = select(0u, 1u, a.rawExp != 0u);
+  let implicitB = select(0u, 1u, b.rawExp != 0u);
+
+  // Widen each 53-bit significand (implicit + 52-bit mantissa) by 3 zero
+  // bits at the bottom — room for guard/round/sticky once alignment shifts happen.
+  let sigHiA = (implicitA << 23u) | (a.mantissaHi << 3u) | (a.lo >> 29u);
+  let sigLoA = a.lo << 3u;
+  let sigHiB = (implicitB << 23u) | (b.mantissaHi << 3u) | (b.lo >> 29u);
+  let sigLoB = b.lo << 3u;
+
+  // P = the operand with the larger exponent (Q = the other); on a tie, P =
+  // whichever has the larger significand — keeps subtraction below always
+  // non-negative without needing signed magnitudes.
+  var signP: u32; var expP: i32; var sigHiP: u32; var sigLoP: u32;
+  var signQ: u32; var expQ: i32; var sigHiQ: u32; var sigLoQ: u32;
+  if (expA > expB || (expA == expB && ge64(sigHiA, sigLoA, sigHiB, sigLoB))) {
+    signP = a.sign; expP = expA; sigHiP = sigHiA; sigLoP = sigLoA;
+    signQ = b.sign; expQ = expB; sigHiQ = sigHiB; sigLoQ = sigLoB;
+  } else {
+    signP = b.sign; expP = expB; sigHiP = sigHiB; sigLoP = sigLoB;
+    signQ = a.sign; expQ = expA; sigHiQ = sigHiA; sigLoQ = sigLoA;
+  }
+
+  let diff = u32(expP - expQ);
+  let shiftedQ = shr_sticky(sigHiQ, sigLoQ, diff);
+  let alignedHiQ = shiftedQ.hi;
+  let alignedLoQ = shiftedQ.lo | shiftedQ.sticky; // fold sticky into bit0
+
+  var sumHi: u32; var sumLo: u32;
+  if (signP == signQ) {
+    let s = add64(sigHiP, sigLoP, alignedHiQ, alignedLoQ);
+    sumHi = s.hi; sumLo = s.lo;
+  } else {
+    let s = sub64(sigHiP, sigLoP, alignedHiQ, alignedLoQ); // P >= Q(aligned) by construction
+    sumHi = s.hi; sumLo = s.lo;
+  }
+
+  if (sumHi == 0u && sumLo == 0u) {
+    return Fields(0u, 0u, 0u, 0u); // exact cancellation -> +0
+  }
+
+  // commonExp2: per-bit scale of sumLo's bit0 in the widened representation.
+  let commonExp2 = expP - 55;
+
+  var leadPos: i32;
+  if (sumHi != 0u) {
+    leadPos = 32 + i32(31u - countLeadingZeros(sumHi));
+  } else {
+    leadPos = i32(31u - countLeadingZeros(sumLo));
+  }
+  let tentativeExp = leadPos + commonExp2;
+  var targetLSBScale = tentativeExp - 52;
+  if (tentativeExp < -1022) { targetLSBScale = -1074; }
+  let shiftAmt = targetLSBScale - commonExp2;
+
+  var keepHi: u32; var keepLo: u32;
+  if (shiftAmt <= 0) {
+    let sh = shl(sumHi, sumLo, u32(-shiftAmt)); // exact — cancellation only, never loses bits
+    keepHi = sh.hi; keepLo = sh.lo;
+  } else {
+    // Only reached without cancellation (same-sign add, or a tied-exponent
+    // subtract with no shrinkage) — shiftAmt here is always exactly 3 or 4,
+    // so the dropped bits are fully known from sumLo directly (no sticky
+    // approximation needed, unlike the Q-alignment shift above).
+    let n = u32(shiftAmt);
+    let remainder = sumLo & ((1u << n) - 1u);
+    let halfway = 1u << (n - 1u);
+    let sh = shr_sticky(sumHi, sumLo, n);
+    keepHi = sh.hi; keepLo = sh.lo;
+    if (remainder > halfway || (remainder == halfway && (keepLo & 1u) != 0u)) {
+      let inc = add64(keepHi, keepLo, 0u, 1u);
+      keepHi = inc.hi; keepLo = inc.lo;
+    }
+  }
+
+  var resultExpBase = targetLSBScale;
+  if ((keepHi & (1u << 21u)) != 0u) { // rounding carried past the 53-bit budget
+    let sh = shr_sticky(keepHi, keepLo, 1u); // dropped bit is guaranteed 0 here
+    keepHi = sh.hi; keepLo = sh.lo;
+    resultExpBase = resultExpBase + 1;
+  }
+
+  let resultSign = signP;
+  if ((keepHi & (1u << 20u)) != 0u) { // normal-shaped result
+    let unbiasedExp = 52 + resultExpBase;
+    let rawExpFinal = unbiasedExp + BIAS;
+    if (rawExpFinal >= 2047) {
+      return Fields(resultSign, EXP_ALL_ONES, 0u, 0u); // overflow -> Infinity
+    }
+    return Fields(resultSign, u32(rawExpFinal), keepHi & 0xfffffu, keepLo);
+  }
+  return Fields(resultSign, 0u, keepHi & 0xfffffu, keepLo); // subnormal result
+}
+
+// Packed-in/Packed-out convenience wrapper around addFields — encodes once,
+// after the math, rather than addFields itself needing to know about Packed.
+fn computeSum(a: Fields, b: Fields) -> Packed {
+  let f = addFields(a, b);
+  return encode(f.sign, f.rawExp, f.mantissaHi, f.lo);
+}

package/src/shaders/isamax.wgsl

@@ -25,19 +25,42 @@ fn main(
 ) {
   // -1.0 is a safe sentinel: any |x[i]| >= 0 beats it,
   // so workgroups with no elements lose gracefully in the epilogue.
-  var best_val: f32 = -1.0;
-  var best_idx: u32 = 0u;
+  var best_val0: f32 = -1.0; var best_idx0: u32 = 0u;
+  var best_val1: f32 = -1.0; var best_idx1: u32 = 0u;
+  var best_val2: f32 = -1.0; var best_idx2: u32 = 0u;
+  var best_val3: f32 = -1.0; var best_idx3: u32 = 0u;
 
-  for (var id = gid.x; id < params.n; id += num_wg.x * WGS) {
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
+    let v0 = abs(x[ id                * params.x_inc]);
+    let v1 = abs(x[(id +      stride) * params.x_inc]);
+    let v2 = abs(x[(id + 2u * stride) * params.x_inc]);
+    let v3 = abs(x[(id + 3u * stride) * params.x_inc]);
+    if (v0 > best_val0) { best_val0 = v0; best_idx0 = id; }
+    if (v1 > best_val1) { best_val1 = v1; best_idx1 = id +      stride; }
+    if (v2 > best_val2) { best_val2 = v2; best_idx2 = id + 2u * stride; }
+    if (v3 > best_val3) { best_val3 = v3; best_idx3 = id + 3u * stride; }
+  }
+  for (var id = n4_floor + gid.x; id < params.n; id += stride) {
     let v = abs(x[id * params.x_inc]);
-    if (v > best_val) {
-      best_val = v;
-      best_idx = id;
-    }
+    if (v > best_val0) { best_val0 = v; best_idx0 = id; }
+  }
+
+  // merge 4 independent lanes; prefer lower index on tie (first occurrence wins)
+  if (best_val1 > best_val0 || (best_val1 == best_val0 && best_idx1 < best_idx0)) {
+    best_val0 = best_val1; best_idx0 = best_idx1;
+  }
+  if (best_val2 > best_val0 || (best_val2 == best_val0 && best_idx2 < best_idx0)) {
+    best_val0 = best_val2; best_idx0 = best_idx2;
+  }
+  if (best_val3 > best_val0 || (best_val3 == best_val0 && best_idx3 < best_idx0)) {
+    best_val0 = best_val3; best_idx0 = best_idx3;
   }
 
-  tile_val[lid.x] = best_val;
-  tile_idx[lid.x] = best_idx;
+  tile_val[lid.x] = best_val0;
+  tile_idx[lid.x] = best_idx0;
   workgroupBarrier();
 
   for (var s = WGS / 2u; s > 0u; s >>= 1u) {

package/src/shaders/reduction/sumF64.wgsl

@@ -0,0 +1,49 @@
+// sum reduction (f64): collapses 2*WGS partial [main, aux] pairs into one,
+// using computeSum instead of plain f32 `+` (see reduction/sum.wgsl for the
+// f32 original this mirrors).
+// dispatch: 1 workgroup of WGS threads. partialsMain/partialsAux must have
+// exactly 2*WGS entries each.
+//
+// Concatenated after f64add.wgsl by getPipeline (WGSL has no #include),
+// reusing its decode/encode/computeSum and Packed struct — f64add.wgsl
+// declares no bindings and no entry point of its own (just helper functions),
+// so bindings here start at 0 and the entry point is simply `reduce_f64`.
+//
+// partialsAux/result's aux slot are array<u32>, not array<f32> — aux's bits
+// must never pass through an f32-typed storage slot (NaN-bit-pattern
+// corruption risk, see f64pack.mjs and the Packed struct comment above
+// decode()/encode() in f64add.wgsl).
+
+@group(0) @binding(0) var<storage, read>       partialsMain: array<f32>;
+@group(0) @binding(1) var<storage, read>       partialsAux:  array<u32>;
+@group(0) @binding(2) var<storage, read_write> resultMain:   array<f32, 1>;
+@group(0) @binding(3) var<storage, read_write> resultAux:    array<u32, 1>;
+
+const WGS: u32 = 64;
+
+var<workgroup> tile: array<Packed, 64>;
+
+fn addPair(a: Packed, b: Packed) -> Packed {
+  return computeSum(decode(bitcast<u32>(a.main), a.aux), decode(bitcast<u32>(b.main), b.aux));
+}
+
+@compute @workgroup_size(64)
+fn reduce_f64(
+  @builtin(local_invocation_id) lid: vec3u,
+) {
+  let i = lid.x;
+  let a = Packed(partialsMain[i], partialsAux[i]);
+  let b = Packed(partialsMain[i + WGS], partialsAux[i + WGS]);
+  tile[i] = addPair(a, b);
+  workgroupBarrier();
+
+  for (var s = WGS / 2u; s > 0u; s >>= 1u) {
+    if (i < s) { tile[i] = addPair(tile[i], tile[i + s]); }
+    workgroupBarrier();
+  }
+
+  if (i == 0u) {
+    resultMain[0] = tile[0].main;
+    resultAux[0] = tile[0].aux;
+  }
+}

package/src/shaders/sasum.wgsl

@@ -21,11 +21,25 @@ fn main(
   @builtin(workgroup_id)         wgid:   vec3u,
   @builtin(num_workgroups)       num_wg: vec3u,
 ) {
-  var acc: f32 = 0.0;
-  for (var id = gid.x; id < params.n; id += num_wg.x * WGS) {
-    acc += abs(x[id * params.x_inc]);
+  var acc0: f32 = 0.0;
+  var acc1: f32 = 0.0;
+  var acc2: f32 = 0.0;
+  var acc3: f32 = 0.0;
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
+    acc0 += abs(x[ id                * params.x_inc]);
+    acc1 += abs(x[(id +      stride) * params.x_inc]);
+    acc2 += abs(x[(id + 2u * stride) * params.x_inc]);
+    acc3 += abs(x[(id + 3u * stride) * params.x_inc]);
   }
-  tile[lid.x] = acc;
+  for (var id = n4_floor + gid.x; id < params.n; id += stride) {
+    acc0 += abs(x[id * params.x_inc]);
+  }
+
+  tile[lid.x] = acc0 + acc1 + acc2 + acc3;
   workgroupBarrier();
 
   for (var s = WGS / 2u; s > 0u; s >>= 1u) {

package/src/shaders/sdot.wgsl

@@ -23,11 +23,25 @@ fn main(
   @builtin(workgroup_id)         wgid:   vec3u,
   @builtin(num_workgroups)       num_wg: vec3u,
 ) {
-  var acc: f32 = 0.0;
-  for (var id = gid.x; id < params.n; id += num_wg.x * WGS) {
-    acc += x[id * params.x_inc] * y[id * params.y_inc];
+  var acc0: f32 = 0.0;
+  var acc1: f32 = 0.0;
+  var acc2: f32 = 0.0;
+  var acc3: f32 = 0.0;
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
+    acc0 += x[ id                * params.x_inc] * y[ id                * params.y_inc];
+    acc1 += x[(id +      stride) * params.x_inc] * y[(id +      stride) * params.y_inc];
+    acc2 += x[(id + 2u * stride) * params.x_inc] * y[(id + 2u * stride) * params.y_inc];
+    acc3 += x[(id + 3u * stride) * params.x_inc] * y[(id + 3u * stride) * params.y_inc];
   }
-  tile[lid.x] = acc;
+  for (var id = n4_floor + gid.x; id < params.n; id += stride) {
+    acc0 += x[id * params.x_inc] * y[id * params.y_inc];
+  }
+
+  tile[lid.x] = acc0 + acc1 + acc2 + acc3;
   workgroupBarrier();
 
   for (var s = WGS / 2u; s > 0u; s >>= 1u) {

package/src/shaders/sgemv_n.wgsl

@@ -0,0 +1,75 @@
+// sgemv_n: y = alpha * A * x + beta * y  (A is m×n row-major, no-transpose)
+//
+// One workgroup per output row, with a grid-stride outer loop so the shader
+// still covers all rows when m exceeds maxComputeWorkgroupsPerDimension.
+// Threads stride through A[row, :] and x with coalesced reads (consecutive
+// threads → consecutive addresses). Four independent accumulators let the GPU
+// pipeline memory requests across iterations (ILP=4), hiding the
+// global-memory latency.
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read>       x: array<f32>;
+@group(0) @binding(2) var<storage, read_write> y: array<f32>;
+
+struct Params {
+  m:     u32,
+  n:     u32,
+  alpha: f32,
+  beta:  f32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> scratch: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  // Grid-stride loop: each workgroup handles ceil(m / nwg.x) rows.
+  for (var row = wgid.x; row < params.m; row += nwg.x) {
+    let row_base = row * params.lda;
+    var acc0: f32 = 0.0;
+    var acc1: f32 = 0.0;
+    var acc2: f32 = 0.0;
+    var acc3: f32 = 0.0;
+
+    // 4-unrolled loop: each iteration issues 4 independent loads for A and x.
+    // The accumulators are independent so the GPU can overlap the memory
+    // requests rather than serialising them behind a dependency chain.
+    let n4_floor = (params.n / (4u * WGS)) * (4u * WGS);
+    for (var j: u32 = lid.x; j < n4_floor; j += 4u * WGS) {
+      acc0 += A[row_base + j            ] * x[ j             * params.incx];
+      acc1 += A[row_base + j +     WGS  ] * x[(j +     WGS)  * params.incx];
+      acc2 += A[row_base + j + 2u * WGS ] * x[(j + 2u * WGS) * params.incx];
+      acc3 += A[row_base + j + 3u * WGS ] * x[(j + 3u * WGS) * params.incx];
+    }
+    // Scalar tail: at most 3*WGS elements left after the unrolled block.
+    for (var j: u32 = n4_floor + lid.x; j < params.n; j += WGS) {
+      acc0 += A[row_base + j] * x[j * params.incx];
+    }
+
+    // Parallel reduction: 64 → 32 → 16 → 8 → 4 → 2 → 1
+    scratch[lid.x] = acc0 + acc1 + acc2 + acc3;
+    workgroupBarrier();
+    for (var stride = WGS >> 1u; stride > 0u; stride >>= 1u) {
+      if lid.x < stride {
+        scratch[lid.x] += scratch[lid.x + stride];
+      }
+      workgroupBarrier();
+    }
+
+    if lid.x == 0u {
+      let yi = row * params.incy;
+      y[yi] = params.alpha * scratch[0] + params.beta * y[yi];
+    }
+    // All 64 threads must agree before the next row reuses scratch[].
+    workgroupBarrier();
+  }
+}

package/src/shaders/sgemv_t.wgsl

@@ -0,0 +1,65 @@
+// sgemv_t: y = alpha * A^T * x + beta * y  (A is m×n row-major, transposed)
+// each thread owns one column of A → one element of y (length n)
+// tiles over x (length m) using shared memory; four independent accumulators
+// let the GPU pipeline A reads across j within each tile (ILP=4)
+
+@group(0) @binding(0) var<storage, read>       A: array<f32>;
+@group(0) @binding(1) var<storage, read>       x: array<f32>;
+@group(0) @binding(2) var<storage, read_write> y: array<f32>;
+
+struct Params {
+  m:     u32,
+  n:     u32,
+  alpha: f32,
+  beta:  f32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+var<workgroup> x_tile: array<f32, 64>;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(global_invocation_id) gid: vec3u,
+  @builtin(local_invocation_id)  lid: vec3u,
+) {
+  // each thread owns column col of A → output y[col]
+  let col     = gid.x;
+  // tile over x (length m, the rows of A)
+  let m_floor = (params.m / WGS) * WGS;
+  var acc0: f32 = 0.0;
+  var acc1: f32 = 0.0;
+  var acc2: f32 = 0.0;
+  var acc3: f32 = 0.0;
+
+  for (var base = 0u; base < m_floor; base += WGS) {
+    // cooperative load: all 64 threads fill x_tile with x[base..base+WGS]
+    x_tile[lid.x] = x[(base + lid.x) * params.incx];
+    workgroupBarrier();
+
+    // 4-unrolled inner loop: 4 independent A reads let the GPU pipeline
+    // global-memory requests within each tile. WGS=64 divides by 4 exactly.
+    if (col < params.n) {
+      for (var j = 0u; j < WGS; j += 4u) {
+        acc0 += A[(base + j    ) * params.lda + col] * x_tile[j    ];
+        acc1 += A[(base + j + 1) * params.lda + col] * x_tile[j + 1];
+        acc2 += A[(base + j + 2) * params.lda + col] * x_tile[j + 2];
+        acc3 += A[(base + j + 3) * params.lda + col] * x_tile[j + 3];
+      }
+    }
+    workgroupBarrier();
+  }
+
+  if (col < params.n) {
+    // remainder: m not divisible by WGS — short loop, single accumulator fine
+    for (var k = m_floor; k < params.m; k++) {
+      acc0 += A[k * params.lda + col] * x[k * params.incx];
+    }
+    let yi = col * params.incy;
+    y[yi] = params.alpha * (acc0 + acc1 + acc2 + acc3) + params.beta * y[yi];
+  }
+}

package/src/shaders/sger.wgsl

@@ -0,0 +1,48 @@
+// sger: A := alpha * x * y^T + A  (rank-1 update, A is m×n general/dense)
+
+@group(0) @binding(0) var<storage, read>       x: array<f32>;
+@group(0) @binding(1) var<storage, read>       y: array<f32>;
+@group(0) @binding(2) var<storage, read_write> A: array<f32>;
+
+struct Params {
+  m:     u32,
+  n:     u32,
+  alpha: f32,
+  incx:  u32,
+  incy:  u32,
+  lda:   u32,
+}
+
+@group(0) @binding(3) var<uniform> params: Params;
+
+const WGS: u32 = 64u;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3u,
+  @builtin(local_invocation_id) lid:  vec3u,
+  @builtin(num_workgroups)      nwg:  vec3u,
+) {
+  for (var row = wgid.x; row < params.m; row += nwg.x) {
+    let xi = params.alpha * x[row * params.incx];
+    let row_base = row * params.lda;
+
+    // 4-unrolled loop: each iteration issues 4 independent A/y accesses.
+    let n4_floor = (params.n / (4u * WGS)) * (4u * WGS);
+    for (var col: u32 = lid.x; col < n4_floor; col += 4u * WGS) {
+      let idx0 = row_base + col;
+      let idx1 = row_base + col + WGS;
+      let idx2 = row_base + col + 2u * WGS;
+      let idx3 = row_base + col + 3u * WGS;
+      A[idx0] = xi * y[ col            * params.incy] + A[idx0];
+      A[idx1] = xi * y[(col +     WGS) * params.incy] + A[idx1];
+      A[idx2] = xi * y[(col + 2u * WGS) * params.incy] + A[idx2];
+      A[idx3] = xi * y[(col + 3u * WGS) * params.incy] + A[idx3];
+    }
+    // Scalar tail: at most 3*WGS elements left after the unrolled block.
+    for (var col: u32 = n4_floor + lid.x; col < params.n; col += WGS) {
+      let idx = row_base + col;
+      A[idx] = xi * y[col * params.incy] + A[idx];
+    }
+  }
+}

package/src/shaders/snrm2.wgsl

@@ -21,12 +21,30 @@ fn main(
   @builtin(workgroup_id)         wgid:   vec3u,
   @builtin(num_workgroups)       num_wg: vec3u,
 ) {
-  var acc: f32 = 0.0;
-  for (var id = gid.x; id < params.n; id += num_wg.x * WGS) {
+  var acc0: f32 = 0.0;
+  var acc1: f32 = 0.0;
+  var acc2: f32 = 0.0;
+  var acc3: f32 = 0.0;
+
+  let stride   = num_wg.x * WGS;
+  let n4_floor = (params.n / (4u * stride)) * (4u * stride);
+
+  for (var id = gid.x; id < n4_floor; id += 4u * stride) {
+    let v0 = x[ id                * params.x_inc];
+    let v1 = x[(id +      stride) * params.x_inc];
+    let v2 = x[(id + 2u * stride) * params.x_inc];
+    let v3 = x[(id + 3u * stride) * params.x_inc];
+    acc0 += v0 * v0;
+    acc1 += v1 * v1;
+    acc2 += v2 * v2;
+    acc3 += v3 * v3;
+  }
+  for (var id = n4_floor + gid.x; id < params.n; id += stride) {
     let v = x[id * params.x_inc];
-    acc += v * v;
+    acc0 += v * v;
   }
-  tile[lid.x] = acc;
+
+  tile[lid.x] = acc0 + acc1 + acc2 + acc3;
   workgroupBarrier();
 
   for (var s = WGS / 2u; s > 0u; s >>= 1u) {