tweaks

gfx · gfx · commit fdd2f28662af · 2019-08-02T14:06:21.000+09:00
diff --git a/benchmark/key-decoder.ts b/benchmark/key-decoder.ts
@@ -0,0 +1,49 @@
+/* eslint-disable no-console */
+import { utf8EncodeJs, utf8Count, utf8DecodeJs, utf8DecodeTD } from "../src/utils/utf8";
+import { utf8DecodeWasm } from "../src/wasmFunctions";
+
+// @ts-ignore
+import Benchmark from "benchmark";
+import { CachedKeyDecoder } from "../src/CachedKeyDecoder";
+
+type InputType = {
+  bytes: Uint8Array;
+  byteLength: number;
+  str: string;
+};
+
+const keys: Array<InputType> = Object.keys(require("./benchmark-from-msgpack-lite-data.json")).map((str) => {
+  const byteLength = utf8Count(str);
+  const bytes = new Uint8Array(new ArrayBuffer(byteLength));
+
+  utf8EncodeJs(str, bytes, 0);
+
+  return { bytes, byteLength, str };
+});
+
+for (const dataSet of [keys]) {
+  const keyDecoder = new CachedKeyDecoder();
+
+  const suite = new Benchmark.Suite();
+
+  suite.add("utf8DecodeJs", () => {
+    for (const data of dataSet) {
+      if (utf8DecodeJs(data.bytes, 0, data.byteLength) !== data.str) {
+        throw new Error("wrong result!");
+      }
+    }
+  });
+
+  suite.add("CachedKeyDecoder", () => {
+    for (const data of dataSet) {
+      if (keyDecoder.decode(data.bytes, 0, data.byteLength) !== data.str) {
+        throw new Error("wrong result!");
+      }
+    }
+  });
+  suite.on("cycle", (event: any) => {
+    console.log(String(event.target));
+  });
+
+  suite.run();
+}
diff --git a/src/CachedKeyDecoder.ts b/src/CachedKeyDecoder.ts
@@ -3,7 +3,6 @@ import { utf8DecodeJs } from "./utils/utf8";
 interface KeyCacheRecord {
   readonly bytes: Uint8Array;
   readonly value: string;
-  hits: number;
 }
 
 const DEFAULT_MAX_KEY_LENGTH = 16;
@@ -39,19 +38,21 @@ export class CachedKeyDecoder {
           continue FIND_CHUNK;
         }
       }
-
-      record.hits++;
       return record.value;
     }
     return null;
   }
 
   private store(bytes: Uint8Array, value: string) {
     const records = this.caches[bytes.length - 1];
-    const hits = 1;
-    records.unshift({ bytes, value, hits });
-    if (records.length > this.maxLengthPerKey) {
-      records.pop();
+    const record: KeyCacheRecord = { bytes, value };
+
+    if (records.length >= this.maxLengthPerKey) {
+      // `records` are full!
+      // Set `record` to a randomized position.
+      records[(Math.random() * records.length) | 0] = record;
+    } else {
+      records.push(record);
     }
   }
 
diff --git a/test/CachedKeyDecoder.test.ts b/test/CachedKeyDecoder.test.ts
@@ -35,16 +35,17 @@ describe("CachedKeyDecoder", () => {
     });
 
     it("decodes strings with purging records", () => {
-      const decoder = new CachedKeyDecoder(16, 2);
+      const decoder = new CachedKeyDecoder(16, 4);
 
-      assert.deepStrictEqual(tryDecode(decoder, "foo"), "foo");
-      assert.deepStrictEqual(tryDecode(decoder, "bar"), "bar");
+      for (let i = 0; i < 100; i++) {
+        assert.deepStrictEqual(tryDecode(decoder, "foo1"), "foo1");
+        assert.deepStrictEqual(tryDecode(decoder, "foo2"), "foo2");
+        assert.deepStrictEqual(tryDecode(decoder, "foo3"), "foo3");
+        assert.deepStrictEqual(tryDecode(decoder, "foo4"), "foo4");
+        assert.deepStrictEqual(tryDecode(decoder, "foo5"), "foo5");
+      }
 
-      // the next `tryDecode()` should purge the cache of "foo"
-      assert.deepStrictEqual(tryDecode(decoder, "baz"), "baz");
-
-      // with newly created an internal cache record
-      assert.deepStrictEqual(tryDecode(decoder, "foo"), "foo");
+      console.dir(decoder, { depth: 100 });
     });
   });
 

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@ import { utf8DecodeJs } from "./utils/utf8";`
`3`	`3`	`interface KeyCacheRecord {`
`4`	`4`	`readonly bytes: Uint8Array;`
`5`	`5`	`readonly value: string;`
`6`		`- hits: number;`
`7`	`6`	`}`
`8`	`7`
`9`	`8`	`const DEFAULT_MAX_KEY_LENGTH = 16;`
`@@ -39,19 +38,21 @@ export class CachedKeyDecoder {`
`39`	`38`	`continue FIND_CHUNK;`
`40`	`39`	`}`
`41`	`40`	`}`
`42`		`-`
`43`		`- record.hits++;`
`44`	`41`	`return record.value;`
`45`	`42`	`}`
`46`	`43`	`return null;`
`47`	`44`	`}`
`48`	`45`
`49`	`46`	`private store(bytes: Uint8Array, value: string) {`
`50`	`47`	`const records = this.caches[bytes.length - 1];`
`51`		`- const hits = 1;`
`52`		`- records.unshift({ bytes, value, hits });`
`53`		`- if (records.length > this.maxLengthPerKey) {`
`54`		`- records.pop();`
	`48`	`+ const record: KeyCacheRecord = { bytes, value };`
	`49`	`+`
	`50`	`+ if (records.length >= this.maxLengthPerKey) {`
	`51`	+ // `records` are full!
	`52`	+ // Set `record` to a randomized position.
	`53`	`+ records[(Math.random() * records.length) \| 0] = record;`
	`54`	`+ } else {`
	`55`	`+ records.push(record);`
`55`	`56`	`}`
`56`	`57`	`}`
`57`	`58`