json-as 1.3.7 → 1.3.8

package/assembly/deserialize/swar/string.ts

@@ -52,101 +52,103 @@ import { hex4_to_u16_swar } from "../../util/swar";
   return changetype<string>(out);
 }
 
+// Standalone (whole-value) escaped scanner. Quotes are already stripped, so
+// `srcEnd` is the payload end and only `\` escapes are handled. Same HYBRID
+// strategy as the field scanner: escape blocks use a free optimistic u64 store
+// for the plain prefix; clean runs stream the first block then bulk-memcpy the
+// remainder. The `backslash_mask_unsafe` hits are confirmed scalarly.
+//
+// NOTE: vs the prior overflow scanner this is faster on dense and sparse
+// escaping but ~20% slower on sustained moderate-density escaping (escape
+// every ~20 chars), where multi-escape-per-block had an edge.
 // @ts-expect-error: @inline is a valid decorator
 @inline function deserializeEscapedString_SWAR(
   payloadStart: usize,
   escapeStart: usize,
   srcEnd: usize,
 ): string {
-  const srcEnd8 = srcEnd - 8;
   const prefixLen = <u32>(escapeStart - payloadStart);
   const outStart = bs.offset - bs.buffer;
-  bs.ensureSize(<u32>(srcEnd - payloadStart));
+  bs.ensureSize(<u32>(srcEnd - payloadStart) + 8); // +8 slack for u64 overcopy
   if (prefixLen != 0) {
     memory.copy(bs.offset, payloadStart, prefixLen);
     bs.offset += prefixLen;
   }
 
   let srcStart = escapeStart;
+  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
 
-  while (srcStart < srcEnd8) {
+  while (srcStart <= srcEnd8) {
     const block = load<u64>(srcStart);
-    store<u64>(bs.offset, block);
-
     let mask = inline.always(backslash_mask_unsafe(block));
-
-    // Early exit
-    if (mask === 0) {
-      srcStart += 8;
+    if (mask == 0) {
+      store<u64>(bs.offset, block);
       bs.offset += 8;
+      srcStart += 8;
+      if (
+        srcStart <= srcEnd8 &&
+        inline.always(backslash_mask_unsafe(load<u64>(srcStart))) == 0
+      ) {
+        const runStart = srcStart;
+        srcStart += 8;
+        while (
+          srcStart <= srcEnd8 &&
+          inline.always(backslash_mask_unsafe(load<u64>(srcStart))) == 0
+        ) {
+          srcStart += 8;
+        }
+        const runLen = <u32>(srcStart - runStart);
+        memory.copy(bs.offset, runStart, runLen);
+        bs.offset += runLen;
+      }
       continue;
     }
 
+    store<u64>(bs.offset, block);
+    let handled = false;
     do {
-      const laneIdx = usize(ctz(mask) >> 3); // 0 2 4 6
+      const laneIdx = usize(ctz(mask) >> 3);
       mask &= mask - 1;
       const srcIdx = srcStart + laneIdx;
-      const dstIdx = bs.offset + laneIdx;
-      const header = load<u32>(srcIdx);
-      const code = <u16>(header >> 16);
-
-      // Detect false positive (code unit where low byte is 0x5C)
-      if ((header & 0xffff) !== 0x5c) continue;
-
-      // Hot path (negative bias)
+      if ((load<u32>(srcIdx) & 0xffff) !== 0x5c) continue; // false positive
+      bs.offset += laneIdx;
+      const code = load<u16>(srcIdx, 2);
       if (code !== 0x75) {
-        // Short escapes (\n \t \" \\)
-        const escaped = load<u16>(DESERIALIZE_ESCAPE_TABLE + code);
-        mask &= mask - usize(escaped === 0x5c);
-        store<u16>(dstIdx, escaped);
-        store<u32>(dstIdx, load<u32>(srcIdx, 4), 2);
-
-        const l6 = usize(laneIdx === 6);
-        bs.offset -= (1 - l6) << 1;
-        srcStart += l6 << 1;
-        continue;
+        store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
+        bs.offset += 2;
+        srcStart = srcIdx + 4;
+      } else {
+        store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcIdx, 4)));
+        bs.offset += 2;
+        srcStart = srcIdx + 12;
       }
-
-      // Unicode escape (\uXXXX)
-      const block = load<u64>(srcIdx, 4); // XXXX
-      const escaped = hex4_to_u16_swar(block);
-      store<u16>(dstIdx, escaped);
-      // store<u64>(dstIdx, load<u32>(srcIdx, 12), 2);
-      srcStart += 4 + laneIdx;
-      bs.offset -= 6 - laneIdx;
-    } while (mask !== 0);
-
-    bs.offset += 8;
-    srcStart += 8;
+      handled = true;
+      break;
+    } while (mask != 0);
+    if (!handled) {
+      bs.offset += 8;
+      srcStart += 8;
+    }
   }
 
   while (srcStart < srcEnd) {
-    const block = load<u16>(srcStart);
-    store<u16>(bs.offset, block);
-    srcStart += 2;
-
-    // Early exit
-    if (block !== 0x5c) {
+    const char = load<u16>(srcStart);
+    if (char != BACK_SLASH) {
+      store<u16>(bs.offset, char);
       bs.offset += 2;
+      srcStart += 2;
       continue;
     }
-
-    const code = load<u16>(srcStart);
+    const code = load<u16>(srcStart, 2);
     if (code !== 0x75) {
-      // Short escapes (\n \t \" \\)
-      const block = load<u16>(srcStart);
-      const escape = load<u16>(DESERIALIZE_ESCAPE_TABLE + block);
-      store<u16>(bs.offset, escape);
-      srcStart += 2;
+      store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
+      bs.offset += 2;
+      srcStart += 4;
     } else {
-      // Unicode escape (\uXXXX)
-      const block = load<u64>(srcStart, 2); // XXXX
-      const escaped = hex4_to_u16_swar(block);
-      store<u16>(bs.offset, escaped);
-      srcStart += 10;
+      store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcStart, 4)));
+      bs.offset += 2;
+      srcStart += 12;
     }
