json-as 1.3.6 → 1.3.8

package/assembly/deserialize/swar/float.ts

@@ -0,0 +1,304 @@
+// SWAR float deserializers. Lemire-style fast path with parse4 SWAR digit
+// folding on the fractional accumulator. Output is bit-identical to
+// `f64.parse` / `f32.parse` (the NAIVE baseline) on the fast path because:
+//
+//   - the u64 mantissa accumulator is exact (no rounding in the digit loop),
+//   - `1e0 .. 1e22` are exactly representable in f64, and
+//   - a single fmul/fdiv on two exact operands is correctly rounded.
+//
+// Pathological inputs (>19 mantissa digits, mantissa > 2^53, or |exp| > 22)
+// fall through to `f64.parse` / `f32.parse` over the float's own range so the
+// SWAR result matches the NAIVE result for every input.
+//
+// Inspired by Daniel Lemire, "Number parsing at a gigabyte per second" (2021)
+// and the simdjson `fast_float` implementation. The integer-part loop stays
+// scalar — most JSON float payloads have 1-3 digit integer parts, so a parse4
+// stride there pays the wasted-validate cost on every call without saving
+// enough scalar iterations.
+
+import { ptrToStr } from "../../util/ptrToStr";
+import { parse4Digits_PairMul } from "../../util/swar-int";
+import { scientific } from "../../util/scientific";
+
+export const POW10_F64_POS: usize = memory.data<f64>([
+  1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14,
+  1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22,
+]);
+export const MAX_EXACT_POW10: i32 = 22;
+// 2^53. Any u64 mantissa <= this is exact in f64.
+export const MAX_EXACT_MANTISSA: u64 = 1 << 53;
+
+const ASCII_PLUS: u16 = 43;
+const ASCII_MINUS: u16 = 45;
+const ASCII_DOT: u16 = 46;
+const ASCII_ZERO: u16 = 48;
+const ASCII_E_UP: u16 = 69;
+const ASCII_E_LO: u16 = 101;
+
+// @ts-ignore: inline
+@inline export function loadPow10(exp: u32): f64 {
+  return load<f64>(POW10_F64_POS + ((<usize>exp) << 3));
+}
+
+// @ts-ignore: inline
+@inline function fallback<T>(srcStart: usize, srcEnd: usize): T {
+  const s = ptrToStr(srcStart, srcEnd);
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return <T>f64.parse(s);
+  // @ts-ignore
+  return <T>(<f32>f32.parse(s));
+}
+
+// @ts-ignore: inline
+@inline function fallbackField<T extends number>(
+  origStart: usize,
+  end: usize,
+  fieldPtr: usize,
+): void {
+  const s = ptrToStr(origStart, end);
+  if (sizeof<T>() == sizeof<f32>()) {
+    store<f32>(fieldPtr, f32.parse(s));
+  } else {
+    store<f64>(fieldPtr, f64.parse(s));
+  }
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloat_SWAR<T>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  const origStart = srcStart;
+  let p = srcStart;
+  let negative = false;
+  if (p < srcEnd && load<u16>(p) == ASCII_MINUS) {
+    negative = true;
+    p += 2;
+  }
+
+  // Integer part: scalar. Most JSON integers are 1-3 digits, so parse4 would
+  // waste a validate per call.
+  let mantissa: u64 = 0;
+  let intDigits: i32 = 0;
+  while (p < srcEnd) {
+    const d = <u32>load<u16>(p) - ASCII_ZERO;
+    if (d > 9) break;
+    mantissa = mantissa * 10 + <u64>d;
+    intDigits++;
+    p += 2;
+  }
+
+  // Fractional part: parse4 stride (8 bytes / 4 digits) → scalar tail.
+  // parse8 was tried and benchmarked even/worse; the saved mantissa mul
+  // didn't outweigh the extra load and combined-validation latency, and the
+  // dependency chain is the same length either way.
+  let fracDigits: i32 = 0;
+  if (p < srcEnd && load<u16>(p) == ASCII_DOT) {
+    p += 2;
+    while (p + 6 < srcEnd) {
+      const parsed = inline.always(parse4Digits_PairMul(load<u64>(p)));
+      if (parsed == U32.MAX_VALUE) break;
+      mantissa = mantissa * 10_000 + <u64>parsed;
+      fracDigits += 4;
+      p += 8;
+    }
+    while (p < srcEnd) {
+      const d = <u32>load<u16>(p) - ASCII_ZERO;
+      if (d > 9) break;
+      mantissa = mantissa * 10 + <u64>d;
+      fracDigits++;
+      p += 2;
+    }
+  }
+
+  const mantDigits = intDigits + fracDigits;
+  if (mantDigits == 0) return fallback<T>(origStart, srcEnd);
+
+  let exponent: i32 = -fracDigits;
+
+  // Optional `e[+-]NNN` suffix.
+  if (p < srcEnd) {
+    const c = load<u16>(p);
+    if (c == ASCII_E_LO || c == ASCII_E_UP) {
+      const expStart = p;
+      p += 2;
+      if (p >= srcEnd) return fallback<T>(origStart, expStart);
+      let expNeg = false;
+      const sc = load<u16>(p);
+      if (sc == ASCII_MINUS) {
+        expNeg = true;
+        p += 2;
+      } else if (sc == ASCII_PLUS) {
+        p += 2;
+      }
+      if (p >= srcEnd) return fallback<T>(origStart, expStart);
+      let exp: i32 = 0;
+      let expDigits: i32 = 0;
+      while (p < srcEnd) {
+        const d = <u32>load<u16>(p) - ASCII_ZERO;
+        if (d > 9) break;
+        exp = exp * 10 + <i32>d;
+        expDigits++;
+        if (expDigits > 4) return fallback<T>(origStart, srcEnd);
+        p += 2;
+      }
+      if (expDigits == 0) return fallback<T>(origStart, expStart);
+      exponent += expNeg ? -exp : exp;
+    }
+  }
+
+  // Lemire fast path when fully in range; `scientific` for u64-fitting
+  // mantissas that exceed 2^53 or |exp| > 22 (still correctly rounded, but
+  // via the scaledown/scaleup path); `f*.parse` fallback only for >19
+  // mantissa digits where the sticky-bit handling matters.
+  let result: f64;
+  if (
+    mantDigits <= 19 &&
+    mantissa <= MAX_EXACT_MANTISSA &&
+    exponent <= MAX_EXACT_POW10 &&
+    exponent >= -MAX_EXACT_POW10
+  ) {
+    result = <f64>mantissa;
+    if (exponent > 0) {
+      result *= loadPow10(<u32>exponent);
+    } else if (exponent < 0) {
+      result /= loadPow10(<u32>-exponent);
+    }
+  } else if (mantDigits <= 19) {
+    result = scientific(mantissa, exponent);
+  } else {
+    return fallback<T>(origStart, srcEnd);
+  }
+  if (negative) result = -result;
+
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return <T>result;
+  // @ts-ignore
+  return <T>(<f32>result);
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloatField_SWAR<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  const fieldPtr = dstObj + dstOffset;
+  const origStart = srcStart;
+  let p = srcStart;
+  let negative = false;
+  if (p < srcEnd && load<u16>(p) == ASCII_MINUS) {
+    negative = true;
+    p += 2;
+  }
+
+  let mantissa: u64 = 0;
+  let intDigits: i32 = 0;
+  while (p < srcEnd) {
+    const d = <u32>load<u16>(p) - ASCII_ZERO;
+    if (d > 9) break;
+    mantissa = mantissa * 10 + <u64>d;
+    intDigits++;
+    p += 2;
+  }
+
+  let fracDigits: i32 = 0;
+  if (p < srcEnd && load<u16>(p) == ASCII_DOT) {
+    p += 2;
+    while (p + 6 < srcEnd) {
+      const parsed = parse4Digits_PairMul(load<u64>(p));
+      if (parsed == U32.MAX_VALUE) break;
+      mantissa = mantissa * 10_000 + <u64>parsed;
+      fracDigits += 4;
+      p += 8;
+    }
+    while (p < srcEnd) {
+      const d = <u32>load<u16>(p) - ASCII_ZERO;
+      if (d > 9) break;
+      mantissa = mantissa * 10 + <u64>d;
+      fracDigits++;
+      p += 2;
+    }
+  }
+
+  const mantDigits = intDigits + fracDigits;
+  if (mantDigits == 0) unreachable();
+
+  let exponent: i32 = -fracDigits;
+
+  if (p < srcEnd) {
+    const c = load<u16>(p);
+    if (c == ASCII_E_LO || c == ASCII_E_UP) {
+      const expStart = p;
+      p += 2;
+      if (p >= srcEnd) {
+        fallbackField<T>(origStart, expStart, fieldPtr);
+        return expStart;
+      }
+      let expNeg = false;
+      const sc = load<u16>(p);
+      if (sc == ASCII_MINUS) {
+        expNeg = true;
+        p += 2;
+      } else if (sc == ASCII_PLUS) {
+        p += 2;
+      }
+      if (p >= srcEnd) {
+        fallbackField<T>(origStart, expStart, fieldPtr);
+        return expStart;
+      }
+      let exp: i32 = 0;
+      let expDigits: i32 = 0;
+      while (p < srcEnd) {
+        const d = <u32>load<u16>(p) - ASCII_ZERO;
+        if (d > 9) break;
+        exp = exp * 10 + <i32>d;
+        expDigits++;
+        if (expDigits > 4) {
+          fallbackField<T>(origStart, p, fieldPtr);
+          return p;
+        }
+        p += 2;
+      }
+      if (expDigits == 0) {
+        fallbackField<T>(origStart, expStart, fieldPtr);
+        return expStart;
+      }
+      exponent += expNeg ? -exp : exp;
+    }
+  }
+
+  let result: f64;
+  if (
+    mantDigits <= 19 &&
+    mantissa <= MAX_EXACT_MANTISSA &&
+    exponent <= MAX_EXACT_POW10 &&
+    exponent >= -MAX_EXACT_POW10
+  ) {
+    result = <f64>mantissa;
+    if (exponent > 0) {
+      result *= loadPow10(<u32>exponent);
+    } else if (exponent < 0) {
+      result /= loadPow10(<u32>-exponent);
+    }
+  } else if (mantDigits <= 19) {
+    result = scientific(mantissa, exponent);
+  } else {
+    fallbackField<T>(origStart, p, fieldPtr);
+    return p;
+  }
+  if (negative) result = -result;
+
+  if (sizeof<T>() == sizeof<f32>()) {
+    store<f32>(fieldPtr, <f32>result);
+  } else {
+    store<f64>(fieldPtr, result);
+  }
+
+  return p;
+}

