json-as 0.5.42 → 0.5.50

package/README.md

@@ -93,25 +93,34 @@ Fully supports:
 
 ## Performance
 
-Number parsing speed has doubled over the last 5 versions due to the use of a `atoi_fast` function found in `assembly/util.ts`. This can be further optimized with SIMD.
-
-String serialization has more than tripled in performance (+360%). The algorithm was rewritten for less if statements and more traps.
-
-String deserialization was quadrupled from 3.4m ops to 14.8 ops (435%). It went from using `.replaceAll` to a specialized algorithm.
-
-Schema (object) parsing is being optimized on GitHub and should be at least doubled if not tripled. (Current speed of barely-optimized version is 6.9m ops) This is due to taking advantage of the types with a type map and eliminating extra checking.
-
-**Serialize Object (Vec3):** 6.7m ops/5s
-
-**Deserialize Object (Vec3):** 5.1m ops/5s
-
-**Serialize Array (int[]):** 6.6m ops/5s
-
-**Deserialize Array (int[]):** 8.6m ops/5s
-
-**Serialize String (5):** 5.9m ops/5s
-
-**Deserialize String (5):** 16.3m ops/5s
+Here are some benchmarks I took with `tinybench` (JavaScript) and `astral` (AssemblyScript).
+I took the benchmarks using the minimal runtime which doesn't call the Garbage Collector, so you may expect a 10% to 40% decrease from low to high throughput.
+
+Tests are run on Ubuntu/WSL2 with a AMD Ryzen 9 CPU
+
+JavaScript Results (TinyBench/NodeJS 19)
+┌───────────────────────────┬─────────────┬────────────────────┬──────────┐
+│         Task Name         │  ops / sec  │  Average Time(ns)  │  Margin  │
+├───────────────────────────┼─────────────┼────────────────────┼──────────┤
+│ 'Stringify Object (Vec3)' │  '817,816'  │      1222.76       │ '±3.55%' │
+│   'Parse Object (Vec3)'   │  '726,115'  │      1377.19       │ '±3.21%' │
+│ 'Stringify Number Array'  │ '1,104,036' │      905.77        │ '±6.48%' │
+│   'Parse Number Array'    │ '1,114,053' │      897.62        │ '±2.58%' │
+│    'Stringify String'     │ '1,565,716' │      638.69        │ '±2.04%' │
+│      'Parse String'       │  '69,568'   │      14374.22      │ '±2.55%' │
+└───────────────────────────┴─────────────┴────────────────────┴──────────┘
+
+AssemblyScript Results (Runtime Minimal)
+┌───────────────────────────┬─────────────┬────────────────────┬──────────┐
+│         Task Name         │  ops / sec  │  Average Time(ns)  │   Diff   │
+├───────────────────────────┼─────────────┼────────────────────┼──────────┤
+│ 'Stringify Object (Vec3)' │ '2,091,000' │       417.22       │  -805ns  │
+│   'Parse Object (Vec3)'   │ '1,780,000' │       539.02       │  -838ns  |
+│ 'Stringify Number Array'  │ '1,920,000' │       445.43       │  -460ns  │
+│   'Parse Number Array'    │ '1,660,000' │       597.17       │  -300ns  │
+│    'Stringify String'     │ '1,280,000' │       736.27       │   +97ns  │
+│      'Parse String'       │ '4,230,000' │       239.21       │ -14135ns │
+└───────────────────────────┴─────────────┴────────────────────┴──────────┘
 
 ## Issues
 

package/assembly/__benches__/as-json.ts

@@ -3,6 +3,13 @@ import { backSlashCode, quoteCode } from "../src/chars";
 import { atoi_fast, parseSciInteger, unsafeCharCodeAt } from "../src/util";
 import { HASH } from "util/hash";
 
