a few version for comparison

Author: sliemeobn

Runtime/bench/_version2.ts

@@ -2,66 +2,74 @@ import { globalVariable } from "../src/find-global.js";
 import { ref } from "../src/types.js";
 
 export class JSObjectSpace_v2 {
-    private _entryByValue: Map<any, { id: number; rc: number }>;
-    private _values: (any | undefined)[];
-    private _refCounts: number[];
+    private _idByValue: Map<any, number>;
+    private _valueById: Record<number, any>;
+    private _refCountById: Record<number, number | undefined>;
     private _nextRef: number;
 
     constructor() {
-        this._values = [];
-        this._values[0] = undefined;
-        this._values[1] = globalVariable;
-
-        this._entryByValue = new Map();
-        this._entryByValue.set(globalVariable, { id: 1, rc: 1 });
-
-        this._refCounts = [];
-        this._refCounts[0] = 0;
-        this._refCounts[1] = 1;
+        this._idByValue = new Map();
+        this._idByValue.set(globalVariable, 1);
+        this._valueById = Object.create(null);
+        this._refCountById = Object.create(null);
+        this._valueById[1] = globalVariable;
+        this._refCountById[1] = 1;
 
         // 0 is invalid, 1 is globalThis.
         this._nextRef = 2;
     }
 
     retain(value: any) {
-        const entry = this._entryByValue.get(value);
-        if (entry) {
-            entry.rc++;
-            this._refCounts[entry.id]++;
-            return entry.id;
+        const id = this._idByValue.get(value);
+        if (id !== undefined) {
+            this._refCountById[id]!++;
+            return id;
         }
 
-        const id = this._nextRef++;
-        this._values[id] = value;
-        this._refCounts[id] = 1;
-        this._entryByValue.set(value, { id, rc: 1 });
-        return id;
+        const newId = this._nextRef++;
+        this._valueById[newId] = value;
+        this._refCountById[newId] = 1;
+        this._idByValue.set(value, newId);
+        return newId;
     }
 
     retainByRef(ref: ref) {
-        return this.retain(this.getObject(ref));
+        const rc = this._refCountById[ref];
+        if (rc === undefined) {
+            throw new ReferenceError(
+                "Attempted to retain invalid reference " + ref,
+            );
+        }
+        this._refCountById[ref] = rc + 1;
+        return ref;
     }
 
     release(ref: ref) {
-        const value = this._values[ref];
-        const entry = this._entryByValue.get(value)!;
-        entry.rc--;
-        this._refCounts[ref]--;
-        if (entry.rc != 0) return;
+        const rc = this._refCountById[ref];
+        if (rc === undefined) {
+            throw new ReferenceError(
+                "Attempted to release invalid reference " + ref,
+            );
+        }
+        const next = rc - 1;
+        if (next !== 0) {
+            this._refCountById[ref] = next;
+            return;
+        }
 
-        this._entryByValue.delete(value);
-        // Keep IDs monotonic; clear slot and leave possible holes.
-        this._values[ref] = undefined;
-        this._refCounts[ref] = 0;
+        const value = this._valueById[ref];
+        this._idByValue.delete(value);
+        delete this._valueById[ref];
+        delete this._refCountById[ref];
     }
 
     getObject(ref: ref) {
-        const value = this._values[ref];
-        if (value === undefined) {
+        const rc = this._refCountById[ref];
+        if (rc === undefined) {
             throw new ReferenceError(
                 "Attempted to read invalid reference " + ref,
             );
         }
-        return value;
+        return this._valueById[ref];
     }
 }

Runtime/bench/_version3.ts

@@ -0,0 +1,75 @@
+import { globalVariable } from "../src/find-global.js";
+import { ref } from "../src/types.js";
+
+export class JSObjectSpace_v3 {
+    private _idByValue: Map<any, number>;
+    private _valueById: Map<number, any>;
+    private _refCountById: Map<number, number>;
+    private _nextRef: number;
+
+    constructor() {
+        this._idByValue = new Map();
+        this._idByValue.set(globalVariable, 1);
+        this._valueById = new Map();
+        this._refCountById = new Map();
+        this._valueById.set(1, globalVariable);
+        this._refCountById.set(1, 1);
+
+        // 0 is invalid, 1 is globalThis.
+        this._nextRef = 2;
+    }
+
+    retain(value: any) {
+        const id = this._idByValue.get(value);
+        if (id !== undefined) {
+            this._refCountById.set(id, this._refCountById.get(id)! + 1);
+            return id;
+        }
+
+        const newId = this._nextRef++;
+        this._valueById.set(newId, value);
+        this._refCountById.set(newId, 1);
+        this._idByValue.set(value, newId);
+        return newId;
+    }
+
+    retainByRef(ref: ref) {
+        const rc = this._refCountById.get(ref);
+        if (rc === undefined) {
+            throw new ReferenceError(
+                "Attempted to retain invalid reference " + ref,
+            );
+        }
+        this._refCountById.set(ref, rc + 1);
+        return ref;
+    }
+
+    release(ref: ref) {
+        const rc = this._refCountById.get(ref);
+        if (rc === undefined) {
+            throw new ReferenceError(
+                "Attempted to release invalid reference " + ref,
+            );
+        }
+        const next = rc - 1;
+        if (next !== 0) {
+            this._refCountById.set(ref, next);
+            return;
+        }
+
+        const value = this._valueById.get(ref);
+        this._idByValue.delete(value);
+        this._valueById.delete(ref);
+        this._refCountById.delete(ref);
+    }
+
+    getObject(ref: ref) {
+        const rc = this._refCountById.get(ref);
+        if (rc === undefined) {
+            throw new ReferenceError(
+                "Attempted to read invalid reference " + ref,
+            );
+        }
+        return this._valueById.get(ref);
+    }
+}

Runtime/bench/bench-runner.ts

@@ -6,6 +6,7 @@
 import { JSObjectSpace } from "../src/object-heap.js";
 import { JSObjectSpaceOriginal } from "./_original.js";
 import { JSObjectSpace_v2 } from "./_version2.js";
+import { JSObjectSpace_v3 } from "./_version3.js";
 
 export interface HeapLike {
     retain(value: unknown): number;
@@ -96,6 +97,7 @@ function main() {
     const implementations: Array<{ name: string; Heap: new () => HeapLike }> = [
         { name: "JSObjectSpaceOriginal", Heap: JSObjectSpaceOriginal },
         { name: "JSObjectSpace_v2 (ref++, single map)", Heap: JSObjectSpace_v2 },
+        { name: "JSObjectSpace_v3 (ref++, all maps)", Heap: JSObjectSpace_v3 },
         { name: "JSObjectSpace (current)", Heap: JSObjectSpace }
     ];