json-as 0.9.20 → 0.9.22

package/assembly/serialize/string.ts

@@ -9,18 +9,225 @@ import {
 } from "../custom/chars";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
 import { bs } from "../custom/bs";
-import { _intTo16, intTo16 } from "../custom/util";
+import { _intTo16, intTo16, unsafeCharCodeAt } from "../custom/util";
+import { Sink } from "../custom/sink";
 
-// @ts-ignore: Decorator valid here
+function needsEscaping(data: string): bool {
+    let len = data.length;
+
+    // if (len < 16) {
+    //     while (len--) {
+    //         const char = load<u16>(changetype<usize>(data) + len);
+    //         if (char == 34 || char == 92 || char <= 31) {
+    //             return true;
+    //         }
+    //     }
+    //     return false;
+    // }
+
+    let running = v128.splat<i64>(0);
+    //let i = 0;
+
+    //while (i + 15 < len) {
+    let w = v128.load(changetype<usize>(data));
+    running = v128.or(running, v128.eq<i16>(w, i16x8.splat(34)));
+    running = v128.or(running, v128.eq<i16>(w, i16x8.splat(92)));
+
+    let subtracted = v128.sub<i16>(w, i8x16.splat(31));
+    running = v128.or(running, v128.eq<i16>(subtracted, v128.splat<i64>(0)));
+    //i += 16;
+    //}
+
+    return v128.any_true(running);
+}
+
+/**
+ * A prototype SIMD implementation for string serialization which can only work in 128-byte (or 16 chars with wtf-16).
+ * 
+ * A faster version could perhaps look like the following:
+ */
+// @ts-ignore: Decorator
+@inline export function serialize_simd_v1(src: string, dst: usize): void {
+    let src_ptr = changetype<usize>(src);
+    let dst_ptr = changetype<usize>(dst) + 2;
+
+    store<u16>(changetype<usize>(dst), 34); /* " */
+
+    const src_end = src_ptr + u32(src.length << 1);
+    const src_end_15 = src_end - 15;
+
+    while (src_ptr < src_end_15) {
+        const currentBlock = v128.load(src_ptr);
+        const backslash_indices = i16x8.eq(currentBlock, i16x8.splat(92));
+        const quote_indices = i16x8.eq(currentBlock, i16x8.splat(34));
+        const concat_indices = v128.or(quote_indices, backslash_indices);
+
+        const escape_indices = i16x8.lt_u(currentBlock, i16x8.splat(32));
+
+        if (v128.any_true(v128.or(escape_indices, concat_indices))) {
+            const mask = i16x8.bitmask(concat_indices);
+
+            const anomalies = popcnt(mask);
+            const start_index = (clz(mask) & ~1) + 2 // This essentially floors to the nearest even integer
+            if (anomalies === 1) {
+                memory.copy(dst_ptr, src_ptr, start_index >> 1);
+                store<u16>(dst_ptr + start_index, 34);
+                memory.copy(dst_ptr + start_index + 2, src_ptr + start_index, (32 - start_index) >> 1)
+            }
+
+            if (v128.any_true(escape_indices)) {
+
+            }
+            dst_ptr += 16;
+            src_ptr += 16;
+        } else {
+            v128.store(dst_ptr, currentBlock);
+            src_ptr += 16;
+            dst_ptr += 16;
+        }
+    }
+}
+
+const back_slash_reg = i16x8.splat(92); // "\"
+const quote_reg = i16x8.splat(34); // "\""
+
+// @ts-ignore: Decorator
+@inline export function serialize_simd_v2(src: string, dst: usize): void {
+    let src_ptr = changetype<usize>(src);
+    let dst_ptr = changetype<usize>(dst);
+
+    let i = 0;
+    const len = src.length;
+
+    while (i < len) {
+        const block = v128.load16x4_u(src_ptr);
+        console.log("block: " + prt(block));
+        const backslash_mask = i16x8.eq(block, back_slash_reg);
+        const quote_mask = i16x8.eq(block, quote_reg);
+        const is_quote_or_backslash = v128.or(quote_mask, backslash_mask);
+        console.log("mask:  " + prt10(is_quote_or_backslash))
+        
+
+        // store<v128>(dst_ptr, expanded);
+        src_ptr += 8;
+        dst_ptr += 16;
+        i += 8;
+    }
+}
+
+function prt(obj: v128): string {
+    let out = "";
+    out += i16x8.extract_lane_u(obj, 0).toString() + " ";
+    out += i16x8.extract_lane_u(obj, 1).toString() + " ";
+    out += i16x8.extract_lane_u(obj, 2).toString() + " ";
+    out += i16x8.extract_lane_u(obj, 3).toString() + " ";
+    out += i16x8.extract_lane_u(obj, 4).toString() + " ";
+    out += i16x8.extract_lane_u(obj, 5).toString() + " ";
+    out += i16x8.extract_lane_u(obj, 6).toString() + " ";
+    out += i16x8.extract_lane_u(obj, 7).toString();
+    return out;
+}
+
+function prt10(obj: v128): string {
+    let out = "";
+    out += (i16x8.extract_lane_u(obj, 0) ? "1" : "0") + " ";
+    out += (i16x8.extract_lane_u(obj, 1) ? "1" : "0") + " ";
+    out += (i16x8.extract_lane_u(obj, 2) ? "1" : "0") + " ";
+    out += (i16x8.extract_lane_u(obj, 3) ? "1" : "0") + " ";
+    out += (i16x8.extract_lane_u(obj, 4) ? "1" : "0") + " ";
+    out += (i16x8.extract_lane_u(obj, 5) ? "1" : "0") + " ";
+    out += (i16x8.extract_lane_u(obj, 6) ? "1" : "0") + " ";
+    out += i16x8.extract_lane_u(obj, 7) ? "1" : "0";
+    return out;
+}
+
+function vis(src_ptr: usize, mask: i32): void {
+    let chars = "";
+    let bits = "";
+    for (let i = 0; i < 8; i++) {
+        const char = load<u16>(src_ptr + (i << 1));
+        const bit = (mask >> i) & 1;
+        chars += String.fromCharCode(char) + " ";
+        bits += bit.toString() + " ";
+    }
+    console.log(chars);
+    console.log(bits);
+}
+
+// @ts-ignore: Decorator
 @inline export function serializeString(data: string): string {
+    if (!needsEscaping(data)) {
+        return "\"" + data + "\"";
+    }
+
+    if (data.length === 0) {
+        return "\"\"";
+    }
+    let result = Sink.fromString("\"");
+
+    let last: i32 = 0;
+    for (let i = 0; i < data.length; i++) {
+        const char = unsafeCharCodeAt(<string>data, i);
+        if (char === 34 || char === 92) {
+            result.write(<string>data, last, i);
+            result.writeCodePoint(92);
+            last = i;
+        } else if (char < 16) {
+            result.write(<string>data, last, i);
+            last = i + 1;
+            switch (char) {
+                case 8: {
+                    result.write("\\b");
+                    break;
+                }
+                case 9: {
+                    result.write("\\t");
+                    break;
+                }
+                case 10: {
+                    result.write("\\n");
+                    break;
+                }
+                case 12: {
+                    result.write("\\f");
+                    break;
+                }
+                case 13: {
+                    result.write("\\r");
+                    break;
+                }
+                default: {
+                    // all chars 0-31 must be encoded as a four digit unicode escape sequence
+                    // \u0000 to \u000f handled here
+                    result.write("\\u000");
+                    result.write(char.toString(16));
+                    break;
+                }
+            }
+        } else if (char < 32) {
+            result.write(<string>data, last, i);
+            last = i + 1;
+            // all chars 0-31 must be encoded as a four digit unicode escape sequence
+            // \u0010 to \u001f handled here
+            result.write("\\u00");
+            result.write(char.toString(16));
+        }
+    }
+    result.write(<string>data, last);
+    result.writeCodePoint(34);
+    return result.toString();
+}
+// @ts-ignore: Decorator valid here
+@inline export function serializeString_BS(data: string): void {
     const len = data.length << 1;
     if (len === 0) {
         bs.write_32(2228258); /* "" */
-        return bs.out<string>();
+        return;
     }
 
     bs.write_16(QUOTE);
 
+
     let last: i32 = 0;
     for (let i = 0; i < len; i += 2) {
         const char = load<u16>(changetype<usize>(data) + i);
@@ -78,7 +285,12 @@ import { _intTo16, intTo16 } from "../custom/util";
             last = i;
         }
     }