+
+let last = 1;
+let char = 0;
+let inStr = false;
+let key: string | null = null;
+let pos = 0;
+
 @json
 class Vec3 {
   x: i32;
@@ -12,20 +19,15 @@ class Vec3 {
     data: string,
     to: Vec3
   ): Vec3 {
-    let last = 1;
-    let char = 0;
-    let inStr = false;
-    let key: string | null = null;
-    let pos = 0;
     for (; pos < data.length - 1; pos++) {
       char = unsafeCharCodeAt(data, pos);
       if (inStr === false && char === quoteCode) {
         if (key != null) {
-          if (unsafeCharCodeAt(key, 0) == 120) {
+          if (unsafeCharCodeAt(key!, 0) == 120) {
             to.x = parseSciInteger<i32>(data.substring(last, pos - 1));
-          } else if (unsafeCharCodeAt(key, 0) == 121) {
+          } else if (unsafeCharCodeAt(key!, 0) == 121) {
             to.y = parseSciInteger<i32>(data.substring(last, pos - 1));
-          } else if (unsafeCharCodeAt(key, 0) == 122) {
+          } else if (unsafeCharCodeAt(key!, 0) == 122) {
             to.z = parseSciInteger<i32>(data.substring(last, pos - 1));
           }
         }
@@ -41,14 +43,20 @@ class Vec3 {
       }
     }
     if (key != null) {
-      if (unsafeCharCodeAt(key, 0) == 120) {
+      if (unsafeCharCodeAt(key!, 0) == 120) {
         to.x = parseSciInteger<i32>(data.substring(last, pos - 1));
-      } else if (unsafeCharCodeAt(key, 0) == 121) {
+      } else if (unsafeCharCodeAt(key!, 0) == 121) {
         to.y = parseSciInteger<i32>(data.substring(last, pos - 1));
-      } else if (unsafeCharCodeAt(key, 0) == 122) {
+      } else if (unsafeCharCodeAt(key!, 0) == 122) {
         to.z = parseSciInteger<i32>(data.substring(last, pos - 1));
       }
     }
+
+    last = 1;
+    char = 0;
+    inStr = false;
+    key = null;
+    pos = 0;
     return to;
   }
 }
@@ -57,35 +65,8 @@ const vec: Vec3 = {
   x: 3,
   y: 1,
   z: 8,
-};
-
-@inline function istr8<
-  T extends number
->(int: T): string {
-  if (int >= 100) {
-    const str = changetype<string>(__new(6, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48);
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 2);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 4);
-    return str;
-  } else if (int >= 10) {
-    const str = changetype<string>(__new(4, idof<String>()));
-    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48);
-    store<u16>(changetype<usize>(str), (int % 10) + 48, 2);
-    return str;
-  } else {
-    const str = changetype<string>(__new(2, idof<String>()));
-    store<u16>(changetype<usize>(str), (int % 10) + 48);
-    return str;
-  }
 }
-
-bench("strint", () => {
-  blackbox<string>(istr8<i32>(123));
-});
-bench("tostr", () => {
-  blackbox<string>((<i32>123).toString());
-});
+/*
 bench("Stringify Object (Vec3)", () => {
   blackbox<string>(vec.__JSON_Serialize());
 });
@@ -99,10 +80,18 @@ bench("Stringify Number Array", () => {
   blackbox(JSON.stringify<i32[]>([1, 2, 3]));
 });
 
-bench("Parse Array", () => {
+bench("Parse Number Array", () => {
   blackbox(JSON.parse<i32[]>(blackbox("[1,2,3]")));
 });
 
+bench("Stringify String", () => {
+  blackbox(JSON.stringify(blackbox('Hello "World!')));
+});
+*/
+bench("Parse String", () => {
+  blackbox(JSON.parse<string>(blackbox('"Hello "World!"')));
+});
+/*
 bench("Stringify Boolean Array", () => {
   blackbox(JSON.stringify<boolean[]>([true, false, true]));
 });
@@ -111,14 +100,6 @@ bench("Stringify String Array", () => {
   blackbox(JSON.stringify<string[]>(["a", "b", "c"]));
 });
 
-bench("Stringify String", () => {
-  blackbox(JSON.stringify(blackbox('Hello "World!')));
-});
-
-bench("Parse String", () => {
-  blackbox(JSON.parse<string>(blackbox('"Hello "World!"')));
-});
-
 bench("Stringify Boolean", () => {
   blackbox(JSON.stringify(blackbox(true)));
 });
@@ -142,3 +123,4 @@ bench("Stringify Float", () => {
 bench("Parse Float", () => {
   blackbox(JSON.parse<f32>(blackbox("3.14")));
 });
+*/

package/assembly/__tests__/as-json.spec.ts

@@ -1,13 +1,4 @@
 import { JSON } from "..";
-import {
-  u128,
-  u128Safe,
-  u256,
-  u256Safe,
-  i128,
-  i128Safe,
-  i256Safe,
-} from "as-bignum/assembly";
 function canSerde<T>(data: T): void {
   const serialized = JSON.stringify<T>(data);
   const deserialized = JSON.stringify<T>(JSON.parse<T>(serialized));

package/bench.js

@@ -0,0 +1,67 @@
+import { Bench } from "tinybench";
+// Trying a new benchmarking lib.
+// It seems to not warmup long at all, so its probably bad.
+// benchmark will probably be best here
+
+// JavaScript Results
+// ┌─────────┬───────────────────────────┬─────────────┬────────────────────┬──────────┬─────────┐
+// │ (index) │         Task Name         │  ops / sec  │  Average Time(ns)  │  Margin  │ Samples │
+// ├─────────┼───────────────────────────┼─────────────┼────────────────────┼──────────┼─────────┤
+// │    0    │ 'Stringify Object (Vec3)' │  '817,816'  │      1222.76       │ '±3.55%' │  81782  │
+// │    1    │   'Parse Object (Vec3)'   │  '726,115'  │      1377.19       │ '±3.21%' │  72612  │
+// │    2    │ 'Stringify Number Array'  │ '1,104,036' │      905.77        │ '±6.48%' │ 110404  │
+// │    3    │   'Parse Number Array'    │ '1,114,053' │      897.62        │ '±2.58%' │ 111406  │
+// │    4    │    'Stringify String'     │ '1,565,716' │      638.69        │ '±2.04%' │ 156572  │
+// │    5    │      'Parse String'       │  '69,568'   │      14374.22      │ '±2.55%' │  6957   │
+// └─────────┴───────────────────────────┴─────────────┴────────────────────┴──────────┴─────────┘
+
+// AssemblyScript Results (Runtime Minimal)
+// ┌─────────┬───────────────────────────┬─────────────┬────────────────────┬──────────┬─────────┐
+// │ (index) │         Task Name         │  ops / sec  │  Average Time(ns)  │   Diff   │ Samples │
+// ├─────────┼───────────────────────────┼─────────────┼────────────────────┼──────────┼─────────┤
+// │    0    │ 'Stringify Object (Vec3)' │ '2,091,000' │       417.22       │  -805ns  │ ------- │
+// │    1    │   'Parse Object (Vec3)'   │ '1,780,000' │       539.02       │  -838ns  │ ------- |
+// │    2    │ 'Stringify Number Array'  │ '1,920,000' │       445.43       │  -460ns  │ ------- │
+// │    3    │   'Parse Number Array'    │ '1,660,000' │       597.17       │  -300ns  │ ------- │
+// │    4    │    'Stringify String'     │ '1,280,000' │       736.27       │   +97ns  │ ------- │
+// │    5    │      'Parse String'       │ '4,230,000' │       239.21       │ -14135ns │ ------- │
+// └─────────┴───────────────────────────┴─────────────┴────────────────────┴──────────┴─────────┘
+
+const vec = {
+    x: 3,
+    y: 1,
+    z: 8,
+};
+
+let data;
+
+const bench = new Bench({ time: 100 })
+
+    .add("Stringify Object (Vec3)", () => {
+        data = JSON.stringify(vec);
+    })
+
+    .add("Parse Object (Vec3)", () => {
+        data = JSON.parse('{"x":0,"y":0,"z":0}');
+    })
+
+    .add("Stringify Number Array", () => {
+        data = JSON.stringify([1, 2, 3]);
+    })
+
+    .add("Parse Number Array", () => {
+        data = JSON.parse("[1,2,3]");
+    })
+
+    .add("Stringify String", () => {
+        data = JSON.stringify('Hello "World!');
+    })
+
+    .add("Parse String", () => {
+        data = JSON.parse('"Hello "World!"');
+    })
+    .todo("unimplemented .add");
+
+await bench.run();
+
+console.table(bench.table());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.5.42",
+  "version": "0.5.50",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -14,7 +14,7 @@
   "license": "MIT",
   "scripts": {
     "aspect": "asp",
-    "bench:astral": "astral -Ospeed --noAssert --uncheckedBehavior always",
+    "bench:astral": "astral -Ospeed --noAssert --uncheckedBehavior always --runtime minimal",
     "build:test": "asc assembly/test.ts --target test --runtime stub",
     "build:transform": "tsc -p ./transform",
     "test:wasmtime": "wasmtime ./build/test.wasm",
@@ -29,11 +29,11 @@
     "assemblyscript": "^0.27.1",
     "assemblyscript-prettier": "^1.0.7",
     "prettier": "^2.8.4",
+    "tinybench": "^2.5.0",
     "typescript": "^4.9.5",
     "visitor-as": "^0.11.4"
   },
   "dependencies": {
-    "as-bignum": "^0.2.23",
     "as-string-sink": "^0.5.3",
     "as-variant": "^0.4.1"
   },