wgblas 2.1.0 → 2.2.0

package/src/shaders/f64add.wgsl

@@ -1,281 +0,0 @@
-// 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);
-}