json-as 0.9.8-b → 0.9.9-a

package/CHANGELOG

@@ -15,10 +15,14 @@ v0.9.7 - Update testing framework and readme logo
 v0.9.8 - Update dependencies
 v0.9.8a - Fix #80 - Empty Maps were not serialized to {}, instead, threw memory out of bounds
 v0.9.8b - Fix #81 - Revert transform
-[UNRELEASED] v0.9.9
+v0.9.9 - Fix #82 - Initialize maps
+v0.9.9a - Remove extraneous logs from transform
+
+[UNRELEASED] v1.0.0
  - Allow nullable primitives
  - Port over JSON.Value
  - Performance improvements
+ - Add SIMD support
  - Introduce options
  - Custom serializers
  - Support arbitrary-length integers (@hypercubed/as-mpz)

package/README.md

@@ -3,7 +3,7 @@
  __|  ||   __||     ||   | | ___ |  _  ||   __|
 |  |  ||__   ||  |  || | | ||___||     ||__   |
 |_____||_____||_____||_|___|     |__|__||_____|
-v0.9.8b
+v0.9.9a
 </pre>
 </h5>
 
@@ -187,16 +187,17 @@ Below are benchmark results comparing JavaScript's built-in JSON implementation
 
 My library beats JSON (written in C++) on all counts *and*, I see many places where I can pull at least a 60% uplift in performance if I implement it.
 
+Note: SIMD is in-development and only available on the `v1` branch on GitHub
 
 Serialization Benchmarks:
 
-| Value                      | JavaScript (ops/s) | JSON-as (ops/s) | Difference |
-|----------------------------|--------------------|-----------------|------------|
-| "hello world"              | 28,629,598         | 64,210,666      | + 124%     |
-| 12345                      | 31,562,431         | 56,329,066      | + 78%      |
-| 1.2345                     | 15,977,278         | 20,322,939      | + 27%      |
-| [[],[[]],[[],[[]]]]        | 8,998,624          | 34,453,102      | + 283%     |
-| { x: f64, y: f64, z: f64 } | 15,583,686         | 17,604,821      | + 12%      |
+| Value                      | JavaScript (ops/s) | JSON-AS (ops/s)    | JSON-AS (Pages)     | JSON-AS (SIMD+Pages)| Max Throughput |
+|----------------------------|--------------------|--------------------|---------------------|---------------------|----------------|
+| "hello world"              | 7,124,361          | 44,290,480 (6.2x)  | 73,601,235 (10.3x)  | NOT IMPLEMENTED     | 1.91 GB/s      | 
+| 12345                      | 9,611,677          | 66,900,642 (6.9x)  | 145,924,333 (15.2x) | NOT IMPLEMENTED     | 0.58 GB/s      |
+| 1.2345                     | 7,227,259          | 20,322,939 (2.8x)  | NOT IMPLEMENTED     | NOT IMPLEMENTED     | 0.16 GB/s      |
+| [[],[[]],[[],[[]]]]        | 5,655,429          | 34,453,102 (6.0x)  | NOT IMPLEMENTED     | NOT IMPLEMENTED     | 1.32 GB/s      |
+| { x: f64, y: f64, z: f64 } | 3,878,604          | 44,557,996 (11.5x) | 113,203,242 (29.2x) | 172,023,231 (44.4x) | 8.61 GB/s      |
 
 
 

package/assembly/deserialize/map.ts

@@ -72,6 +72,8 @@ import { deserializeFloat } from "./float";
                     depth--;
                     if (depth === 0) {
                         ++objectValueIndex;
+                        console.log("Index: " + nameof<indexof<T>>());
+                        console.log("Value: " + nameof<valueof<T>>());
                         map.set(deserializeMapKey<indexof<T>>(key), JSON.parse<valueof<T>>(data.slice(outerLoopIndex, objectValueIndex)));
                         outerLoopIndex = objectValueIndex;
                         isKey = false;

package/assembly/test.ts

@@ -1,14 +1,78 @@
 import { JSON } from "json-as/assembly";
-import * as console from "as-console";
+
+@json
+class TokenMetaData {
+    id: u64;
+    name: string;
+    uri: string;
+
+    constructor(id: u64, name: string, uri: string) {
+        this.id = id;
+        this.name = name;
+        this.uri = uri;
+    }
+}
+
 @json
-class Yo {
-  map: Map<string, u64>;
+class NonFungibleToken {
+    owner: string = "";
+    counter: u64 = 0;
+    tokens: Map<u64, TokenMetaData> = new Map<u64, TokenMetaData>();
+    owners: Map<u64, string> = new Map<u64, string>();
+    balances: Map<string, u64[]> = new Map<string, u64[]>();
+
+    constructor() { }
+
+    mint(name: string, uri: string, toAddress: string): u64 {
+        this.counter += 1;
+        const id = this.counter;
+
+        const tokenMetaData = new TokenMetaData(id, name, uri);
+
+        this.tokens.set(id, tokenMetaData);
+        this.owners.set(id, toAddress);
+
+        if (!this.balances.has(toAddress)) {
+            this.balances.set(toAddress, []);
+        }
 
-  constructor() {
-    this.map = new Map();
-  }
+        this.balances.get(toAddress).push(id);
+
+        return id;
+    }
+}
+function readStringFromMemory(ptr: usize): string {
+    let len: i32 = load<u32>(ptr)
+    let buffer = new Uint8Array(len);
+
+    for (let i = 0; i < len; ++i) {
+        buffer[i] = load<u8>(ptr + 4 + i);
+    }
+
+    let s = String.UTF8.decode(buffer.buffer);
+    return s
+}
+
+function getLengthPrefixedString(s: string): ArrayBuffer {
+    let stringBuf = Uint8Array.wrap(String.UTF8.encode(s))
+    let newLen = stringBuf.byteLength
+    let buffer = new ArrayBuffer(4 + newLen);
+    let dataView = new DataView(buffer);
+
+    dataView.setUint32(0, newLen, true);
+
+    for (let i = 0; i < newLen; ++i) {
+        dataView.setInt8(4 + i, stringBuf[i])
+    }
+
+    return buffer
 }
 
-let y = new Yo();
-y.map.set("bhavya", 3000);
-console.log(JSON.stringify(y));
+const s1 = getLengthPrefixedString("hello world");
+console.log(Uint8Array.wrap(s1).join(" "));
+const s2 = readStringFromMemory(changetype<usize>(s1));
+console.log(s2);
+
+let state = JSON.parse<NonFungibleToken>('{"owner":"","counter":1,"tokens":{"1":{"id":1,"name":"foo","uri":"bar"}},"owners":{"1":"baz"},"balances":{"baz":[1]}}');
+state.mint("foo", "bar", "baz")
+console.log(JSON.stringify(state))