json-as 1.2.1 → 1.2.2

package/README.md

@@ -16,8 +16,8 @@
   - [Using Custom Serializers or Deserializers](#using-custom-serializers-or-deserializers)
 - [Performance](#performance)
   - [Comparison to JavaScript](#comparison-to-javascript)
+  - [Performance Tuning](#performance-tuning)
   - [Running Benchmarks Locally](#running-benchmarks-locally)
-  - [Re-run Benchmarks](#re-run-benchmarks)
 - [Debugging](#debugging)
 - [License](#license)
 - [Contact](#contact)
@@ -269,6 +269,21 @@ obj.data = JSON.Value.from("a string"); // Changing to a string
 console.log(JSON.stringify(obj)); // {"id":1,"name":"Example","data":"a string"}
 ```
 
+**Working with nullable primitives and dynamic data**
+
+```ts
+const box = JSON.Box.from<i32>(123);
+const value = JSON.Value.from<JSON.Box<i32> | null>(box);
+const reboxed = JSON.Box.fromValue<i32>(value); // Box<i32> | null
+console.log(reboxed !== null ? reboxed!.toString() : "null");
+// 123
+
+const value = JSON.parse<JSON.Value>("123");
+const boxed = JSON.Box.fromValue<i32>(value);
+console.log(boxed !== null ? boxed!.toString() : "null");
+// 123
+```
+
 ### Using Raw JSON strings
 
 Sometimes its necessary to simply copy a string instead of serializing it.
@@ -396,8 +411,23 @@ The following charts compare JSON-AS (both SWAR and SIMD variants) against JavaS
 
 <img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart02.svg" alt="Performance Chart 2">
 
+<img src="https://raw.githubusercontent.com/JairusSW/json-as/refs/heads/docs/charts/chart03.png" alt="Performance Chart 3">
+
 > Note: I have focused on extensively optimizing serialization. I used to have deserialization be highly unsafe and extremely fast, but I've since doubled down on safety for deserialization which has negatively affected performance. I will be optimizing soon.
 
+### Performance Tuning
+
+Instead of using flags for setting options, `json-as` is configured by environmental variables.
+Here's a short list:
+
+**JSON_CACHE** (default: 0) - Enables caching costly strings based on hit frequency. May boost string serialization in excess of 22 GB/s.
+
+**JSON_DEBUG** (default: 0) - Sets the debug level. May be within range `0-3`
+
+**JSON_MODE** (default: SWAR) - Selects which mode should be used. Can be `NAIVE,SWAR,SIMD`. Note that `--enable simd` may be required.
+
+**JSON_WRITE** (default: "") - Select a series of files to output after transform and optimization passes have completed for easy inspection. Usage: `JSON_WRITE=.path-to-file-a.ts,./path-to-file-b.ts`
+
 ### Running benchmarks locally
 
 Benchmarks are run directly on top of v8 for more tailored control

package/assembly/deserialize/simd/string.ts

@@ -1,3 +1,4 @@
+import { bs } from "../../../lib/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
 
@@ -8,94 +9,92 @@ import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables
  * @returns number of bytes written
  */
 // todo: optimize and stuff. it works, its not pretty. ideally, i'd like this to be (nearly) branchless
-export function deserializeString_SIMD(srcStart: usize, srcEnd: usize, dst: usize): usize {
+export function deserializeString_SIMD(srcStart: usize, srcEnd: usize): void {
   const SPLAT_92 = i16x8.splat(92); /* \ */
   srcStart += 2;
   srcEnd -= 2;
-  let dst_ptr = changetype<usize>(dst);
+  bs.ensureSize(u32(srcEnd - srcStart));
   const src_end_15 = srcEnd - 15;
 
-  while (srcStart < src_end_15) {
-    const block = v128.load(srcStart);
-    v128.store(dst_ptr, block);
+  // while (srcStart < src_end_15) {
+  //   const block = v128.load(srcStart);
+  //   v128.store(bs.offset, block);
 
-    const backslash_indices = i16x8.eq(block, SPLAT_92);
-    let mask = i16x8.bitmask(backslash_indices);
+  //   const backslash_indices = i16x8.eq(block, SPLAT_92);
+  //   let mask = i16x8.bitmask(backslash_indices);
 
-    while (mask != 0) {
-      const lane_index = ctz(mask) << 1;
-      const dst_offset = dst_ptr + lane_index;
-      const src_offset = srcStart + lane_index;
-      const code = load<u16>(src_offset, 2);
+  //   while (mask != 0) {
+  //     const lane_index = ctz(mask) << 1;
+  //     const dst_offset = bs.offset + lane_index;
+  //     const src_offset = srcStart + lane_index;
+  //     const code = load<u16>(src_offset, 2);
 
-      mask &= mask - 1;
-      if (code == 117 && load<u32>(src_offset, 4) == 3145776) {
-        const block = load<u32>(src_offset, 8);
-        const codeA = block & 0xffff;
-        const codeB = (block >> 16) & 0xffff;
-        const escapedA = load<u8>(ESCAPE_HEX_TABLE + codeA);
-        const escapedB = load<u8>(ESCAPE_HEX_TABLE + codeB);
-        const escaped = (escapedA << 4) + escapedB;
-        // console.log("Escaped:");
-        // console.log("  a: " + escapedA.toString())
-        // console.log("  b: " + escapedB.toString());
-        // console.log("  c: " + escaped.toString());
-        // console.log("  o: " + (dst_ptr - dst).toString());
-        // console.log("  d: " + (dst_offset - dst).toString())
-        // console.log("  l: " + (lane_index).toString())
-        store<u16>(dst_offset, escaped);
-        v128.store(dst_offset, v128.load(src_offset, 4), 2);
-        if (lane_index >= 6) {
-          const bytes_left = lane_index - 4;
-          srcStart += bytes_left;
-          dst_ptr += bytes_left;
-          // console.log("  e: " + (bytes_left).toString())
-        }
-        dst_ptr -= 10;
-      } else {
-        const escaped = load<u8>(DESERIALIZE_ESCAPE_TABLE + code);
-        store<u16>(dst_offset, escaped);
-        v128.store(dst_offset, v128.load(src_offset, 4), 2);
-        // console.log("Escaped:");
-        if (lane_index == 14) {
-          srcStart += 2;
-        } else {
-          dst_ptr -= 2;
-        }
-      }
-    }
+  //     mask &= mask - 1;
+  //     if (code == 117 && load<u32>(src_offset, 4) == 3145776) {
+  //       const block = load<u32>(src_offset, 8);
+  //       const codeA = block & 0xffff;
+  //       const codeB = (block >> 16) & 0xffff;
+  //       const escapedA = load<u8>(ESCAPE_HEX_TABLE + codeA);
+  //       const escapedB = load<u8>(ESCAPE_HEX_TABLE + codeB);
+  //       const escaped = (escapedA << 4) + escapedB;
+  //       // console.log("Escaped:");
+  //       console.log("  a: " + escapedA.toString())
+  //       console.log("  b: " + escapedB.toString());
+  //       console.log("  c: " + escaped.toString());
+  //       console.log("  o: " + (bs.offset - dst).toString());
+  //       console.log("  d: " + (dst_offset - dst).toString())
+  //       console.log("  l: " + (lane_index).toString())
+  //       store<u16>(dst_offset, escaped);
+  //       v128.store(dst_offset, v128.load(src_offset, 4), 2);
+  //       if (lane_index >= 6) {
+  //         const bytes_left = lane_index - 4;
+  //         srcStart += bytes_left;
+  //         bs.offset += bytes_left;
+  //         // console.log("  e: " + (bytes_left).toString())
+  //       }
+  //       bs.offset -= 10;
+  //     } else {
+  //       const escaped = load<u8>(DESERIALIZE_ESCAPE_TABLE + code);
+  //       store<u16>(dst_offset, escaped);
+  //       v128.store(dst_offset, v128.load(src_offset, 4), 2);
+  //       // console.log("Escaped:");
+  //       if (lane_index == 14) {
+  //         srcStart += 2;
+  //       } else {
+  //         bs.offset -= 2;
+  //       }
+  //     }
+  //   }
 
-    srcStart += 16;
-    dst_ptr += 16;
+  //   srcStart += 16;
+  //   bs.offset += 16;
 
-    // console.log("src: " + (srcStart - changetype<usize>(src)).toString());
-    // console.log("dst: " + (dst_ptr - dst).toString());
-  }
+  //   // console.log("src: " + (srcStart - changetype<usize>(src)).toString());
+  //   // console.log("dst: " + (dst_ptr - dst).toString());
+  // }
   while (srcStart < srcEnd) {
     let code = load<u16>(srcStart);
-    if (code == BACK_SLASH) {
+    if (code === BACK_SLASH) {
       code = load<u16>(DESERIALIZE_ESCAPE_TABLE + load<u8>(srcStart, 2));
-      if (code == 117 && load<u32>(srcStart, 4) == 3145776) {
+      if (code === 117 && load<u32>(srcStart, 4) === 3145776) {
         const block = load<u32>(srcStart, 8);
         const codeA = block & 0xffff;
         const codeB = (block >> 16) & 0xffff;
         const escapedA = load<u8>(ESCAPE_HEX_TABLE + codeA);
         const escapedB = load<u8>(ESCAPE_HEX_TABLE + codeB);
         const escaped = (escapedA << 4) + escapedB;
-        store<u16>(dst_ptr, escaped);
-        dst_ptr += 2;
+        store<u16>(bs.offset, escaped);
+        bs.offset += 2;
         srcStart += 12;
       } else {
-        store<u16>(dst_ptr, code);
-        dst_ptr += 2;
+        store<u16>(bs.offset, code);
+        bs.offset += 2;
         srcStart += 4;
       }
     } else {
-      store<u16>(dst_ptr, code);
-      dst_ptr += 2;
+      store<u16>(bs.offset, code);
+      bs.offset += 2;
       srcStart += 2;
     }
   }
-
-  return dst_ptr - dst;
 }

package/assembly/deserialize/simple/arbitrary.ts

@@ -5,8 +5,6 @@ import { deserializeFloat } from "./float";
 import { deserializeString } from "./string";
 import { deserializeObject } from "./object";
 import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";
-import { bs } from "../../../lib/as-bs";
-import { deserializeString_SWAR } from "../swar/string";
 
 export function deserializeArbitrary(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value {
   const firstChar = load<u16>(srcStart);
@@ -18,7 +16,9 @@ export function deserializeArbitrary(srcStart: usize, srcEnd: usize, dst: usize)
     return JSON.Value.from(deserializeArray<JSON.Value[]>(srcStart, srcEnd, 0));
   } else if (firstChar == 116 || firstChar == 102) return JSON.Value.from(deserializeBoolean(srcStart, srcEnd));
   else if (firstChar == CHAR_N) {
-    return JSON.Value.from<usize>(0);
+    const value = JSON.Value.from<usize>(0);
+    value.isNull = true;
+    return value;
   }
   return unreachable();
-}
+}

package/assembly/deserialize/simple/array/arbitrary.ts

@@ -121,7 +121,7 @@ export function deserializeArbitraryArray(srcStart: usize, srcEnd: usize, dst: u
       }
     } else if (code == CHAR_N) {
       if (load<u64>(srcStart) == 30399761348886638) {
-        console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
+        // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
         // @ts-ignore: type
         out.push(JSON.__deserialize<JSON.Value>(srcStart, (srcStart += 8)));
         // while (isSpace(load<u16>((srcStart += 2)))) {

package/assembly/index.d.ts

@@ -43,3 +43,12 @@ declare function serializer(..._): any;
  */
 // @ts-ignore: type
 declare function deserializer(..._): any;
+
+declare enum JSONMode {
+  SWAR = 0,
+  SIMD = 1,
+  NAIVE = 2
+}
+
+declare const JSON_MODE: JSONMode;
+declare const JSON_CACHE: bool;