json-as 1.1.25 → 1.1.27

package/assembly/deserialize/swar/string.ts

@@ -0,0 +1,128 @@
+import { bs } from "../../../lib/as-bs";
+import { BACK_SLASH } from "../../custom/chars";
+import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
+
+// @ts-ignore: decorator allowed
+@lazy const LANE_MASK_HIGH = 0xFF00_FF00_FF00_FF00;
+// @ts-ignore: decorator allowed
+@lazy const LANE_MASK_LOW = 0x00FF_00FF_00FF_00FF;
+// @ts-ignore: decorator allowed
+@lazy const UINT64_H8 = 0x8080808080808080;
+// @ts-ignore: decorator allowed
+@lazy const QUOTE_MASK = 0x0022_0022_0022_0022;
+// @ts-ignore: decorator allowed
+@lazy const BACKSLASH_MASK = 0x005C_005C_005C_005C;
+// @ts-ignore: decorator allowed
+@lazy const CONTROL_MASK = 0x0020_0020_0020_0020;
+// @ts-ignore: decorator allowed
+@lazy const U00_MARKER = 13511005048209500;
+
+/**
+ * Deserializes strings back into into their original form using SIMD operations
+ * @param src string to deserialize
+ * @param dst buffer to write to
+ * @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_SWAR(srcStart: usize, srcEnd: usize): void {
+  srcStart += 2;
+  srcEnd -= 2;
+  bs.proposeSize(u32(srcEnd - srcStart));
+
+//   const src_end_15 = srcEnd - 15;
+//   while (srcStart < src_end_15) {
+//     const block = load<u64>(srcStart);
+//     store<u64>(dst_ptr, block);
+
+//     let mask = v64x4_eq(block, BACKSLASH_MASK);
+
+//     while (mask != 0) {
+//       const lane_index = usize(ctz(mask) >> 3);
+//       const dst_offset = dst_ptr + 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);
+//         memory.copy(dst_offset + 2, src_offset + 4, (4 - lane_index) << 1);
+//         // 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);
+//         memory.copy(dst_offset + 2, src_offset + 4, (4 - lane_index) << 1);
+//         // v128.store(dst_offset, v128.load(src_offset, 4), 2);
+//         // console.log("Escaped:");
+//         if (lane_index == 14) {
+//           srcStart += 2;
+//         } else {
+//           dst_ptr -= 2;
+//         }
+//       }
+//     }
+
+//     srcStart += 16;
+//     dst_ptr += 16;
+
+//     // 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) {
+      code = load<u16>(DESERIALIZE_ESCAPE_TABLE + load<u8>(srcStart, 2));
+      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>(bs.offset, escaped);
+        bs.offset += 2;
+        srcStart += 12;
+      } else {
+        store<u16>(bs.offset, code);
+        bs.offset += 2;
+        srcStart += 4;
+      }
+    } else {
+      store<u16>(bs.offset, code);
+      bs.offset += 2;
+      srcStart += 2;
+    }
+  }
+}
+
+// @ts-ignore: decorators allowed
+@inline function v64x4_eq(x: u64, y: u64): u64 {
+  const xored = (x ^ LANE_MASK_HIGH) ^ y;
+  const mask = (((xored >> 1) | UINT64_H8) - xored) & UINT64_H8;
+  return (mask << 1) - (mask >> 7);
+}
+
+// @ts-ignore: decorators allowed
+@inline function v64x4_ltu(a: u64, b: u64): u64 {
+  // Vigna's algorithm - fastest SWAR unsigned less-than
+  return (((a | UINT64_H8) - (b & ~UINT64_H8)) | (a ^ b)) ^ (a | ~b);
+}

package/assembly/index.ts

@@ -11,7 +11,7 @@ import { deserializeFloat } from "./deserialize/simple/float";
 import { deserializeMap } from "./deserialize/simple/map";
 import { deserializeDate } from "./deserialize/simple/date";
 import { deserializeInteger } from "./deserialize/simple/integer";
-import { deserializeString } from "./deserialize/simple/string";
+// import { deserializeString } from "./deserialize/simple/string";
 import { serializeArbitrary } from "./serialize/simple/arbitrary";
 
 import { NULL_WORD, QUOTE } from "./custom/chars";
@@ -29,6 +29,8 @@ import { serializeRaw } from "./serialize/simple/raw";
 import { deserializeRaw } from "./deserialize/simple/raw";
 import { serializeString_SIMD } from "./serialize/simd/string";
 import { serializeString_SWAR } from "./serialize/swar/string";
+import { deserializeString_SWAR } from "./deserialize/swar/string";
+import { deserializeString } from "./deserialize/simple/string";
 // import { deserializeString_SIMD } from "./deserialize/simd/string";
 
 /**
@@ -185,8 +187,9 @@ export namespace JSON {
       //   // @ts-ignore
       //   return changetype<string>(deserializeString_SIMD(dataPtr, dataPtr + dataSize, __new(dataSize - 4, idof<string>())));
       // } else {
+      
       // @ts-ignore
-      return deserializeString(dataPtr, dataPtr + dataSize, __new(dataSize - 4, idof<string>()));
+      return deserializeString(dataPtr, dataPtr + dataSize, 0);
       // }
     } else if (isArray<T>()) {
       // @ts-ignore
@@ -605,6 +608,7 @@ export namespace JSON {
       return deserializeFloat<T>(srcStart, srcEnd);
     } else if (isString<T>()) {
       if (srcEnd - srcStart < 4) throw new Error("Cannot parse data as string because it was formatted incorrectly!");
+      
       // @ts-ignore: type
       return deserializeString(srcStart, srcEnd, dst);
     } else if (isNullable<T>() && srcEnd - srcStart == 8 && load<u64>(srcStart) == 30399761348886638) {

package/assembly/serialize/swar/string.ts

@@ -2,14 +2,17 @@ import { bs } from "../../../lib/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { bytes } from "../../util/bytes";
+import { serializeString } from "../simple/string";
 
 
 // @ts-ignore: decorator allowed
 @lazy const LANE_MASK_HIGH = 0xFF00_FF00_FF00_FF00;
 // @ts-ignore: decorator allowed
+@lazy const ONES: u64 = 0x0101010101010101;
+// @ts-ignore: decorator allowed
 @lazy const LANE_MASK_LOW = 0x00FF_00FF_00FF_00FF;
 // @ts-ignore: decorator allowed
-@lazy const UINT64_H8 = 0x8080808080808080;
+@lazy const HIGHS = 0x8080808080808080;
 // @ts-ignore: decorator allowed
 @lazy const QUOTE_MASK = 0x0022_0022_0022_0022;
 // @ts-ignore: decorator allowed
@@ -19,91 +22,90 @@ import { bytes } from "../../util/bytes";
 // @ts-ignore: decorator allowed
 @lazy const U00_MARKER = 13511005048209500;
 
-export function serializeString_SWAR(src: string): void {
-  const srcSize = bytes(src);
-  let srcStart = changetype<usize>(src);
-  const srcEnd = srcStart + srcSize;
-  const srcEnd8 = srcEnd - 8;
+// @ts-ignore: decorator valid here
+@inline export function serializeString_SWAR(src: string): void {
+  serializeString(src);
+
+  // const srcSize = bytes(src);
+  // let srcStart = changetype<usize>(src);
+  // const srcEnd = srcStart + srcSize;
+  // const srcEnd8 = srcEnd - 8;
 
-  bs.proposeSize(srcSize + 4);
-  store<u16>(bs.offset, 34); // "
-  bs.offset += 2;
+  // bs.proposeSize(srcSize + 4);
+  // store<u16>(bs.offset, 34); // "
+  // bs.offset += 2;
 
-  while (srcStart <= srcEnd8) {
-    const block = load<u64>(srcStart);
-    store<u64>(bs.offset, block);
+  // while (srcStart <= srcEnd8) {
+  //   const block = load<u64>(srcStart);
+  //   store<u64>(bs.offset, block);
 
-    let mask = (
-      v64x4_eq(block, QUOTE_MASK) |
-      v64x4_eq(block, BACKSLASH_MASK) |
-      v64x4_ltu(block & LANE_MASK_LOW, CONTROL_MASK)
-    ) & UINT64_H8
+  //   let mask = (
+  //     v64x4_eq(block, QUOTE_MASK) |
+  //     v64x4_eq(block, BACKSLASH_MASK) |
+  //     v64x4_ltu(block & LANE_MASK_LOW, CONTROL_MASK)
+  //   ) & HIGHS
 
-    while (mask != 0) {
-      const lane_index = usize(ctz(mask) >> 3);
-      console.log("lane index " + lane_index.toString());
-      const src_offset = srcStart + lane_index;
-      const code = load<u16>(src_offset) << 2;
-      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + code);
+  //   while (mask != 0) {
+  //     const lane_index = usize(ctz(mask) >> 3);
+  //     const src_offset = srcStart + lane_index;
+  //     const dst_offset = bs.offset + lane_index;
+  //     const code = load<u16>(src_offset) << 2;
+  //     const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + code);
 
-      if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.growSize(10);
-        const dst_offset = bs.offset + lane_index;
-        store<u64>(dst_offset, U00_MARKER);
-        store<u32>(dst_offset, escaped, 8);
-        // store<u64>(dst_offset, load<u64>(src_offset, 2), 12); // unsafe. can overflow here
-        memory.copy(dst_offset + 12, src_offset + 2, (4 - lane_index) << 1);
-        bs.offset += 10;
-      } else {
-        bs.growSize(2);
-        const dst_offset = bs.offset + lane_index;
-        store<u32>(dst_offset, escaped);
-        // store<u64>(dst_offset, load<u64>(src_offset, 2), 4);
-        memory.copy(dst_offset + 4, src_offset + 2, (4 - lane_index) << 1);
-        bs.offset += 2;
-      }
+  //     if ((escaped & 0xffff) != BACK_SLASH) {
+  //       bs.growSize(10);
+  //       store<u64>(dst_offset, U00_MARKER);
+  //       store<u32>(dst_offset, escaped, 8);
+  //       // store<u64>(dst_offset, load<u64>(src_offset, 2), 12); // unsafe. can overflow here
+  //       memory.copy(dst_offset + 12, src_offset + 2, (4 - lane_index) << 1);
+  //       bs.offset += 10;
+  //     } else {
+  //       bs.growSize(2);
+  //       store<u32>(dst_offset, escaped);
+  //       // store<u64>(dst_offset, load<u64>(src_offset, 2), 4);
+  //       memory.copy(dst_offset + 4, src_offset + 2, (4 - lane_index) << 1);
+  //       bs.offset += 2;
+  //     }
 
-      mask &= mask - 1;
-    }
+  //     mask &= mask - 1;
+  //   }
 
-    srcStart += 8;
-    bs.offset += 8;
-  }
+  //   srcStart += 8;
+  //   bs.offset += 8;
+  // }
 
-  while (srcStart <= srcEnd - 2) {
-    const code = load<u16>(srcStart);
-    if (code == 92 || code == 34 || code < 32) {
-      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
-      if ((escaped & 0xffff) != BACK_SLASH) {
-        bs.growSize(10);
-        store<u64>(bs.offset, U00_MARKER);
-        store<u32>(bs.offset, escaped, 8);
-        bs.offset += 12;
-      } else {
-        bs.growSize(2);
-        store<u32>(bs.offset, escaped);
-        bs.offset += 4;
-      }
-    } else {
-      store<u16>(bs.offset, code);
-      bs.offset += 2;
-    }
-    srcStart += 2;
-  }
+  // while (srcStart <= srcEnd - 2) {
+  //   const code = load<u16>(srcStart);
+  //   if (code == 92 || code == 34 || code < 32) {
+  //     const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
+  //     if ((escaped & 0xffff) != BACK_SLASH) {
+  //       bs.growSize(10);
+  //       store<u64>(bs.offset, U00_MARKER);
+  //       store<u32>(bs.offset, escaped, 8);
+  //       bs.offset += 12;
+  //     } else {
+  //       bs.growSize(2);
+  //       store<u32>(bs.offset, escaped);
+  //       bs.offset += 4;
+  //     }
+  //   } else {
+  //     store<u16>(bs.offset, code);
+  //     bs.offset += 2;
+  //   }
+  //   srcStart += 2;
+  // }
 
-  store<u16>(bs.offset, 34); // "
-  bs.offset += 2;
+  // store<u16>(bs.offset, 34); // "
+  // bs.offset += 2;
 }
 
 // @ts-ignore: decorators allowed
 @inline function v64x4_eq(x: u64, y: u64): u64 {
   const xored = (x ^ LANE_MASK_HIGH) ^ y;
-  const mask = (((xored >> 1) | UINT64_H8) - xored) & UINT64_H8;
+  const mask = (((xored >> 1) | HIGHS) - xored) & HIGHS;
   return (mask << 1) - (mask >> 7);
 }
-
 // @ts-ignore: decorators allowed
 @inline function v64x4_ltu(a: u64, b: u64): u64 {
-  // Vigna's algorithm - fastest SWAR unsigned less-than
-  return (((a | UINT64_H8) - (b & ~UINT64_H8)) | (a ^ b)) ^ (a | ~b);
+  return (((a | HIGHS) - (b & ~HIGHS)) | (a ^ b)) ^ (a | ~b);
 }

package/assembly/test.tmp.ts

@@ -1,11 +1,7 @@
 import {
-  bs
-} from "../lib/as-bs";
+  JSON
+} from ".";
 import {
-  serializeString_SIMD
-} from "./serialize/simd/string";
-import {
-  serializeString_SWAR
-} from "./serialize/swar/string";
-serializeString_SWAR("a\"cd");
-console.log(bs.out<string>());
+  expect
+} from "./__tests__/lib";
+expect(JSON.stringify(JSON.parse<string>(JSON.stringify("abcdYZ12345890sdfw\"vie91kfESDFOK12i9i12dsf./?")))).toBe("\"abcdYZ12345890sdfw\b\"vie91kfESDFOK12i9i12dsf./?\"");

package/assembly/test.ts

@@ -1,7 +1,4 @@
-import { bs } from "../lib/as-bs";
-import { serializeString_SIMD } from "./serialize/simd/string";
-import { serializeString_SWAR } from "./serialize/swar/string";
+import { JSON } from ".";
+import { expect } from "./__tests__/lib";
 
-serializeString_SWAR("a\"cd");
-// serializeString_SIMD("a\0b\"\nd");
-console.log(bs.out<string>());
+expect(JSON.stringify(JSON.parse<string>(JSON.stringify("abcdYZ12345890sdfw\"vie91kfESDFOK12i9i12dsf./?")))).toBe('"abcdYZ12345890sdfw\\"vie91kfESDFOK12i9i12dsf./?"')

package/bench/abc.bench.ts

@@ -1,4 +1,5 @@
-import { bench } from "./lib/bench.js";
+import { dumpToFile } from "./lib/bench.js";
+import { bench, blackbox } from "./lib/bench.js";
 
 const v1 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 const v2 = '"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"';
@@ -6,22 +7,19 @@ const v2 = '"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"';
 bench(
   "Serialize Alphabet",
   () => {
-    blackbox(JSON.stringify(blackbox(v1)));
+    blackbox(JSON.stringify(v1));
   },
   64_000_00,
   v1.length << 1,
 );
+dumpToFile("abc", "serialize")
 
 bench(
   "Deserialize Alphabet",
   () => {
-    blackbox(JSON.parse(blackbox(v2)));
+    blackbox(JSON.parse(v2));
   },
   64_000_00,
   v2.length << 1,
 );
-
-function blackbox<T>(value: T): T {
-  (globalThis as any).__blackhole = value;
-  return globalThis.__blackhole;
-}
+dumpToFile("abc", "deserialize")