-    bs.write_s_se_u(<string>data, last, changetype<OBJECT>(changetype<usize>(data) - TOTAL_OVERHEAD).rtSize);
-    bs.write_16(QUOTE);
-    return bs.out<string>();
+
+    if (last === 0) {
+        bs.write_s(data);
+        bs.write_16(QUOTE)
+    } else {
+        bs.write_s_se(<string>data, last, changetype<OBJECT>(changetype<usize>(data) - TOTAL_OVERHEAD).rtSize);
+        bs.write_16(QUOTE);
+    }
 }

package/assembly/test.ts

@@ -1,29 +1,34 @@
-// import { JSON } from ".";
-import { JSON } from ".";
-@json
-class Message {
-  @alias("raw_foo")
-  public raw: JSON.Raw = "[1,2,3]";
-  constructor(role: string, content: string) {
-    this._role = role;
-    this.content = content;
-  }
+import { JSON } from "."
 
-  @alias("role")
-  protected _role: string;
-
-  get role(): string {
-    return this._role;
-  }
+@json
+class Vec3<T> {
+  public x: i32 = 0;
+  public y: i32 = 0;
+  public z: T;
+}
 
-  content: string;
+@json
+class Base {
+  public bam: string = "harekogkeorgke"
 }
 
 @json
-class UserMessage extends Message {
-  constructor(content: string) {
-    super("user", content);
+class Foo extends Base {
+  public bar: JSON.Raw = "\"this is ok\'"
+  public baz: i32 = 0;
+  public pos: Vec3<Vec3<i32>> = {
+    x: 1,
+    y: 2,
+    z: {
+      x: 1,
+      y: 2,
+      z: 3
+    }
   }
+  // ^ this is not okay
 }
-console.log(JSON.stringify(new Message("user", "foo")));
-console.log(JSON.stringify(new UserMessage("foo")));
+
+const serialized = JSON.stringify(new Foo());
+console.log("Serialized: " + serialized);
+const deserialized = JSON.parse<Foo>(serialized);
+console.log("Deserialized: " + JSON.stringify(deserialized));

package/bench.js

@@ -67,7 +67,7 @@ const bench = new Bench({ time: 1000 })
     })
 */
   .add("Parse String", () => {
-    data = JSON.parse("[[],[[]],[[],[[]]]]");
+    data = JSON.stringify('hello "world abc');
   })
   .todo("unimplemented .add");
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.9.20",
+  "version": "0.9.22",
   "description": "The only JSON library you'll need for AssemblyScript. SIMD enabled",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -11,16 +11,15 @@
     "Frankk Taylor",
     "lekiano",
     "Florian Guitton",
-    "Matt Johnson-Pint"
+    "Matt Johnson-Pint",
+    "Tomáš Hromada"
   ],
   "license": "MIT",
   "scripts": {
     "test": "ast test && rm -rf ./build/",
     "pretest": "rm -rf ./build/ && ast build",
-    "build:test": "rm -rf ./build/ && JSON_DEBUG=true asc assembly/test.ts --transform ./transform -o ./build/test.wasm",
-    "build:bench": "asc bench/benchmark.ts -o bench/benchmark.wasm --transform ./transform --optimizeLevel 3 --shrinkLevel 0 --converge --noAssert --uncheckedBehavior always --runtime stub --enable simd",
-    "bench:wasmtime": "wasmtime ./bench/benchmark.wasm",
-    "bench:wasmer": "wasmer --llvm ./bench/benchmark.wasm",
+    "bench": "astral --enable simd --runtime stub",
+    "build:test": "rm -rf ./build/ && asc assembly/test.ts --transform ./transform -o ./build/test.wasm --enable simd --enable relaxed-simd",
     "build:transform": "tsc -p ./transform",
     "test:wasmtime": "wasmtime ./build/test.wasm",
     "test:wavm": "wavm run ./build/test.wasm",
@@ -29,6 +28,7 @@
     "prettier": "prettier -w ."
   },
   "devDependencies": {
+    "@as-tral/cli": "^3.0.2",
     "@assemblyscript/wasi-shim": "^0.1.0",
     "@types/node": "^20.14.12",
     "as-bench": "^0.0.0-alpha",
@@ -44,7 +44,8 @@
     "visitor-as": "^0.11.4"
   },
   "dependencies": {
-    "as-virtual": "^0.2.0"
+    "as-virtual": "^0.2.0",
+    "chalk": "^5.3.0"
   },
   "overrides": {
     "assemblyscript": "$assemblyscript"