-
-    bs.offset += 2;
   }
   return bs.sliceOut<string>(outStart);
 }
@@ -245,45 +247,72 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
   memory.copy(stringPtr, srcStart, byteLength);
 }
 
-// Scans a quoted string value, writes into the destination field, and returns next unread src pointer.
+// Scans a quoted string value, writes into the destination field, and returns
+// the next unread src pointer.
+//
+// HYBRID strategy (validated against the prior run-copy scanner across escape
+// densities — see __benches__/custom/swar-string-deser-hybrid-h2h: +17–70%):
+//   * Escape-bearing block: one optimistic whole-block u64 store copies the
+//     plain prefix for free, then the (scalar-confirmed) escape is decoded.
+//   * Clean block: stream the first one, then if the clean run continues switch
+//     to one bulk memory.copy for the remainder.
+// SWAR masks carry high-byte false positives, so each hit is confirmed
+// scalarly before acting.
 // @ts-expect-error: @inline is a valid decorator
-@inline function deserializeEscapedStringScan_SWAR_SplitTuned(
+@inline function deserializeEscapedStringField_SWAR(
   payloadStart: usize,
   escapeStart: usize,
   srcEnd: usize,
   dstFieldPtr: usize,
 ): usize {
   const prefixLen = <u32>(escapeStart - payloadStart);
-  const srcEnd8 = srcEnd - 8;
   bs.offset = bs.buffer;
-  bs.ensureSize(<u32>(srcEnd - payloadStart));
+  bs.ensureSize(<u32>(srcEnd - payloadStart) + 8); // +8 slack for u64 overcopy
   if (prefixLen != 0) {
     memory.copy(bs.buffer, payloadStart, prefixLen);
     bs.offset += prefixLen;
   }
 
-  let lastPtr = escapeStart;
   let srcStart = escapeStart;
+  const srcEnd8 = srcEnd >= 8 ? srcEnd - 8 : 0;
 
   while (srcStart <= srcEnd8) {
-    const blockStart = srcStart;
-    let mask = inline.always(backslash_or_quote_mask(load<u64>(srcStart)));
-    if (mask === 0) {
+    const block = load<u64>(srcStart);
+    let mask = inline.always(backslash_or_quote_mask(block));
+    if (mask == 0) {
+      store<u64>(bs.offset, block);
+      bs.offset += 8;
       srcStart += 8;
+      if (
+        srcStart <= srcEnd8 &&
+        inline.always(backslash_or_quote_mask(load<u64>(srcStart))) == 0
+      ) {
+        const runStart = srcStart;
+        srcStart += 8;
+        while (
+          srcStart <= srcEnd8 &&
+          inline.always(backslash_or_quote_mask(load<u64>(srcStart))) == 0
+        ) {
+          srcStart += 8;
+        }
+        const runLen = <u32>(srcStart - runStart);
+        memory.copy(bs.offset, runStart, runLen);
+        bs.offset += runLen;
+      }
       continue;
     }
 
+    // Escape/quote block (mask may carry high-byte false positives).
+    store<u64>(bs.offset, block);
+    let handled = false;
     do {
       const laneIdx = usize(ctz(mask) >> 3);
       mask &= mask - 1;
       const srcIdx = srcStart + laneIdx;
       const char = load<u16>(srcIdx);
+      if (char != QUOTE && char != BACK_SLASH) continue; // false positive
+      bs.offset += laneIdx;
       if (char == QUOTE) {
-        const runLen = <u32>(srcIdx - lastPtr);
-        if (runLen != 0) {
-          memory.copy(bs.offset, lastPtr, runLen);
-          bs.offset += runLen;
-        }
         writeStringToField(
           dstFieldPtr,
           bs.buffer,
@@ -292,54 +321,39 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
         bs.offset = bs.buffer;
         return srcIdx + 2;
       }
-      if (char != BACK_SLASH) continue;
-
-      const runLen = <u32>(srcIdx - lastPtr);
-      if (runLen != 0) {
-        memory.copy(bs.offset, lastPtr, runLen);
-        bs.offset += runLen;
-      }
-
-      const chunk = load<u32>(srcIdx);
-      const code = <u16>(chunk >> 16);
+      const code = load<u16>(srcIdx, 2);
       if (code !== 0x75) {
         store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
         bs.offset += 2;
-        lastPtr = srcIdx + 4;
+        srcStart = srcIdx + 4;
       } else {
         store<u16>(bs.offset, hex4_to_u16_swar(load<u64>(srcIdx, 4)));
         bs.offset += 2;
-        lastPtr = srcIdx + 12;
+        srcStart = srcIdx + 12;
       }
-      srcStart = lastPtr;
+      handled = true;
       break;
-    } while (mask !== 0);
-    if (srcStart == blockStart) srcStart += 8;
+    } while (mask != 0);
+    if (!handled) {
+      bs.offset += 8;
+      srcStart += 8;
+    }
   }
 
+  // scalar tail (< 8 bytes remaining)
   while (srcStart < srcEnd) {
     const char = load<u16>(srcStart);
     if (char == QUOTE) {
-      const runLen = <u32>(srcStart - lastPtr);
-      if (runLen != 0) {
-        memory.copy(bs.offset, lastPtr, runLen);
-        bs.offset += runLen;
-      }
       writeStringToField(dstFieldPtr, bs.buffer, <u32>(bs.offset - bs.buffer));
       bs.offset = bs.buffer;
       return srcStart + 2;
     }
     if (char != BACK_SLASH) {
+      store<u16>(bs.offset, char);
+      bs.offset += 2;
       srcStart += 2;
       continue;
     }
-
-    const runLen = <u32>(srcStart - lastPtr);
-    if (runLen != 0) {
-      memory.copy(bs.offset, lastPtr, runLen);
-      bs.offset += runLen;
-    }
-
     const code = load<u16>(srcStart, 2);
     if (code !== 0x75) {
       store<u16>(bs.offset, load<u16>(DESERIALIZE_ESCAPE_TABLE + code));
@@ -350,7 +364,6 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
       bs.offset += 2;
       srcStart += 12;
     }
-    lastPtr = srcStart;
   }
 
   bs.offset = bs.buffer;
@@ -462,8 +475,10 @@ export function deserializeString_SWAR(srcStart: usize, srcEnd: usize): string {
 export function deserializeStringField_SWAR<T extends string | null>(
   srcStart: usize,
   srcEnd: usize,
-  dstFieldPtr: usize,
+  dstObj: usize,
+  dstOffset: usize = 0,
 ): usize {
+  const dstFieldPtr = dstObj + dstOffset;
   if (srcStart + 2 > srcEnd || load<u16>(srcStart) != QUOTE)
     abort("Expected leading quote");
 
@@ -506,7 +521,7 @@ export function deserializeStringField_SWAR<T extends string | null>(
       }
       if (char != BACK_SLASH) continue;
       return inline.always(
-        deserializeEscapedStringScan_SWAR_SplitTuned(
+        deserializeEscapedStringField_SWAR(
           payloadStart,
           srcIdx,
           srcEnd,
@@ -530,7 +545,7 @@ export function deserializeStringField_SWAR<T extends string | null>(
     }
     if (char == BACK_SLASH) {
       return inline.always(
-        deserializeEscapedStringScan_SWAR_SplitTuned(
+        deserializeEscapedStringField_SWAR(
           payloadStart,
           srcStart,
           srcEnd,

package/assembly/deserialize/swar/typedarray.ts

@@ -0,0 +1,224 @@
+// SWAR-mode TypedArray / ArrayBuffer deserializer.
+//
+// The naive variant in `../naive/typedarray.ts` does two scalar passes
+// (count digit-starts, then call `JSON.__deserialize` per element which
+// re-scans the same digits). This rewrite replaces both passes:
+//
+//   - **No count pass.** TypedArrays have a fixed length at construction,
+//     so the natural approach is to count first then allocate. We tried
+//     that with a SWAR comma counter — it cut the per-element cost but
+//     kept us ~30% below the top-level `f64[]` path because the count
+//     scan still touched the whole input twice. Instead we allocate
+//     worst-case (`(srcEnd - srcStart) >> 2 + 1` elements — each
+//     element needs >= "D," = 2 UTF-16 chars = 4 bytes) and `__renew`
+//     the underlying buffer down to the exact byte count after parsing.
+//     The over-allocation peaks at ~2-3× the final size for typical
+//     payloads; the trim is a single `memory.copy` on the GC's terms.
+//
+//   - **Inline parse.** The integer parsers come from `./array/integer.ts`
+//     (refactored to take element type `E` so the same
+//     `parseSignedIntegerSWAR` serves `Array<i32>` and `Int32Array`).
+//     The float parser comes from `./array/float.ts`. Stores write
+//     directly to `dataStart + index * elementSize`, bypassing the
+//     typed-array's bounds-checked `[]=` setter.
+
+import { isSpace } from "../../util";
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
+import { parseFloatElementSWAR } from "./array/float";
+import {
+  parseSignedIntegerSWAR,
+  parseUnsignedIntegerSWAR,
+} from "./array/integer";
+
+/**
+ * SWAR TypedArray deserializer.
+ *
+ * Counts commas (with empty-body detection), allocates the typed array
+ * at the exact size, then parses each element inline with no per-call
+ * function dispatch. Stores write directly to `dataStart + idx *
+ * elementSize`, bypassing the typed-array's bounds-checked `[]=` setter.
+ *
+ * Falls through to the underlying SWAR float / integer parsers; the
+ * element type (`f32/f64/u8/i32/...`) is detected via `isFloat<E>()` /
+ * `isSigned<E>()` and AS folds the type dispatch at compile time.
+ */
+/**
+ * Worst-case element count: each element occupies >= 1 digit + 1
+ * delimiter = 2 UTF-16 chars = 4 bytes. So `(srcEnd - srcStart) >> 2`
+ * upper-bounds the count. Allocating to worst-case lets us skip a
+ * full count pass over the input — at the cost of an over-allocated
+ * underlying buffer that we trim via `__renew` once we know the
+ * actual element count.
+ *
+ * For a top-level f64[] payload of ~64 MiB JSON encoding 6M floats,
+ * worst-case alloc is ~16M f64 = 128 MB temporarily. We trim back
+ * to ~48 MB after parse. The trim is a wasm `memory.copy` (or just
+ * a length update if the runtime supports in-place shrink), much
+ * cheaper than a second 64 MB scan over the input.
+ */
+export function deserializeTypedArray_SWAR<T extends ArrayLike<number>>(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize = 0,
+): T {
+  // Find the opening `[`, then skip whitespace to the first non-WS char.
+  while (srcStart < srcEnd) {
+    const ch = load<u16>(srcStart);
+    if (ch == BRACKET_LEFT) {
+      srcStart += 2;
+      break;
+    }
+    srcStart += 2;
+  }
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+
+  // Empty-array fast path.
+  if (srcStart >= srcEnd || load<u16>(srcStart) == BRACKET_RIGHT) {
+    let out = changetype<T>(dst || changetype<usize>(instantiate<T>(0)));
+    if (out.length != 0) out = changetype<T>(instantiate<T>(0));
+    return out;
+  }
+
+  const elementSize = sizeof<valueof<T>>();
+  const maxElements = i32((<usize>(srcEnd - srcStart)) >> 2) + 1;
+  let out = changetype<T>(
+    dst || changetype<usize>(instantiate<T>(maxElements)),
+  );
+  if (out.length != maxElements) {
+    out = changetype<T>(instantiate<T>(maxElements));
+  }
+
+  const dataStart = out.dataStart;
+  let writePtr = dataStart;
+
+  // Parse loop. Each element parses into the slot at `writePtr`, then
+  // the separator (`,` or `]`) is consumed. Whitespace surrounding the
+  // separator is skipped to match the naive variant's behaviour.
+  while (srcStart < srcEnd) {
+    let next: usize = 0;
+    if (isFloat<valueof<T>>()) {
+      next = parseFloatElementSWAR<valueof<T>>(srcStart, srcEnd, writePtr);
+    } else if (isSigned<valueof<T>>()) {
+      next = parseSignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, writePtr);
+    } else {
+      next = parseUnsignedIntegerSWAR<valueof<T>>(srcStart, srcEnd, writePtr);
+    }
+    if (!next) break;
+    writePtr += elementSize;
+    srcStart = next;
+    if (srcStart >= srcEnd) break;
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    const ch = load<u16>(srcStart);
+    if (ch == COMMA) {
+      srcStart += 2;
+      while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+      continue;
+    }
+    if (ch == BRACKET_RIGHT) break;
+    break;
+  }
+
+  // Trim to actual count. `out.length =` on a typed-array isn't legal
+  // (length is read-only), so we shrink the underlying ArrayBufferView
+  // directly: `__renew` the buffer to the actual byte length and
+  // update the view's `byteLength` and `dataStart`. AS's TypedArray
+  // structure has `buffer`, `dataStart` (= buffer), `byteLength`
+  // (capacity in bytes) in that order — same layout as ArrayBufferView.
+  const actualCount = i32(<usize>(writePtr - dataStart) / elementSize);
+  if (actualCount != maxElements) {
+    const actualBytes = <usize>actualCount * elementSize;
+    const oldBuffer = changetype<ArrayBuffer>(
+      load<usize>(changetype<usize>(out)),
+    );
+    const newBuffer = __renew(changetype<usize>(oldBuffer), actualBytes);
+    // Update buffer, dataStart, byteLength on the view.
+    store<usize>(changetype<usize>(out), newBuffer);
+    store<usize>(
+      changetype<usize>(out),
+      newBuffer,
+      offsetof<ArrayBufferView>("dataStart"),
+    );
+    store<i32>(
+      changetype<usize>(out),
+      i32(actualBytes),
+      offsetof<ArrayBufferView>("byteLength"),
+    );
+    __link(changetype<usize>(out), newBuffer, false);
+  }
+
+  return out;
+}
+
+/**
+ * SWAR ArrayBuffer deserializer. JSON encoding is `[u8, u8, ...]` so
+ * elements are always 1-3 ASCII digits (0..255). We can use the same
+ * comma-count + inline-parse strategy as above, but since the result
+ * is an `ArrayBuffer` rather than a `TypedArray<E>`, we use a plain
+ * `store<u8>` directly.
+ */
+export function deserializeArrayBuffer_SWAR(
+  srcStart: usize,
+  srcEnd: usize,
+  dst: usize = 0,
+): ArrayBuffer {
+  while (srcStart < srcEnd) {
+    const ch = load<u16>(srcStart);
+    if (ch == BRACKET_LEFT) {
+      srcStart += 2;
+      break;
+    }
+    srcStart += 2;
+  }
+  while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+
+  if (srcStart >= srcEnd || load<u16>(srcStart) == BRACKET_RIGHT) {
+    let out = dst ? changetype<ArrayBuffer>(dst) : new ArrayBuffer(0);
+    if (out.byteLength != 0) out = new ArrayBuffer(0);
+    return out;
+  }
+
+  // Worst-case byte count: each element is `D,` minimum = 4 bytes.
+  const maxBytes = i32((<usize>(srcEnd - srcStart)) >> 2) + 1;
+  let out = dst ? changetype<ArrayBuffer>(dst) : new ArrayBuffer(maxBytes);
+  if (out.byteLength != maxBytes) {
+    out = new ArrayBuffer(maxBytes);
+  }
+
+  const dataStart = changetype<usize>(out);
+  let writePtr: usize = 0;
+
+  while (srcStart < srcEnd) {
+    const next = parseUnsignedIntegerSWAR<u8>(
+      srcStart,
+      srcEnd,
+      dataStart + writePtr,
+    );
+    if (!next) break;
+    writePtr += 1;
+    srcStart = next;
+    if (srcStart >= srcEnd) break;
+
+    while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+    if (srcStart >= srcEnd) break;
+    const ch = load<u16>(srcStart);
+    if (ch == COMMA) {
+      srcStart += 2;
+      while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+      continue;
+    }
+    if (ch == BRACKET_RIGHT) break;
+    break;
+  }
+
+  // Trim to actual byte count via `__renew`.
+  const actualBytes = i32(writePtr);
+  if (actualBytes != maxBytes) {
+    out = changetype<ArrayBuffer>(
+      __renew(changetype<usize>(out), <usize>actualBytes),
+    );
+  }
+
+  return out;
+}