json-as 1.3.7 → 1.3.8

package/assembly/deserialize/swar/array/float.ts

@@ -1,9 +1,271 @@
-import { deserializeFloatField } from "../../simple/float";
+import { ptrToStr } from "../../../util/ptrToStr";
+import { scientific } from "../../../util/scientific";
+import { deserializeFloatField_NAIVE } from "../../naive/float";
+import { deserializeFloatArray_NAIVE } from "../../naive/array/float";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
+import { parse4Digits_PairMul } from "../../../util/swar-int";
+import { loadPow10, MAX_EXACT_MANTISSA, MAX_EXACT_POW10 } from "../float";
+import { isSpace } from "../../../util";
 
 
-@inline export function deserializeFloatArrayInto<T extends number[]>(
+@inline function skipFloatArrayWhitespace(
+  srcStart: usize,
+  srcEnd: usize,
+): usize {
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  return srcStart;
+}
+
+// @ts-ignore: inline
+@inline function fallbackStore<E>(
+  origStart: usize,
+  end: usize,
+  slot: usize,
+): void {
+  const s = ptrToStr(origStart, end);
+  if (sizeof<E>() == sizeof<f32>()) {
+    store<f32>(slot, f32.parse(s));
+  } else {
+    store<f64>(slot, f64.parse(s));
+  }
+}
+
+/**
+ * Inline single-pass Lemire-style float element parser for arrays.
+ *
+ * Bit-identical output to `f64.parse` / `f32.parse`: u64 mantissa
+ * accumulation is exact, and `<f64>mantissa * pow10[exp]` is correctly
+ * rounded for the fast-path range (mantissa <= 2^53, |exp| <= 22).
+ * Pathological inputs (oversized mantissa or exponent) fall back to
+ * `f*.parse` over the float's own substring, again matching the NAIVE
+ * baseline.
+ *
+ * Returns the advanced source position on success, or `0` to signal "bail
+ * to the per-element NAIVE path" only for truly malformed input (no leading
+ * digit, lone minus, malformed exponent suffix). Valid-but-out-of-range
+ * numbers are handled inline.
+ */
+// @ts-expect-error: decorators valid here
+@inline export function parseFloatElementSWAR<E>(
+  srcStart: usize,
+  srcEnd: usize,
+  slot: usize,
+): usize {
+  const origStart = srcStart;
+  let p = srcStart;
+  let negative = false;
+  let code = load<u16>(p);
+  if (code == 45) {
+    negative = true;
+    p += 2;
+    if (p >= srcEnd) return 0;
+    code = load<u16>(p);
+  }
+
+  let firstDigit = <u32>code - 48;
+  if (firstDigit > 9) return 0;
+
+  // Integer mantissa: scalar (most JSON integers are 1-3 digits).
+  let mantissa: u64 = 0;
+  let intDigits: i32 = 0;
+  while (p < srcEnd) {
+    const d = <u32>load<u16>(p) - 48;
+    if (d > 9) break;
+    mantissa = mantissa * 10 + <u64>d;
+    intDigits++;
+    p += 2;
+  }
+
+  // Fractional mantissa: parse4 SWAR stride + scalar tail. Same u64
+  // accumulator as the integer part — exponent compensates for fracDigits.
+  let fracDigits: i32 = 0;
+  if (p < srcEnd && load<u16>(p) == 46) {
+    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) - 48;
+      if (d > 9) break;
+      mantissa = mantissa * 10 + <u64>d;
+      fracDigits++;
+      p += 2;
+    }
+  }
+
+  const mantDigits = intDigits + fracDigits;
+  let exponent: i32 = -fracDigits;
+
+  // Optional `e[+-]NNN` suffix.
+  if (p < srcEnd) {
+    code = load<u16>(p);
+    if (code == 101 || code == 69) {
+      const expStart = p;
+      p += 2;
+      if (p >= srcEnd) {
+        fallbackStore<E>(origStart, expStart, slot);
+        return expStart;
+      }
+      let expNeg = false;
+      const sc = load<u16>(p);
+      if (sc == 45) {
+        expNeg = true;
+        p += 2;
+      } else if (sc == 43) {
+        p += 2;
+      }
+      if (p >= srcEnd) {
+        fallbackStore<E>(origStart, expStart, slot);
+        return expStart;
+      }
+      let exp: i32 = 0;
+      let expDigits: i32 = 0;
+      while (p < srcEnd) {
+        const d = <u32>load<u16>(p) - 48;
+        if (d > 9) break;
+        exp = exp * 10 + <i32>d;
+        expDigits++;
+        if (expDigits > 4) {
+          fallbackStore<E>(origStart, p, slot);
+          return p;
+        }
+        p += 2;
+      }
+      if (expDigits == 0) {
+        fallbackStore<E>(origStart, expStart, slot);
+        return expStart;
+      }
+      exponent += expNeg ? -exp : exp;
+    }
+  }
+
+  // Lemire fast path: mantissa <= 2^53 and |exp| <= 22 means a single fmul
+  // on two exactly-representable operands, correctly rounded.
+  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) {
+    // Mantissa fits in u64 but the fast-path constraints don't hold. Call
+    // `scientific` directly with our already-parsed mantissa+exp, skipping
+    // the `ptrToStr` allocation + strtod re-parse.
+    result = scientific(mantissa, exponent);
+  } else {
+    // >19 mantissa digits — beyond u64 capacity, may need strtod's sticky-bit
+    // pattern. Hand off to f*.parse on the float's substring.
+    fallbackStore<E>(origStart, p, slot);
+    return p;
+  }
+  if (negative) result = -result;
+
+  if (sizeof<E>() == sizeof<f32>()) {
+    store<f32>(slot, <f32>result);
+  } else {
+    store<f64>(slot, result);
+  }
+  return p;
+}
+
+/**
+ * Top-level SWAR float-array deserializer (`f64[]` / `f32[]`).
+ *
+ * Worst-case sizing matches the NAIVE variant: each element occupies >=
+ * 2 UTF-16 chars (`D,`), so `(srcEnd - srcStart) >> 2` upper-bounds the
+ * element count. `f64`/`f32` are unmanaged so AS skips zero-fill on
+ * `length=`, making the over-allocation effectively free; the trailing
+ * `out.length` trim recovers the true count.
+ *
+ * The fast loop writes directly through `writePtr` (eliminating the
+ * per-element `Array.push` capacity check + length write) and inlines
+ * `parseFloatElementSWAR` (eliminating the double-scan that
+ * `deserializeFloatArray_NAIVE` performs: scan-to-terminator +
+ * `JSON.__deserialize` re-parse). If the inline parser bails (truly
+ * malformed input), we hand off to the NAIVE path with the pre-allocated
+ * buffer retained so capacity is reused.
+ */
+export function deserializeFloatArray_SWAR<T extends number[]>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize,
+): T {
+  const out = changetype<nonnull<T>>(
+    dst || changetype<usize>(instantiate<T>()),
+  );
+  const originalSrcStart = srcStart;
+
+  const elementSize = sizeof<valueof<T>>();
+  const maxElements = i32((<usize>(srcEnd - srcStart)) >> 2);
+  if (maxElements > 0) out.length = maxElements;
+  const dataStart = out.dataStart;
+  let writePtr = dataStart;
+
+  do {
+    if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
+    srcStart += 2;
+    srcStart = skipFloatArrayWhitespace(srcStart, srcEnd);
+    if (srcStart >= srcEnd) break;
+    if (load<u16>(srcStart) == BRACKET_RIGHT) {
+      out.length = 0;
+      return out;
+    }
+
+    while (srcStart < srcEnd) {
+      const next = parseFloatElementSWAR<valueof<T>>(
+        srcStart,
+        srcEnd,
+        writePtr,
+      );
+      if (!next) break;
+      writePtr += elementSize;
+      srcStart = skipFloatArrayWhitespace(next, srcEnd);
+      if (srcStart >= srcEnd) break;
+
+      const code = load<u16>(srcStart);
+      if (code == COMMA) {
+        srcStart += 2;
+        srcStart = skipFloatArrayWhitespace(srcStart, srcEnd);
+        continue;
+      }
+      if (code == BRACKET_RIGHT) {
+        out.length = i32(<usize>(writePtr - dataStart) / elementSize);
+        return out;
+      }
+      break;
+    }
+  } while (false);
+
+  return deserializeFloatArray_NAIVE<T>(
+    originalSrcStart,
+    srcEnd,
+    changetype<usize>(out),
+  );
+}
+
+/**
+ * Field/into variant — parses `[..]` into the existing `out` array and
+ * returns the cursor past the closing `]`.
+ *
+ * Worst-case pre-sizing (`(srcEnd - srcStart) >> 2`) used by the top-level
+ * SWAR entry is unsafe here: nested callers pass the *outer* container's
+ * `srcEnd`, so on `f64[][][]` payloads like canada.json each tiny inner
+ * `[lon,lat]` would over-allocate megabytes of f64 capacity. Instead we
+ * use `ensureArrayElementSlot`'s grow-or-reuse strategy.
+ */
+@inline export function deserializeFloatArrayBody<T extends number[]>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -13,6 +275,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
   do {
     if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) break;
     srcStart += 2;