package/assembly/deserialize/swar/integer.ts

@@ -0,0 +1,246 @@
+// SWAR integer deserializers (signed + unsigned) over UTF-16 sources.
+//
+// Consume-to-end paths use the full tiered stride hierarchy:
+//
+// - parse16 (32 bytes / 16 digits): best for long inputs
+// - parse8  (16 bytes /  8 digits)
+// - parse4  ( 8 bytes /  4 digits)
+// - scalar  ( 2 bytes /  1 digit )
+//
+// Scan paths use asymmetric tuning based on empirical h2h benches:
+//
+// - Unsigned scan: parse8 + scalar (no parse4). For unsigned inputs the
+//   digit run is aligned, so parse8 either succeeds cleanly or terminates
+//   early. The intermediate parse4 stride costs more in wasted-validate
+//   than it saves in successful work.
+// - Signed scan: parse4 + scalar (no parse8). The leading minus consumes
+//   2 bytes, shifting the digit run into parse8's "terminator-in-load"
+//   zone where validate-fail is common. parse4 is a smaller failure unit.
+//
+// parse16 is omitted from scan entirely: a 16-character digit run plus
+// terminator fits in its 32-byte load, so the terminator triggers a wasted
+// validate-fail at the boundary.
+
+import {
+  parse4Digits_PairMul,
+  parse4Digits_PairMul_Unsafe,
+  parse8Digits_PairMul,
+  parse8Digits_PairMul_Unsafe,
+  parse16Digits_SWAR,
+  parse16Digits_SWAR_Unsafe,
+} from "../../util/swar-int";
+
+const ASCII_MINUS: u16 = 45;
+const ASCII_ZERO: u16 = 48;
+
+/**
+ * Store a signed value into a typed integer field, truncating to `T`'s width.
+ *
+ * @param dstPtr Destination pointer (already includes any field offset).
+ * @param value  The `u64` accumulator, interpreted as a two's-complement
+ *               signed integer for narrower types.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline function storeSignedToField<T extends number>(
+  dstPtr: usize,
+  value: u64,
+): void {
+  if (sizeof<T>() == 1) {
+    store<i8>(dstPtr, <i8>value);
+  } else if (sizeof<T>() == 2) {
+    store<i16>(dstPtr, <i16>value);
+  } else if (sizeof<T>() == 4) {
+    store<i32>(dstPtr, <i32>value);
+  } else {
+    store<i64>(dstPtr, <i64>value);
+  }
+}
+
+/**
+ * Store an unsigned value into a typed integer field, truncating to `T`'s
+ * width.
+ *
+ * @param dstPtr Destination pointer (already includes any field offset).
+ * @param value  The `u64` accumulator.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline function storeUnsignedToField<T extends number>(
+  dstPtr: usize,
+  value: u64,
+): void {
+  if (sizeof<T>() == 1) {
+    store<u8>(dstPtr, <u8>value);
+  } else if (sizeof<T>() == 2) {
+    store<u16>(dstPtr, <u16>value);
+  } else if (sizeof<T>() == 4) {
+    store<u32>(dstPtr, <u32>value);
+  } else {
+    store<u64>(dstPtr, value);
+  }
+}
+
+/**
+ * Parse a signed integer by consuming the entire `[srcStart, srcEnd)` range
+ * as a digit run, with an optional leading `-`.
+ *
+ * Caller guarantees the range is well-formed (optional minus followed by
+ * digits only). Uses the unsafe SWAR kernels with no per-stride validation.
+ *
+ * @param srcStart Pointer to the first UTF-16 code unit.
+ * @param srcEnd   Pointer just past the last code unit.
+ * @returns The parsed value, two's-complement truncated to `T`.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function deserializeInteger_SWAR<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  let negative = false;
+  if (srcStart < srcEnd && load<u16>(srcStart) == ASCII_MINUS) {
+    negative = true;
+    srcStart += 2;
+  }
+  let value: u64 = 0;
+  while (srcStart + 30 < srcEnd) {
+    value =
+      value * 10_000_000_000_000_000 + parse16Digits_SWAR_Unsafe(srcStart);
+    srcStart += 32;
+  }
+  while (srcStart + 14 < srcEnd) {
+    value =
+      value * 100_000_000 +
+      parse8Digits_PairMul_Unsafe(load<u64>(srcStart), load<u64>(srcStart, 8));
+    srcStart += 16;
+  }
+  while (srcStart + 6 < srcEnd) {
+    value = value * 10_000 + parse4Digits_PairMul_Unsafe(load<u64>(srcStart));
+    srcStart += 8;
+  }
+  while (srcStart < srcEnd) {
+    value = value * 10 + (<u32>load<u16>(srcStart) - ASCII_ZERO);
+    srcStart += 2;
+  }
+  return <T>(negative ? 0 - value : value);
+}
+
+/**
+ * Scan for a signed integer field, stopping at the first non-digit
+ * character. Writes the parsed value through `dstObj + dstOffset` and
+ * returns the source position immediately after the last digit.
+ *
+ * Used by struct field deserializers, where the digit run is followed by
+ * a `,`, `}`, `]`, whitespace, etc.
+ *
+ * @param srcStart  Pointer to the first UTF-16 code unit.
+ * @param srcEnd    Pointer just past the last code unit.
+ * @param dstObj    Destination object pointer.
+ * @param dstOffset Byte offset of the field within `dstObj`.
+ * @returns The source position immediately after the last digit consumed.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function deserializeIntegerField_SWAR<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  let negative = false;
+  if (srcStart < srcEnd && load<u16>(srcStart) == ASCII_MINUS) {
+    negative = true;
+    srcStart += 2;
+  }
+  let value: u64 = 0;
+  // Signed scan uses parse4 + scalar only (see file header).
+  while (srcStart + 6 < srcEnd) {
+    const parsed = parse4Digits_PairMul(load<u64>(srcStart));
+    if (parsed == U32.MAX_VALUE) break;
+    value = value * 10_000 + parsed;
+    srcStart += 8;
+  }
+  while (srcStart < srcEnd) {
+    const digit = <u32>load<u16>(srcStart) - ASCII_ZERO;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+  storeSignedToField<T>(dstObj + dstOffset, negative ? 0 - value : value);
+  return srcStart;
+}
+
+/**
+ * Parse an unsigned integer by consuming the entire `[srcStart, srcEnd)`
+ * range as a digit run.
+ *
+ * Caller guarantees the range is digits only. Uses the unsafe SWAR kernels
+ * with no per-stride validation.
+ *
+ * @param srcStart Pointer to the first UTF-16 code unit.
+ * @param srcEnd   Pointer just past the last code unit.
+ * @returns The parsed value, truncated to `T`.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function deserializeUnsigned_SWAR<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+): T {
+  let value: u64 = 0;
+  while (srcStart + 30 < srcEnd) {
+    value =
+      value * 10_000_000_000_000_000 + parse16Digits_SWAR_Unsafe(srcStart);
+    srcStart += 32;
+  }
+  while (srcStart + 14 < srcEnd) {
+    value =
+      value * 100_000_000 +
+      parse8Digits_PairMul_Unsafe(load<u64>(srcStart), load<u64>(srcStart, 8));
+    srcStart += 16;
+  }
+  while (srcStart + 6 < srcEnd) {
+    value = value * 10_000 + parse4Digits_PairMul_Unsafe(load<u64>(srcStart));
+    srcStart += 8;
+  }
+  while (srcStart < srcEnd) {
+    value = value * 10 + (<u32>load<u16>(srcStart) - ASCII_ZERO);
+    srcStart += 2;
+  }
+  return <T>value;
+}
+
+/**
+ * Scan for an unsigned integer field, stopping at the first non-digit
+ * character. Writes the parsed value through `dstObj + dstOffset` and
+ * returns the source position immediately after the last digit.
+ *
+ * @param srcStart  Pointer to the first UTF-16 code unit.
+ * @param srcEnd    Pointer just past the last code unit.
+ * @param dstObj    Destination object pointer.
+ * @param dstOffset Byte offset of the field within `dstObj`.
+ * @returns The source position immediately after the last digit consumed.
+ */
+// @ts-expect-error: @inline is a valid decorator
+@inline export function deserializeUnsignedField_SWAR<T extends number>(
+  srcStart: usize,
+  srcEnd: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
+): usize {
+  let value: u64 = 0;
+  // Unsigned scan uses parse8 + scalar only (see file header).
+  while (srcStart + 14 < srcEnd) {
+    const parsed = parse8Digits_PairMul(
+      load<u64>(srcStart),
+      load<u64>(srcStart, 8),
+    );
+    if (parsed == U32.MAX_VALUE) break;
+    value = value * 100_000_000 + parsed;
+    srcStart += 16;
+  }
+  while (srcStart < srcEnd) {
+    const digit = <u32>load<u16>(srcStart) - ASCII_ZERO;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+  storeUnsignedToField<T>(dstObj + dstOffset, value);
+  return srcStart;
+}