+    srcStart = skipFloatArrayWhitespace(srcStart, srcEnd);
     if (srcStart >= srcEnd) break;
     if (load<u16>(srcStart) == BRACKET_RIGHT) {
       out.length = 0;
@@ -21,17 +284,30 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
     while (srcStart < srcEnd) {
       const slot = ensureArrayElementSlot<T>(out, index);
-      srcStart = deserializeFloatField<valueof<T>>(srcStart, srcEnd, slot);
-      if (!srcStart || srcStart >= srcEnd) break;
+      let next = parseFloatElementSWAR<valueof<T>>(srcStart, srcEnd, slot);
+      if (!next) {
+        next = deserializeFloatField_NAIVE<valueof<T>>(srcStart, srcEnd, slot);
+      }
+      srcStart = next;
+      if (!srcStart) break;
+      srcStart = skipFloatArrayWhitespace(srcStart, srcEnd);
+      if (srcStart >= srcEnd) break;
 
       const code = load<u16>(srcStart);
       if (code == COMMA) {
         srcStart += 2;
+        srcStart = skipFloatArrayWhitespace(srcStart, srcEnd);
         index++;
         continue;
       }
       if (code == BRACKET_RIGHT) {
-        out.length = index + 1;
+        // Skip the `out.length =` call when the length is already correct.
+        // `ensureArrayElementSlot` only grows (never shrinks), so when this
+        // array is being reused with the same shape (canada's `[lon,lat]`
+        // pairs across thousands of geometries) the length is unchanged
+        // and the AS runtime's `ensureCapacity` call is pure overhead.
+        const nextLen = index + 1;
+        if (out.length != nextLen) out.length = nextLen;
         return srcStart + 2;
       }
       break;
@@ -47,7 +323,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
   srcEnd: usize,
   fieldPtr: usize,
 ): usize {
-  return deserializeFloatArrayInto<T>(
+  return deserializeFloatArrayBody<T>(
     srcStart,
     srcEnd,
     ensureArrayField<T>(fieldPtr),

package/assembly/deserialize/swar/array/generic.ts

@@ -4,10 +4,11 @@ import {
   ensureArrayElementSlot,
   ensureArrayField,
   scanValueEnd,
+  skipWhitespace,
 } from "./shared";
 
 
-@inline export function deserializeGenericArrayInto<T extends unknown[]>(
+@inline export function deserializeGenericArrayBody<T extends unknown[]>(
   srcStart: usize,
   srcEnd: usize,
   out: T,
@@ -15,6 +16,7 @@ import {
   if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT)
     throw new Error("Failed to parse JSON!");
   srcStart += 2;
+  srcStart = skipWhitespace(srcStart, srcEnd);
   if (srcStart >= srcEnd) throw new Error("Failed to parse JSON!");
   if (load<u16>(srcStart) == BRACKET_RIGHT) return srcStart + 2;
 
@@ -28,10 +30,12 @@ import {
     store<valueof<T>>(slot, JSON.__deserialize<valueof<T>>(srcStart, valueEnd));
     srcStart = valueEnd;
 
+    srcStart = skipWhitespace(srcStart, srcEnd);
     if (srcStart >= srcEnd) break;
     const code = load<u16>(srcStart);
     if (code == COMMA) {
       srcStart += 2;
+      srcStart = skipWhitespace(srcStart, srcEnd);
       continue;
     }
     if (code == BRACKET_RIGHT) {
@@ -50,7 +54,7 @@ import {
   srcEnd: usize,
   fieldPtr: usize,
 ): usize {
-  return deserializeGenericArrayInto<T>(
+  return deserializeGenericArrayBody<T>(
     srcStart,
     srcEnd,
     ensureArrayField<T>(fieldPtr),