@daneren2005/shared-memory-objects 1.0.0 → 1.2.0

package/dist/shared-list.js

@@ -0,0 +1,125 @@
+import { getPointer as e, loadPointer as t, loadRawPointer as n, replaceRawPointer as r, storePointer as i, storeRawPointer as a } from "./utils/pointer.js";
+import o from "./allocated-memory.js";
+//#region src/shared-list.ts
+var s = 4, c = 1, l = 2, u = class {
+	static ALLOCATE_COUNT = s;
+	memory;
+	firstBlock;
+	uint16Array;
+	onDelete;
+	get length() {
+		return Atomics.load(this.firstBlock.data, l);
+	}
+	get type() {
+		return Atomics.load(this.uint16Array, 0);
+	}
+	set type(e) {
+		Atomics.store(this.uint16Array, 0, e);
+	}
+	get dataLength() {
+		return Math.max(1, Atomics.load(this.uint16Array, 1));
+	}
+	set dataLength(e) {
+		Atomics.store(this.uint16Array, 1, e);
+	}
+	constructor(e, t) {
+		if (this.memory = e, t && "firstBlock" in t) this.firstBlock = new o(e, t.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + 3 * Uint32Array.BYTES_PER_ELEMENT, 2);
+		else {
+			this.firstBlock = t && t.initWithBlock ? new o(e, t.initWithBlock) : e.allocUI32(s), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + 3 * Uint32Array.BYTES_PER_ELEMENT, 2);
+			let n = t?.type ?? Uint32Array;
+			n === Uint32Array ? this.type = 0 : n === Int32Array ? this.type = 1 : n === Float32Array && (this.type = 2), this.dataLength = t?.dataLength ?? 1;
+		}
+	}
+	insert(t) {
+		typeof t == "number" && (t = [t]);
+		let i = this.dataLength;
+		if (t.length > i) throw Error(`Can't insert ${t.length} array into shared list of ${i} dataLength`);
+		let o = this.memory.allocUI32(c + i), s = this.getDataBlock(o.data), u = o.pointer;
+		for (let e = 0; e < t.length; e++) s instanceof Int32Array || s instanceof Uint32Array ? Atomics.store(s, e, t[e]) : s[e] = t[e];
+		let d, f = !1;
+		for (; !f;) d = n(this.firstBlock.data, 1), f = r(this.firstBlock.data, 1, u, d);
+		if (d) {
+			let { bufferPosition: t, bufferByteOffset: n } = e(d), r = new Uint32Array(this.memory.buffers[t].buf, n, 1);
+			a(r, 0, u);
+		} else a(this.firstBlock.data, 0, u);
+		Atomics.add(this.firstBlock.data, l, 1);
+	}
+	deleteMatch(e) {
+		for (let { data: t, index: n, deleteCurrent: r } of this) if (e(t, n)) return r(), !0;
+		return !1;
+	}
+	deleteIndex(e) {
+		return e >= this.length || e < 0 ? !1 : this.deleteMatch((t, n) => n === e);
+	}
+	deleteValue(e) {
+		return typeof e == "number" ? this.deleteMatch((t) => t[0] === e) : this.deleteMatch((t) => {
+			if (t.length !== e.length) return !1;
+			for (let n = 0; n < t.length; n++) if (t[n] !== e[n]) return !1;
+			return !0;
+		});
+	}
+	clear() {
+		let t, i, a = !1;
+		for (; !a;) {
+			if (t = n(this.firstBlock.data, 0), i = n(this.firstBlock.data, 1), !i) return;
+			a = r(this.firstBlock.data, 1, 0, i);
+		}
+		if (!t) return;
+		r(this.firstBlock.data, 0, 0, t);
+		let o = 0, s = t;
+		for (; s;) {
+			let { bufferPosition: t, bufferByteOffset: r } = e(s), i = this.memory.buffers[t];
+			if (!i) break;
+			let a = new Uint32Array(i.buf, r, 2);
+			s = n(a, 0), o++, this.onDelete && this.onDelete(this.getDataBlock(a)), i.free(a.byteOffset);
+		}
+		Atomics.sub(this.firstBlock.data, l, o);
+	}
+	*[Symbol.iterator]() {
+		let e = 0, { bufferPosition: n, bufferByteOffset: r } = t(this.firstBlock.data, 0), a = this.firstBlock.data, o = 0, s = 0;
+		for (; r;) {
+			let c = this.memory.buffers[n];
+			if (!c) return;
+			let u = new Uint32Array(c.buf, r, 2), d = this.getDataBlock(u), f = n, p = r;
+			({bufferPosition: n, bufferByteOffset: r} = t(u, 0));
+			let m = !0;
+			yield {
+				data: d,
+				index: e,
+				deleteCurrent: () => {
+					i(a, 0, n, r), r || i(this.firstBlock.data, 1, o, s), this.onDelete && this.onDelete(this.getDataBlock(u)), c.free(u.byteOffset), Atomics.sub(this.firstBlock.data, l, 1), m = !1;
+				}
+			}, m && (a = u, o = f, s = p, e++);
+		}
+	}
+	forEach(e) {
+		for (let t of this) e(t.data);
+	}
+	getSharedMemory() {
+		return { firstBlock: this.firstBlock.getSharedMemory() };
+	}
+	getDataBlock(e) {
+		let t = e.byteOffset + c * e.BYTES_PER_ELEMENT;
+		switch (this.type) {
+			case 1: return new Int32Array(e.buffer, t, this.dataLength);
+			case 0: return new Uint32Array(e.buffer, t, this.dataLength);
+			case 2: return new Float32Array(e.buffer, t, this.dataLength);
+			default: throw Error(`Unknown data block type ${this.type}`);
+		}
+	}
+	free() {
+		let { bufferPosition: e, bufferByteOffset: n } = t(this.firstBlock.data, 0);
+		for (; n;) {
+			let r = new o(this.memory, {
+				bufferPosition: e,
+				bufferByteOffset: n
+			});
+			({bufferPosition: e, bufferByteOffset: n} = t(r.data, 0)), this.onDelete && this.onDelete(this.getDataBlock(r.data)), r.free();
+		}
+		this.firstBlock.free();
+	}
+};
+//#endregion
+export { u as default };
+
+//# sourceMappingURL=shared-list.js.map

package/dist/shared-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-list.js","names":[],"sources":["../src/shared-list.ts"],"sourcesContent":["import type { SharedAllocatedMemory } from './allocated-memory';\nimport AllocatedMemory from './allocated-memory';\nimport type { TypedArrayConstructor } from './interfaces/typed-array-constructor';\nimport type MemoryHeap from './memory-heap';\nimport { getPointer, loadPointer, loadRawPointer, replaceRawPointer, storePointer, storeRawPointer } from './utils/pointer';\n\nenum TYPE {\n\tuint32,\n\tint32,\n\tfloat32,\n}\n\n// TODO: We need some sort of locking on insert/deletes!\nconst FIRST_BLOCK_RECORD_KEEPING_COUNT = 4;\nconst DATA_BLOCK_RECORD_KEEPING_COUNT = 1;\nconst LENGTH_INDEX = 2;\nexport default class SharedList<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<SharedListIterable<T>> {\n\tstatic readonly ALLOCATE_COUNT = FIRST_BLOCK_RECORD_KEEPING_COUNT;\n\n\tprivate memory: MemoryHeap;\n\t/* First block\n\t\t32 index 0\n\t\tuint16 0 - next buffer position\n\t\tuint16 1 - next buffer index\n\t\t32 index 1\n\t\tuint16 2 - last buffer position\n\t\tuint16 3 - last buffer index\n\t\t32 index 2\n\t\tuint32 4 - length\n\t\t32 index 3\n\t\tuint16 6 - type\n\t\tuint16 7 - data length (defaults to 1 number per data)\n\t*/\n\t/* Other blocks\n\t\t32 index 0\n\t\tuint16 0 - next buffer position\n\t\tuint16 1 - next buffer index\n\t\t32 index 1 => data\n\t*/\n\tprivate firstBlock: AllocatedMemory;\n\tprivate uint16Array: Uint16Array;\n\tonDelete?: (data: T) => void;\n\n\tget length(): number {\n\t\treturn Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t}\n\t\n\tget type(): number {\n\t\treturn Atomics.load(this.uint16Array, 0);\n\t}\n\tprivate set type(value: number) {\n\t\tAtomics.store(this.uint16Array, 0, value);\n\t}\n\tget dataLength(): number {\n\t\t// Can technically be initialized by passing memory without actually every being called - need to make sure dataLength is always at least one\n\t\treturn Math.max(1, Atomics.load(this.uint16Array, 1));\n\t}\n\tprivate set dataLength(value: number) {\n\t\tAtomics.store(this.uint16Array, 1, value);\n\t}\n\n\tconstructor(memory: MemoryHeap, config?: SharedListConfig<T> | SharedListMemory) {\n\t\tthis.memory = memory;\n\n\t\tif(config && 'firstBlock' in config) {\n\t\t\t// TODO: How to handle referencing memory we don't have access to yet because buffer not synced from worker?\n\t\t\tthis.firstBlock = new AllocatedMemory(memory, config.firstBlock);\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (LENGTH_INDEX + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);\n\t\t} else {\n\t\t\tif(config && config.initWithBlock) {\n\t\t\t\tthis.firstBlock = new AllocatedMemory(memory, config.initWithBlock);\n\t\t\t} else {\n\t\t\t\tthis.firstBlock = memory.allocUI32(FIRST_BLOCK_RECORD_KEEPING_COUNT);\n\t\t\t}\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (LENGTH_INDEX + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);\n\n\t\t\tconst type = config?.type ?? Uint32Array;\n\t\t\tif(type === Uint32Array) {\n\t\t\t\tthis.type = TYPE.uint32;\n\t\t\t// @ts-expect-error\n\t\t\t} else if(type === Int32Array) {\n\t\t\t\tthis.type = TYPE.int32;\n\t\t\t// @ts-expect-error\n\t\t\t} else if(type === Float32Array) {\n\t\t\t\tthis.type = TYPE.float32;\n\t\t\t}\n\t\t\tthis.dataLength = config?.dataLength ?? 1;\n\t\t}\n\t}\n\n\tinsert(values: number | Array<number>) {\n\t\tif(typeof values === 'number') {\n\t\t\tvalues = [values];\n\t\t}\n\n\t\tlet dataLength = this.dataLength;\n\t\tif(values.length > dataLength) {\n\t\t\tthrow new Error(`Can't insert ${values.length} array into shared list of ${dataLength} dataLength`);\n\t\t}\n\t\tlet newBlock = this.memory.allocUI32(DATA_BLOCK_RECORD_KEEPING_COUNT + dataLength);\n\t\tlet newData = this.getDataBlock(newBlock.data);\n\t\tlet newBlockPointer = newBlock.pointer;\n\t\t\n\t\tfor(let i = 0; i < values.length; i++) {\n\t\t\tif(newData instanceof Int32Array || newData instanceof Uint32Array) {\n\t\t\t\tAtomics.store(newData, i, values[i]);\n\t\t\t} else {\n\t\t\t\t// TODO: Should we replace with pass thru float32 conversion -> store?\n\t\t\t\tnewData[i] = values[i];\n\t\t\t}\n\t\t}\n\n\t\tlet lastBlockPointer;\n\t\tlet updateWorked = false;\n\t\twhile(!updateWorked) {\n\t\t\tlastBlockPointer = loadRawPointer(this.firstBlock.data, 1);\n\t\t\tupdateWorked = replaceRawPointer(this.firstBlock.data, 1, newBlockPointer, lastBlockPointer);\n\t\t}\n\n\t\tif(lastBlockPointer) {\n\t\t\tlet { bufferPosition: lastBlockPosition, bufferByteOffset: lastBlockByteOffset } = getPointer(lastBlockPointer);\n\t\t\t// TODO: How to handle referencing memory we don't have access to yet because buffer not synced from worker?\n\t\t\tlet lastBlock = new Uint32Array(this.memory.buffers[lastBlockPosition].buf, lastBlockByteOffset, 1);\n\t\t\tstoreRawPointer(lastBlock, 0, newBlockPointer);\n\t\t} else {\n\t\t\t// First item - store on first block\n\t\t\tstoreRawPointer(this.firstBlock.data, 0, newBlockPointer);\n\t\t}\n\t\t\n\t\t// Always update new last buffer position and length\n\t\tAtomics.add(this.firstBlock.data, LENGTH_INDEX, 1);\n\t}\n\n\tdeleteMatch(callback: (values: T, index: number) => boolean): boolean {\n\t\tfor(let { data, index, deleteCurrent } of this) {\n\t\t\tif(callback(data, index)) {\n\t\t\t\tdeleteCurrent();\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\tdeleteIndex(deleteIndex: number): boolean {\n\t\tif(deleteIndex >= this.length || deleteIndex < 0) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn this.deleteMatch((values, index) => index === deleteIndex);\n\t}\n\tdeleteValue(deleteValues: number | Array<number>) {\n\t\tif(typeof deleteValues === 'number') {\n\t\t\treturn this.deleteMatch(values => values[0] === deleteValues);\n\t\t} else {\n\t\t\treturn this.deleteMatch(values => {\n\t\t\t\tif(values.length !== deleteValues.length) {\n\t\t\t\t\treturn false;\n\t\t\t\t} else {\n\t\t\t\t\tfor(let i = 0; i < values.length; i++) {\n\t\t\t\t\t\tif(values[i] !== deleteValues[i]) {\n\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n\n\tclear() {\n\t\tlet firstBlockPointer, lastBlockPointer;\n\t\tlet updateWorked = false;\n\t\twhile(!updateWorked) {\n\t\t\tfirstBlockPointer = loadRawPointer(this.firstBlock.data, 0);\n\t\t\tlastBlockPointer = loadRawPointer(this.firstBlock.data, 1);\n\t\t\t// Already cleared\n\t\t\tif(!lastBlockPointer) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tupdateWorked = replaceRawPointer(this.firstBlock.data, 1, 0, lastBlockPointer);\n\t\t}\n\t\t\n\t\t// Shouldn't be possible to hit: making Typescript happy\n\t\tif(!firstBlockPointer) {\n\t\t\treturn;\n\t\t}\n\n\t\t// We only want to update the last block if this is ran before something new was inserted\n\t\treplaceRawPointer(this.firstBlock.data, 0, 0, firstBlockPointer);\n\n\t\t// Iterate through  inaccessible nodes and delete them\n\t\tlet deletedItems = 0;\n\t\tlet nextBlockPointer = firstBlockPointer;\n\t\twhile(nextBlockPointer) {\n\t\t\tlet { bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = getPointer(nextBlockPointer);\n\t\t\tlet memPool = this.memory.buffers[nextBlockPosition];\n\t\t\t// Short circuit iterations if we can't access memory\n\t\t\tif(!memPool) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tlet blockRecord = new Uint32Array(memPool.buf, nextBlockByteOffset, 2);\n\t\t\tnextBlockPointer = loadRawPointer(blockRecord, 0);\n\t\t\tdeletedItems++;\n\n\t\t\tif(this.onDelete) {\n\t\t\t\tthis.onDelete(this.getDataBlock(blockRecord));\n\t\t\t}\n\n\t\t\tmemPool.free(blockRecord.byteOffset);\n\t\t}\n\t\t\n\t\t// Subtract by however many we deleted so that a insert during this operation is accurate\n\t\tAtomics.sub(this.firstBlock.data, LENGTH_INDEX, deletedItems);\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tlet currentIndex = 0;\n\t\tlet { bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = loadPointer(this.firstBlock.data, 0);\n\t\tlet lastBlockData = this.firstBlock.data;\n\t\tlet lastBlockPosition = 0;\n\t\tlet lastBlockByteOffset = 0;\n\t\twhile(nextBlockByteOffset) {\n\t\t\tlet memPool = this.memory.buffers[nextBlockPosition];\n\t\t\t// Short circuit iterations if we can't access memory\n\t\t\tif(!memPool) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tlet blockRecord = new Uint32Array(memPool.buf, nextBlockByteOffset, 2);\n\t\t\tlet blockData = this.getDataBlock(blockRecord);\n\n\t\t\tlet currentBlockPosition = nextBlockPosition;\n\t\t\tlet currentBlockByteOffset = nextBlockByteOffset;\n\t\t\t({ bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = loadPointer(blockRecord, 0));\n\n\t\t\tlet updateLastBlock = true;\n\t\t\tyield {\n\t\t\t\tdata: blockData,\n\t\t\t\tindex: currentIndex,\n\t\t\t\tdeleteCurrent: () => {\n\t\t\t\t\t// Move previous index to point to one after\n\t\t\t\t\tstorePointer(lastBlockData, 0, nextBlockPosition, nextBlockByteOffset);\n\n\t\t\t\t\t// If this is the last item, update last block to be previous location\n\t\t\t\t\tif(!nextBlockByteOffset) {\n\t\t\t\t\t\tstorePointer(this.firstBlock.data, 1, lastBlockPosition, lastBlockByteOffset);\n\t\t\t\t\t}\n\n\t\t\t\t\tif(this.onDelete) {\n\t\t\t\t\t\tthis.onDelete(this.getDataBlock(blockRecord));\n\t\t\t\t\t}\n\n\t\t\t\t\tmemPool.free(blockRecord.byteOffset);\n\t\t\t\t\tAtomics.sub(this.firstBlock.data, LENGTH_INDEX, 1);\n\t\t\t\t\tupdateLastBlock = false;\n\t\t\t\t},\n\t\t\t};\n\n\t\t\tif(updateLastBlock) {\n\t\t\t\tlastBlockData = blockRecord;\n\t\t\t\tlastBlockPosition = currentBlockPosition;\n\t\t\t\tlastBlockByteOffset = currentBlockByteOffset;\n\t\t\t\tcurrentIndex++;\n\t\t\t}\n\t\t}\n\t}\n\n\tforEach(callback: (data: T) => void) {\n\t\tfor(let value of this) {\n\t\t\tcallback(value.data);\n\t\t}\n\t}\n\n\tgetSharedMemory(): SharedListMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.firstBlock.getSharedMemory(),\n\t\t};\n\t}\n\n\tprivate getDataBlock(memory: Uint32Array): T {\n\t\tconst startIndex = memory.byteOffset + DATA_BLOCK_RECORD_KEEPING_COUNT * memory.BYTES_PER_ELEMENT;\n\n\t\tswitch(this.type) {\n\t\t\tcase TYPE.int32:\n\t\t\t\treturn new Int32Array(memory.buffer, startIndex, this.dataLength) as T;\n\t\t\tcase TYPE.uint32:\n\t\t\t\treturn new Uint32Array(memory.buffer, startIndex, this.dataLength) as T;\n\t\t\tcase TYPE.float32:\n\t\t\t\treturn new Float32Array(memory.buffer, startIndex, this.dataLength) as T;\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`Unknown data block type ${this.type}`);\n\t\t}\n\t}\n\n\tfree() {\n\t\tlet { bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = loadPointer(this.firstBlock.data, 0);\n\t\twhile(nextBlockByteOffset) {\n\t\t\tlet allocatedMemory = new AllocatedMemory(this.memory, {\n\t\t\t\tbufferPosition: nextBlockPosition,\n\t\t\t\tbufferByteOffset: nextBlockByteOffset,\n\t\t\t});\n\n\t\t\t({ bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = loadPointer(allocatedMemory.data, 0));\n\n\t\t\tif(this.onDelete) {\n\t\t\t\tthis.onDelete(this.getDataBlock(allocatedMemory.data));\n\t\t\t}\n\n\t\t\tallocatedMemory.free();\n\t\t}\n\n\t\tthis.firstBlock.free();\n\t}\n}\n\ninterface SharedListConfig<T extends Uint32Array | Int32Array | Float32Array> {\n\tinitWithBlock?: SharedAllocatedMemory\n\ttype?: TypedArrayConstructor<T>\n\tdataLength?: number\n}\ninterface SharedListMemory {\n\tfirstBlock: SharedAllocatedMemory\n}\n\ninterface SharedListIterable<T extends Uint32Array | Int32Array | Float32Array> {\n\tdata: T\n\tindex: number\n\tdeleteCurrent: () => void\n}\n\nexport { type SharedListMemory };"],"mappings":"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"}

package/dist/{src/shared-map.d.ts → shared-map.d.ts}

@@ -1,5 +1,5 @@
-import { SharedAllocatedMemory } from './allocated-memory';
-import { default as MemoryHeap } from './memory-heap';
+import { type SharedAllocatedMemory } from './allocated-memory';
+import type MemoryHeap from './memory-heap';
 export default class SharedMap<K extends string | number> {
     static readonly ALLOCATE_COUNT = 4;
     private memory;

package/dist/shared-map.js

@@ -0,0 +1,104 @@
+import { loadPointer as e, storePointer as t } from "./utils/pointer.js";
+import n from "./allocated-memory.js";
+import r from "./shared-list.js";
+//#region src/shared-map.ts
+var i = 10, a = class a {
+	static ALLOCATE_COUNT = 4;
+	memory;
+	pointerMemory;
+	lock;
+	get hashMemory() {
+		return new n(this.memory, e(this.pointerMemory.data, 0));
+	}
+	get length() {
+		return Atomics.load(this.pointerMemory.data, 2);
+	}
+	get maxHash() {
+		return Atomics.load(this.pointerMemory.data, 3);
+	}
+	constructor(e, r) {
+		if (this.memory = e, r) this.pointerMemory = new n(e, r.firstBlock);
+		else {
+			this.pointerMemory = e.allocUI32(a.ALLOCATE_COUNT);
+			let n = e.allocUI32(i);
+			t(this.pointerMemory.data, 0, n.bufferPosition, n.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, i);
+		}
+		this.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + Uint32Array.BYTES_PER_ELEMENT, 1);
+	}
+	set(e, t) {
+		this.length >= this.maxHash * 2 && this.growHashTable();
+		let n = o(e);
+		this.setHashKey(this.hashMemory, this.maxHash, n, t) && Atomics.add(this.pointerMemory.data, 2, 1);
+	}
+	setHashKey(n, i, a, o) {
+		let s = this.hash(a, i), c, l = e(n.data, s);
+		if (l.bufferByteOffset === 0) {
+			c = new r(this.memory, { dataLength: 2 });
+			let e = c.getSharedMemory();
+			t(n.data, s, e.firstBlock.bufferPosition, e.firstBlock.bufferByteOffset);
+		} else c = new r(this.memory, { firstBlock: l });
+		let u = !0;
+		return c.deleteValue(a) && (u = !1), c.insert([a, o]), u;
+	}
+	get(t) {
+		let n = o(t), i = this.hash(n, this.maxHash), a = e(this.hashMemory.data, i);
+		if (a.bufferByteOffset === 0) return;
+		let s = new r(this.memory, { firstBlock: a });
+		for (let { data: e } of s) if (e[0] === n) return e[1];
+	}
+	has(t) {
+		let n = o(t), i = this.hash(n, this.maxHash), a = e(this.hashMemory.data, i);
+		if (a.bufferByteOffset === 0) return !1;
+		let s = new r(this.memory, { firstBlock: a });
+		for (let { data: e } of s) if (e[0] === n) return !0;
+		return !1;
+	}
+	delete(t) {
+		let n = o(t), i = this.hash(n, this.maxHash), a = e(this.hashMemory.data, i);
+		if (a.bufferByteOffset === 0) return !1;
+		let s = new r(this.memory, { firstBlock: a });
+		for (let { data: e, deleteCurrent: t } of s) if (e[0] === n) return t(), Atomics.sub(this.pointerMemory.data, 2, 1), !0;
+		return !1;
+	}
+	growHashTable() {
+		let n = this.maxHash, i = n * 2, a = this.memory.allocUI32(i), o = this.hashMemory;
+		for (let t = 0; t < n; t++) {
+			let n = e(o.data, t);
+			if (n.bufferByteOffset === 0) continue;
+			let s = new r(this.memory, { firstBlock: n });
+			for (let { data: e } of s) this.setHashKey(a, i, e[0], e[1]);
+			s.free();
+		}
+		t(this.pointerMemory.data, 0, a.bufferPosition, a.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, i), o.free();
+	}
+	hash(e, t) {
+		return e % t;
+	}
+	free() {
+		for (let t = 0; t < this.maxHash; t++) {
+			let n = e(this.hashMemory.data, t);
+			n.bufferByteOffset !== 0 && new r(this.memory, { firstBlock: n }).free();
+		}
+		this.hashMemory.free(), this.pointerMemory.free();
+	}
+	getSharedMemory() {
+		return { firstBlock: this.pointerMemory.getSharedMemory() };
+	}
+};
+function o(e) {
+	return typeof e == "number" ? e : typeof e == "string" ? s(e) : e;
+}
+function s(e) {
+	let t = e.length, n = 17 ^ t, r = 0, i;
+	for (; t >= 4;) i = e.charCodeAt(r) & 255 | (e.charCodeAt(++r) & 255) << 8 | (e.charCodeAt(++r) & 255) << 16 | (e.charCodeAt(++r) & 255) << 14, i = (i & 65535) * 1540483477 + (((i >>> 16) * 1540483477 & 65535) << 16), i ^= i >>> 14, i = (i & 65535) * 1540483477 + (((i >>> 16) * 1540483477 & 65535) << 16), n = (n & 65535) * 1540483477 + (((n >>> 16) * 1540483477 & 65535) << 16) ^ i, t -= 4, ++r;
+	switch (t) {
+		case 3: n ^= (e.charCodeAt(r + 2) & 255) << 16;
+		case 2: n ^= (e.charCodeAt(r + 1) & 255) << 8;
+		case 1: n ^= e.charCodeAt(r) & 255, n = (n & 65535) * 1540483477 + (((n >>> 16) * 1540483477 & 65535) << 16);
+	}
+	return n ^= n >>> 13, n = (n & 65535) * 1540483477 + (((n >>> 16) * 1540483477 & 65535) << 16), n ^= n >>> 15, n >>>= 0, n;
+}
+//#endregion
+export { a as default };
+
+//# sourceMappingURL=shared-map.js.map

package/dist/shared-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-map.js","names":[],"sources":["../src/shared-map.ts"],"sourcesContent":["import AllocatedMemory, { type SharedAllocatedMemory } from './allocated-memory';\nimport type MemoryHeap from './memory-heap';\nimport SharedList from './shared-list';\nimport { loadPointer, storePointer } from './utils/pointer';\n\n// TODO: Grow hashMemory\n// TODO: Add iterator\n// TODO: Add read/write locks\nconst DEFAULT_HASH_SIZE = 10;\nexport default class SharedMap<K extends string | number> {\n\tstatic readonly ALLOCATE_COUNT = 4;\n\n\tprivate memory: MemoryHeap;\n\t// Memory order: Pointer, Lock, Length, MaxHash\n\tprivate pointerMemory: AllocatedMemory;\n\tprivate lock: Int32Array;\n\tprivate get hashMemory(): AllocatedMemory {\n\t\treturn new AllocatedMemory(this.memory, loadPointer(this.pointerMemory.data, 0));\n\t}\n\n\tget length(): number {\n\t\treturn Atomics.load(this.pointerMemory.data, 2);\n\t}\n\tget maxHash(): number {\n\t\treturn Atomics.load(this.pointerMemory.data, 3);\n\t}\n\n\tconstructor(memory: MemoryHeap, clone?: SharedMapMemory) {\n\t\tthis.memory = memory;\n\n\t\tif(clone) {\n\t\t\tthis.pointerMemory = new AllocatedMemory(memory, clone.firstBlock);\n\t\t} else {\n\t\t\tthis.pointerMemory = memory.allocUI32(SharedMap.ALLOCATE_COUNT);\n\t\t\tlet hashMemory = memory.allocUI32(DEFAULT_HASH_SIZE);\n\t\t\tstorePointer(this.pointerMemory.data, 0, hashMemory.bufferPosition, hashMemory.bufferByteOffset);\n\t\t\tAtomics.store(this.pointerMemory.data, 3, DEFAULT_HASH_SIZE);\n\t\t}\n\t\tthis.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + Uint32Array.BYTES_PER_ELEMENT, 1);\n\t}\n\n\tset(key: K, value: number) {\n\t\tif(this.length >= this.maxHash * 2) {\n\t\t\tthis.growHashTable();\n\t\t}\n\n\t\tlet fullHashKey = get32BitHash(key);\n\t\tif(this.setHashKey(this.hashMemory, this.maxHash, fullHashKey, value)) {\n\t\t\tAtomics.add(this.pointerMemory.data, 2, 1);\n\t\t}\n\t}\n\tprivate setHashKey(hashMemory: AllocatedMemory, maxHash: number, fullHashKey: number, value: number) {\n\t\tlet hashKey = this.hash(fullHashKey, maxHash);\n\t\t\n\t\tlet list: SharedList;\n\t\tlet pointer = loadPointer(hashMemory.data, hashKey);\n\t\tif(pointer.bufferByteOffset === 0) {\n\t\t\t// Initialize a list here\n\t\t\tlist = new SharedList(this.memory, {\n\t\t\t\tdataLength: 2,\n\t\t\t});\n\n\t\t\tlet listMemory = list.getSharedMemory();\n\t\t\tstorePointer(hashMemory.data, hashKey, listMemory.firstBlock.bufferPosition, listMemory.firstBlock.bufferByteOffset);\n\t\t} else {\n\t\t\tlist = new SharedList(this.memory, {\n\t\t\t\tfirstBlock: pointer,\n\t\t\t});\n\t\t}\n\n\t\t// Check if any other items in list have the same key and delete them\n\t\tlet inserted = true;\n\t\tif(list.deleteValue(fullHashKey)) {\n\t\t\tinserted = false;\n\t\t}\n\t\tlist.insert([fullHashKey, value]);\n\t\t\n\t\treturn inserted;\n\t}\n\n\tget(key: K): number | undefined {\n\t\tlet fullHashKey = get32BitHash(key);\n\t\tlet hashKey = this.hash(fullHashKey, this.maxHash);\n\n\t\tlet pointer = loadPointer(this.hashMemory.data, hashKey);\n\t\tif(pointer.bufferByteOffset === 0) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tlet list = new SharedList(this.memory, {\n\t\t\tfirstBlock: pointer,\n\t\t});\n\n\t\tfor(let { data } of list) {\n\t\t\tif(data[0] === fullHashKey) {\n\t\t\t\treturn data[1];\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\thas(key: K): boolean {\n\t\tlet fullHashKey = get32BitHash(key);\n\t\tlet hashKey = this.hash(fullHashKey, this.maxHash);\n\n\t\tlet pointer = loadPointer(this.hashMemory.data, hashKey);\n\t\tif(pointer.bufferByteOffset === 0) {\n\t\t\treturn false;\n\t\t}\n\n\t\tlet list = new SharedList(this.memory, {\n\t\t\tfirstBlock: pointer,\n\t\t});\n\n\t\tfor(let { data } of list) {\n\t\t\tif(data[0] === fullHashKey) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\tdelete(key: K): boolean {\n\t\tlet fullHashKey = get32BitHash(key);\n\t\tlet hashKey = this.hash(fullHashKey, this.maxHash);\n\n\t\tlet pointer = loadPointer(this.hashMemory.data, hashKey);\n\t\tif(pointer.bufferByteOffset === 0) {\n\t\t\treturn false;\n\t\t}\n\n\t\tlet list = new SharedList(this.memory, {\n\t\t\tfirstBlock: pointer,\n\t\t});\n\n\t\tfor(let { data, deleteCurrent } of list) {\n\t\t\tif(data[0] === fullHashKey) {\n\t\t\t\tdeleteCurrent();\n\n\t\t\t\tAtomics.sub(this.pointerMemory.data, 2, 1);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\tprivate growHashTable() {\n\t\tlet oldMaxHash = this.maxHash;\n\t\tlet newMaxHash = oldMaxHash * 2;\n\t\tlet newHashMemory = this.memory.allocUI32(newMaxHash);\n\t\tlet oldHashMemory = this.hashMemory;\n\n\t\t// Copy each old hash value into new hash memory\n\t\tfor(let i = 0; i < oldMaxHash; i++) {\n\t\t\tlet pointer = loadPointer(oldHashMemory.data, i);\n\t\t\tif(pointer.bufferByteOffset === 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tlet list = new SharedList(this.memory, {\n\t\t\t\tfirstBlock: pointer,\n\t\t\t});\n\t\t\tfor(let { data } of list) {\n\t\t\t\tthis.setHashKey(newHashMemory, newMaxHash, data[0], data[1]);\n\t\t\t}\n\n\t\t\t// The entries have been copied into freshly allocated lists in the new hash table so the old list can be freed\n\t\t\tlist.free();\n\t\t}\n\n\t\tstorePointer(this.pointerMemory.data, 0, newHashMemory.bufferPosition, newHashMemory.bufferByteOffset);\n\t\tAtomics.store(this.pointerMemory.data, 3, newMaxHash);\n\n\t\t// pointerMemory now references newHashMemory so the old hash table memory can be freed\n\t\toldHashMemory.free();\n\t}\n\n\tprivate hash(key: number, maxHash: number) {\n\t\treturn key % maxHash;\n\t}\n\n\tfree() {\n\t\t// Loop through and free lists in hash table first\n\t\tfor(let i = 0; i < this.maxHash; i++) {\n\t\t\tlet pointer = loadPointer(this.hashMemory.data, i);\n\t\t\tif(pointer.bufferByteOffset === 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tlet list = new SharedList(this.memory, {\n\t\t\t\tfirstBlock: pointer,\n\t\t\t});\n\t\t\tlist.free();\n\t\t}\n\n\t\tthis.hashMemory.free();\n\t\tthis.pointerMemory.free();\n\t}\n\n\tgetSharedMemory(): SharedMapMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.pointerMemory.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedMapMemory {\n\tfirstBlock: SharedAllocatedMemory\n}\n\nfunction get32BitHash<K extends string | number>(key: K): number {\n\tif(typeof key === 'number') {\n\t\treturn key;\n\t} else if(typeof key === 'string') {\n\t\treturn hashString(key);\n\t} else {\n\t\treturn key;\n\t}\n}\n\n// Copied from https://github.com/mmomtchev/SharedMap/blob/master/index.js - MurmurHash2\nfunction hashString(str: string): number {\n\tlet\n\t\tl = str.length,\n\t\th = 17 ^ l,\n\t\ti = 0,\n\t\tk;\n\twhile(l >= 4) {\n\t\tk =\n\t\t\t((str.charCodeAt(i) & 0xff)) |\n\t\t\t((str.charCodeAt(++i) & 0xff) << 8) |\n\t\t\t((str.charCodeAt(++i) & 0xff) << 16) |\n\t\t\t((str.charCodeAt(++i) & 0xff) << 14);\n\t\tk = (((k & 0xffff) * 0x5bd1e995) + ((((k >>> 16) * 0x5bd1e995) & 0xffff) << 16));\n\t\tk ^= k >>> 14;\n\t\tk = (((k & 0xffff) * 0x5bd1e995) + ((((k >>> 16) * 0x5bd1e995) & 0xffff) << 16));\n\t\th = (((h & 0xffff) * 0x5bd1e995) + ((((h >>> 16) * 0x5bd1e995) & 0xffff) << 16)) ^ k;\n\t\tl -= 4;\n\t\t++i;\n\t}\n\t/* eslint-disable no-fallthrough */\n\tswitch(l) {\n\t\tcase 3: h ^= (str.charCodeAt(i + 2) & 0xff) << 16;\n\t\tcase 2: h ^= (str.charCodeAt(i + 1) & 0xff) << 8;\n\t\tcase 1: h ^= (str.charCodeAt(i) & 0xff);\n\t\t\th = (((h & 0xffff) * 0x5bd1e995) + ((((h >>> 16) * 0x5bd1e995) & 0xffff) << 16));\n\t}\n\t/* eslint-enable no-fallthrough */\n\th ^= h >>> 13;\n\th = (((h & 0xffff) * 0x5bd1e995) + ((((h >>> 16) * 0x5bd1e995) & 0xffff) << 16));\n\th ^= h >>> 15;\n\th = h >>> 0;\n\treturn h;\n}\n\nexport type { SharedMapMemory };"],"mappings":"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"}

package/dist/{src/shared-pointer-list.d.ts → shared-pointer-list.d.ts}

@@ -1,6 +1,6 @@
-import { default as AllocatedMemory } from './allocated-memory';
-import { default as MemoryHeap } from './memory-heap';
-import { SharedListMemory } from './shared-list';
+import AllocatedMemory from './allocated-memory';
+import type MemoryHeap from './memory-heap';
+import type { SharedListMemory } from './shared-list';
 export default abstract class SharedPointerList<T extends PointerItem> implements Iterable<T> {
     private memory;
     private list;

package/dist/shared-pointer-list.js

@@ -0,0 +1,47 @@
+import { createPointer as e, loadPointer as t } from "./utils/pointer.js";
+import n from "./allocated-memory.js";
+import r from "./shared-list.js";
+//#region src/shared-pointer-list.ts
+var i = class {
+	memory;
+	list;
+	constructor(e, t) {
+		this.memory = e, this.list = t ? new r(e, t) : new r(e);
+	}
+	get length() {
+		return this.list.length;
+	}
+	insert(t) {
+		this.list.insert(e(t.memory.bufferPosition, t.memory.bufferByteOffset));
+	}
+	delete(t) {
+		return this.list.deleteValue(e(t.memory.bufferPosition, t.memory.bufferByteOffset));
+	}
+	*[Symbol.iterator]() {
+		let e = this.list[Symbol.iterator]();
+		for (let { data: r } of e) {
+			let { bufferPosition: e, bufferByteOffset: i } = t(r, 0), a = new n(this.memory, {
+				bufferPosition: e,
+				bufferByteOffset: i
+			});
+			yield this.createItem(a);
+		}
+	}
+	forEach(e) {
+		for (let t of this) e(t);
+	}
+	find(e) {
+		for (let t of this) if (e(t)) return t;
+	}
+	getSharedMemory() {
+		return this.list.getSharedMemory();
+	}
+	free() {
+		for (let e of this) "free" in e && typeof e.free == "function" ? e.free() : e.memory.free();
+		this.list.free();
+	}
+};
+//#endregion
+export { i as default };
+
+//# sourceMappingURL=shared-pointer-list.js.map

package/dist/shared-pointer-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-pointer-list.js","names":[],"sources":["../src/shared-pointer-list.ts"],"sourcesContent":["import AllocatedMemory from './allocated-memory';\nimport type MemoryHeap from './memory-heap';\nimport type { SharedListMemory } from './shared-list';\nimport SharedList from './shared-list';\nimport { createPointer, loadPointer } from './utils/pointer';\n\nexport default abstract class SharedPointerList<T extends PointerItem> implements Iterable<T> {\n\tprivate memory: MemoryHeap;\n\tprivate list: SharedList;\n\n\tconstructor(heap: MemoryHeap, memory?: SharedListMemory) {\n\t\tthis.memory = heap;\n\n\t\tif(memory) {\n\t\t\tthis.list = new SharedList(heap, memory);\n\t\t} else {\n\t\t\tthis.list = new SharedList(heap);\n\t\t}\n\t}\n\n\tget length() {\n\t\treturn this.list.length;\n\t}\n\n\tinsert(item: T) {\n\t\tthis.list.insert(createPointer(item.memory.bufferPosition, item.memory.bufferByteOffset));\n\t}\n\tdelete(item: T) {\n\t\treturn this.list.deleteValue(createPointer(item.memory.bufferPosition, item.memory.bufferByteOffset));\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tlet iterator = this.list[Symbol.iterator]();\n\n\t\tfor(let { data: pointerData } of iterator) {\n\t\t\tlet { bufferPosition, bufferByteOffset } = loadPointer(pointerData, 0);\n\t\t\tlet allocatedMemory = new AllocatedMemory(this.memory, {\n\t\t\t\tbufferPosition,\n\t\t\t\tbufferByteOffset,\n\t\t\t});\n\t\t\tyield this.createItem(allocatedMemory);\n\t\t}\n\t}\n\tforEach(callback: (item: T) => void) {\n\t\tfor(let value of this) {\n\t\t\tcallback(value);\n\t\t}\n\t}\n\n\tfind(callback: (item: T) => boolean): T | undefined {\n\t\tfor(let value of this) {\n\t\t\tif(callback(value)) {\n\t\t\t\treturn value;\n\t\t\t}\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\tgetSharedMemory() {\n\t\treturn this.list.getSharedMemory();\n\t}\n\n\tprotected abstract createItem(allocatedMemory: AllocatedMemory): T;\n\n\tfree() {\n\t\tfor(let item of this) {\n\t\t\t// NOTE: Anything that allocates it's own memory (ie: type for Item) needs to call free for that class so we can clear all memory recursively\n\t\t\tif('free' in item && typeof item.free === 'function') {\n\t\t\t\titem.free();\n\t\t\t} else {\n\t\t\t\titem.memory.free();\n\t\t\t}\n\t\t}\n\n\t\tthis.list.free();\n\t}\n}\n\ninterface PointerItem {\n\treadonly memory: AllocatedMemory\n}"],"mappings":";;;;AAMA,IAA8B,IAA9B,MAA8F;CAC7F;CACA;CAEA,YAAY,GAAkB,GAA2B;EAGxD,AAFA,KAAK,SAAS,GAEd,AAGC,KAAK,OAHH,IACU,IAAI,EAAW,GAAM,CAAM,IAE3B,IAAI,EAAW,CAAI;CAEjC;CAEA,IAAI,SAAS;EACZ,OAAO,KAAK,KAAK;CAClB;CAEA,OAAO,GAAS;EACf,KAAK,KAAK,OAAO,EAAc,EAAK,OAAO,gBAAgB,EAAK,OAAO,gBAAgB,CAAC;CACzF;CACA,OAAO,GAAS;EACf,OAAO,KAAK,KAAK,YAAY,EAAc,EAAK,OAAO,gBAAgB,EAAK,OAAO,gBAAgB,CAAC;CACrG;CAEA,EAAE,OAAO,YAAY;EACpB,IAAI,IAAW,KAAK,KAAK,OAAO,SAAS,CAAC;EAE1C,KAAI,IAAI,EAAE,MAAM,OAAiB,GAAU;GAC1C,IAAI,EAAE,mBAAgB,wBAAqB,EAAY,GAAa,CAAC,GACjE,IAAkB,IAAI,EAAgB,KAAK,QAAQ;IACtD;IACA;GACD,CAAC;GACD,MAAM,KAAK,WAAW,CAAe;EACtC;CACD;CACA,QAAQ,GAA6B;EACpC,KAAI,IAAI,KAAS,MAChB,EAAS,CAAK;CAEhB;CAEA,KAAK,GAA+C;EACnD,KAAI,IAAI,KAAS,MAChB,IAAG,EAAS,CAAK,GAChB,OAAO;CAKV;CAEA,kBAAkB;EACjB,OAAO,KAAK,KAAK,gBAAgB;CAClC;CAIA,OAAO;EACN,KAAI,IAAI,KAAQ,MAEf,AAAG,UAAU,KAAQ,OAAO,EAAK,QAAS,aACzC,EAAK,KAAK,IAEV,EAAK,OAAO,KAAK;EAInB,KAAK,KAAK,KAAK;CAChB;AACD"}

package/dist/{src/shared-pool.d.ts → shared-pool.d.ts}

@@ -1,14 +1,19 @@
-import { SharedAllocatedMemory } from './allocated-memory';
-import { TypedArrayConstructor } from './interfaces/typed-array-constructor';
-import { default as MemoryHeap } from './memory-heap';
+import type { SharedAllocatedMemory } from './allocated-memory';
+import type { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+import type MemoryHeap from './memory-heap';
 export default class SharedPool<T extends Uint32Array | Int32Array | Float32Array | Float64Array = Uint32Array> implements Iterable<T> {
-    static readonly ALLOCATE_COUNT: number;
+    static readonly ALLOCATE_COUNT = 6;
     private memory;
     private firstBlock;
     private uint16Array;
-    private pointerVector;
-    private recycleVector;
+    private growLock;
+    private pointerStack;
+    private recycleStack;
     private cachedFullDataBlock;
+    private readonly cachedMaxChunkSize;
+    private readonly cachedDataLength;
+    private readonly cachedType;
+    private readonly cachedByteMultipler;
     get length(): number;
     get maxChunkSize(): number;
     private set maxChunkSize(value);
@@ -17,7 +22,6 @@ export default class SharedPool<T extends Uint32Array | Int32Array | Float32Arra
     get dataLength(): number;
     private set dataLength(value);
     get bufferLength(): number;
-    get recycleBufferLength(): number;
     get byteMultipler(): number;
     constructor(memory: MemoryHeap, config?: SharedPoolConfig<T> | SharedPoolMemory);
     at(index: number): T;
@@ -35,7 +39,6 @@ interface SharedPoolConfig<T extends Uint32Array | Int32Array | Float32Array | F
     maxChunkSize?: number;
     type?: TypedArrayConstructor<T>;
     dataLength?: number;
-    recycleBufferLength?: number;
 }
 interface SharedPoolMemory {
     firstBlock: SharedAllocatedMemory;

package/dist/shared-pool.js

@@ -0,0 +1,145 @@
+import { getPointer as e, loadRawPointer as t, storeRawPointer as n } from "./utils/pointer.js";
+import r from "./allocated-memory.js";
+import { lock as i, unlock as a } from "./lock/simple-lock.js";
+import o from "./shared-stack.js";
+//#region src/shared-pool.ts
+var s = 0, c = 1, l = 2, u = 3, d = 4, f = 5, p = class p {
+	static ALLOCATE_COUNT = 6;
+	memory;
+	firstBlock;
+	uint16Array;
+	growLock;
+	pointerStack;
+	recycleStack;
+	cachedFullDataBlock = {};
+	cachedMaxChunkSize;
+	cachedDataLength;
+	cachedType;
+	cachedByteMultipler;
+	get length() {
+		return Atomics.load(this.firstBlock.data, s) - this.recycleStack.length;
+	}
+	get maxChunkSize() {
+		return this.cachedMaxChunkSize;
+	}
+	set maxChunkSize(e) {
+		Atomics.store(this.firstBlock.data, l, e);
+	}
+	get type() {
+		return this.cachedType;
+	}
+	set type(e) {
+		Atomics.store(this.uint16Array, 0, e);
+	}
+	get dataLength() {
+		return this.cachedDataLength;
+	}
+	set dataLength(e) {
+		Atomics.store(this.uint16Array, 1, e);
+	}
+	get bufferLength() {
+		return this.cachedMaxChunkSize * this.pointerStack.length;
+	}
+	get byteMultipler() {
+		return this.cachedByteMultipler;
+	}
+	constructor(i, a) {
+		if (this.memory = i, a && "firstBlock" in a) this.firstBlock = new r(i, a.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + c * Uint32Array.BYTES_PER_ELEMENT, 2), this.pointerStack = new o(i, { firstBlock: e(t(this.firstBlock.data, d)) }), this.recycleStack = new o(i, { firstBlock: e(t(this.firstBlock.data, f)) });
+		else {
+			this.firstBlock = i.allocUI32(p.ALLOCATE_COUNT + o.DEFAULT_ALLOCATE_COUNT * 2), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + c * Uint32Array.BYTES_PER_ELEMENT, 2);
+			let e = a?.dataLength ?? 1, t = a?.maxChunkSize ?? 100;
+			this.pointerStack = new o(i, {
+				firstBlock: this.firstBlock.getSubAllocation(p.ALLOCATE_COUNT, o.DEFAULT_ALLOCATE_COUNT),
+				type: Uint32Array
+			}), n(this.firstBlock.data, d, this.pointerStack.pointer), this.recycleStack = new o(i, {
+				firstBlock: this.firstBlock.getSubAllocation(p.ALLOCATE_COUNT + o.DEFAULT_ALLOCATE_COUNT, o.DEFAULT_ALLOCATE_COUNT),
+				type: Uint32Array
+			}), n(this.firstBlock.data, f, this.recycleStack.pointer);
+			let r = a?.type ?? Uint32Array;
+			r === Uint32Array ? this.type = 0 : r === Int32Array ? this.type = 1 : r === Float32Array ? this.type = 2 : r === Float64Array && (this.type = 3), this.dataLength = e, this.maxChunkSize = t;
+			let s = r === Float64Array ? 2 : 1, l = i.allocUI32(t * e * s);
+			this.pointerStack.push(l.pointer);
+		}
+		this.cachedType = this.uint16Array[0], this.cachedDataLength = Math.max(1, this.uint16Array[1]), this.cachedMaxChunkSize = this.firstBlock.data[l], this.cachedByteMultipler = this.cachedType === 3 ? 2 : 1, this.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + u * Uint32Array.BYTES_PER_ELEMENT, 1);
+	}
+	at(e) {
+		let t = this.getFullDataBlock(e);
+		return this.getDataBlock(t, e % this.cachedMaxChunkSize);
+	}
+	get(e, t = 0) {
+		let n = this.cachedDataLength;
+		if (t >= n) throw Error(`${t} is out of dataLength bounds ${n}`);
+		return this.getFullDataBlock(e)[e % this.cachedMaxChunkSize * n + t];
+	}
+	push(e) {
+		let t = this.cachedDataLength, n = typeof e == "number";
+		if (!n && e.length > t) throw Error(`Can't insert ${e.length} array into shared list of ${t} dataLength`);
+		let r = this.recycleStack.pop();
+		r === void 0 && (r = Atomics.add(this.firstBlock.data, s, 1));
+		let i = this.getFullDataBlock(r), a = t * (r % this.cachedMaxChunkSize);
+		return n ? i[a] = e : i.set(e, a), r;
+	}
+	deleteIndex(e) {
+		this.recycleStack.push(e);
+	}
+	clear() {
+		this.firstBlock.data[s] = 0, this.recycleStack.clear();
+	}
+	*[Symbol.iterator]() {
+		let e = {};
+		for (let t of this.recycleStack) e[t] = !0;
+		let t = this.cachedMaxChunkSize, n = Atomics.load(this.firstBlock.data, s), r = this.getFullDataBlock(0), i = 0;
+		for (let a = 0; a < n; a++) if (!e[a]) {
+			let e = Math.floor(a / t);
+			e !== i && (r = this.getFullDataBlock(a), i = e), yield this.getDataBlock(r, a % t);
+		}
+	}
+	getFullDataBlock(t) {
+		let n = Math.floor(t / this.cachedMaxChunkSize), o = this.cachedFullDataBlock[n];
+		if (o) return o;
+		if (n >= this.pointerStack.length) {
+			i(this.growLock);
+			try {
+				for (; n >= this.pointerStack.length;) {
+					let e = this.memory.allocUI32(this.cachedMaxChunkSize * this.cachedDataLength * this.cachedByteMultipler);
+					this.pointerStack.push(e.pointer);
+				}
+			} finally {
+				a(this.growLock);
+			}
+		}
+		let s = new r(this.memory, e(this.pointerStack.at(n))), c = this.cachedDataLength * this.cachedMaxChunkSize, l;
+		switch (this.cachedType) {
+			case 1:
+				l = new Int32Array(s.data.buffer, s.bufferByteOffset, c);
+				break;
+			case 0:
+				l = new Uint32Array(s.data.buffer, s.bufferByteOffset, c);
+				break;
+			case 2:
+				l = new Float32Array(s.data.buffer, s.bufferByteOffset, c);
+				break;
+			case 3:
+				l = new Float64Array(s.data.buffer, s.bufferByteOffset, c);
+				break;
+			default: throw Error(`Unknown data block type ${this.cachedType}`);
+		}
+		return this.cachedFullDataBlock[n] = l, l;
+	}
+	getDataBlock(e, t) {
+		let n = this.cachedDataLength, r = t * n;
+		return e.subarray(r, r + n);
+	}
+	free() {
+		this.recycleStack.free();
+		for (let t of this.pointerStack) new r(this.memory, e(t)).free();
+		this.pointerStack.free(), this.firstBlock.free();
+	}
+	getSharedMemory() {
+		return { firstBlock: this.firstBlock.getSharedMemory() };
+	}
+};
+//#endregion
+export { p as default };
+
+//# sourceMappingURL=shared-pool.js.map

package/dist/shared-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-pool.js","names":[],"sources":["../src/shared-pool.ts"],"sourcesContent":["import type { SharedAllocatedMemory } from './allocated-memory';\nimport AllocatedMemory from './allocated-memory';\nimport type { TypedArrayConstructor } from './interfaces/typed-array-constructor';\nimport { lock, unlock } from './lock/simple-lock';\nimport type MemoryHeap from './memory-heap';\nimport SharedStack from './shared-stack';\nimport { getPointer, loadRawPointer, storeRawPointer } from './utils/pointer';\n\nenum TYPE {\n\tuint32,\n\tint32,\n\tfloat32,\n\tfloat64,\n}\n\nconst LENGTH_INDEX = 0;\nconst TYPE_INDEX = 1;\nconst MAX_CHUNK_SIZE_INDEX = 2;\n// Guards appending a chunk pointer so only one thread grows the pointer stack at a time\nconst GROW_LOCK_INDEX = 3;\n// Pointers to the two backing SharedStacks (their own firstBlocks): the chunk pointers and the recycled indexes\nconst POINTER_STACK_INDEX = 4;\nconst RECYCLE_STACK_INDEX = 5;\n\n// Array with stable indexes and maximum contiguous memory sizes (necessary to fit large data sets into max 1MB buffers).\n// The chunk pointers and the recycled indexes both live in SharedStacks, whose segments are never moved or freed once\n// published, so concurrent readers never touch memory that is being reclaimed.\n// https://plflib.org/colony.htm for future enhancements - it seems to be an optimized version of what we were aiming for with this\nexport default class SharedPool<T extends Uint32Array | Int32Array | Float32Array | Float64Array = Uint32Array> implements Iterable<T> {\n\tstatic readonly ALLOCATE_COUNT = 6;\n\tprivate memory: MemoryHeap;\n\n\t// Current Length, Type/DataLength, MaxChunkLength, Grow lock, Pointer stack, Recycle stack\n\tprivate firstBlock: AllocatedMemory;\n\tprivate uint16Array: Uint16Array;\n\tprivate growLock: Int32Array;\n\tprivate pointerStack: SharedStack;\n\tprivate recycleStack: SharedStack;\n\n\tprivate cachedFullDataBlock: { [key: number]: T } = {};\n\n\t// Config is written once at construction and never mutated, so it is cached in plain fields\n\tprivate readonly cachedMaxChunkSize: number;\n\tprivate readonly cachedDataLength: number;\n\tprivate readonly cachedType: number;\n\tprivate readonly cachedByteMultipler: number;\n\n\tget length(): number {\n\t\treturn Atomics.load(this.firstBlock.data, LENGTH_INDEX) - this.recycleStack.length;\n\t}\n\tget maxChunkSize(): number {\n\t\treturn this.cachedMaxChunkSize;\n\t}\n\tprivate set maxChunkSize(value: number) {\n\t\tAtomics.store(this.firstBlock.data, MAX_CHUNK_SIZE_INDEX, value);\n\t}\n\n\tget type(): number {\n\t\treturn this.cachedType;\n\t}\n\tprivate set type(value: number) {\n\t\tAtomics.store(this.uint16Array, 0, value);\n\t}\n\tget dataLength(): number {\n\t\treturn this.cachedDataLength;\n\t}\n\tprivate set dataLength(value: number) {\n\t\tAtomics.store(this.uint16Array, 1, value);\n\t}\n\n\tget bufferLength(): number {\n\t\treturn this.cachedMaxChunkSize * this.pointerStack.length;\n\t}\n\tget byteMultipler(): number {\n\t\treturn this.cachedByteMultipler;\n\t}\n\n\tconstructor(memory: MemoryHeap, config?: SharedPoolConfig<T> | SharedPoolMemory) {\n\t\tthis.memory = memory;\n\n\t\tif(config && 'firstBlock' in config) {\n\t\t\tthis.firstBlock = new AllocatedMemory(memory, config.firstBlock);\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\t\t\tthis.pointerStack = new SharedStack(memory, {\n\t\t\t\tfirstBlock: getPointer(loadRawPointer(this.firstBlock.data, POINTER_STACK_INDEX)),\n\t\t\t});\n\t\t\tthis.recycleStack = new SharedStack(memory, {\n\t\t\t\tfirstBlock: getPointer(loadRawPointer(this.firstBlock.data, RECYCLE_STACK_INDEX)),\n\t\t\t});\n\t\t} else {\n\t\t\t// Inline both stacks' firstBlocks right after the pool header so the whole spine is one contiguous allocation\n\t\t\tthis.firstBlock = memory.allocUI32(SharedPool.ALLOCATE_COUNT + SharedStack.DEFAULT_ALLOCATE_COUNT * 2);\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\n\t\t\tlet dataLength = config?.dataLength ?? 1;\n\t\t\tlet maxLength = config?.maxChunkSize ?? 100;\n\n\t\t\tthis.pointerStack = new SharedStack(memory, {\n\t\t\t\tfirstBlock: this.firstBlock.getSubAllocation(SharedPool.ALLOCATE_COUNT, SharedStack.DEFAULT_ALLOCATE_COUNT),\n\t\t\t\ttype: Uint32Array,\n\t\t\t});\n\t\t\tstoreRawPointer(this.firstBlock.data, POINTER_STACK_INDEX, this.pointerStack.pointer);\n\t\t\tthis.recycleStack = new SharedStack(memory, {\n\t\t\t\tfirstBlock: this.firstBlock.getSubAllocation(SharedPool.ALLOCATE_COUNT + SharedStack.DEFAULT_ALLOCATE_COUNT, SharedStack.DEFAULT_ALLOCATE_COUNT),\n\t\t\t\ttype: Uint32Array,\n\t\t\t});\n\t\t\tstoreRawPointer(this.firstBlock.data, RECYCLE_STACK_INDEX, this.recycleStack.pointer);\n\n\t\t\tconst type = config?.type ?? Uint32Array;\n\t\t\tif(type === Uint32Array) {\n\t\t\t\tthis.type = TYPE.uint32;\n\t\t\t// @ts-expect-error\n\t\t\t} else if(type === Int32Array) {\n\t\t\t\tthis.type = TYPE.int32;\n\t\t\t// @ts-expect-error\n\t\t\t} else if(type === Float32Array) {\n\t\t\t\tthis.type = TYPE.float32;\n\t\t\t// @ts-expect-error\n\t\t\t} else if(type === Float64Array) {\n\t\t\t\tthis.type = TYPE.float64;\n\t\t\t}\n\t\t\tthis.dataLength = dataLength;\n\t\t\tthis.maxChunkSize = maxLength;\n\n\t\t\t// @ts-expect-error\n\t\t\tlet byteMultipler = type === Float64Array ? 2 : 1;\n\t\t\tlet firstArray = memory.allocUI32(maxLength * dataLength * byteMultipler);\n\t\t\tthis.pointerStack.push(firstArray.pointer);\n\t\t}\n\n\t\tthis.cachedType = this.uint16Array[0];\n\t\tthis.cachedDataLength = Math.max(1, this.uint16Array[1]);\n\t\tthis.cachedMaxChunkSize = this.firstBlock.data[MAX_CHUNK_SIZE_INDEX];\n\t\tthis.cachedByteMultipler = this.cachedType === TYPE.float64 ? 2 : 1;\n\n\t\tthis.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + GROW_LOCK_INDEX * Uint32Array.BYTES_PER_ELEMENT, 1);\n\t}\n\n\tat(index: number): T {\n\t\tlet dataBlock = this.getFullDataBlock(index);\n\t\treturn this.getDataBlock(dataBlock, index % this.cachedMaxChunkSize);\n\t}\n\tget(index: number, dataIndex = 0): number {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tif(dataIndex >= dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${dataLength}`);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(index);\n\t\treturn dataBlock[(index % this.cachedMaxChunkSize) * dataLength + dataIndex];\n\t}\n\n\tpush(values: number | Array<number>): number {\n\t\tlet dataLength = this.cachedDataLength;\n\t\tconst isSingleNumber = typeof values === 'number';\n\t\tif(!isSingleNumber && values.length > dataLength) {\n\t\t\tthrow new Error(`Can't insert ${values.length} array into shared list of ${dataLength} dataLength`);\n\t\t}\n\n\t\t// Reuse a recycled index if one is available. pop() can come back undefined when another thread drained the last\n\t\t// slot between our two calls, so fall through to a fresh index rather than trusting a length() read\n\t\tlet newIndex = this.recycleStack.pop();\n\t\tif(newIndex === undefined) {\n\t\t\tnewIndex = Atomics.add(this.firstBlock.data, LENGTH_INDEX, 1);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(newIndex);\n\t\tlet startIndex = dataLength * (newIndex % this.cachedMaxChunkSize);\n\t\tif(isSingleNumber) {\n\t\t\tdataBlock[startIndex] = values;\n\t\t} else {\n\t\t\tdataBlock.set(values, startIndex);\n\t\t}\n\n\t\treturn newIndex;\n\t}\n\n\tdeleteIndex(index: number) {\n\t\tthis.recycleStack.push(index);\n\t}\n\n\tclear() {\n\t\tthis.firstBlock.data[LENGTH_INDEX] = 0;\n\t\tthis.recycleStack.clear();\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycleStack) {\n\t\t\trecycledValues[value] = true;\n\t\t}\n\n\t\tconst maxChunkSize = this.cachedMaxChunkSize;\n\t\t// Snapshot the length once - iteration over a concurrently mutated pool is a snapshot anyway, and re-loading the\n\t\t// atomic every step is pure overhead\n\t\tconst length = Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < length; i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / maxChunkSize);\n\t\t\t\tif(newDataBlockIndex !== dataBlockIndex) {\n\t\t\t\t\tdataBlock = this.getFullDataBlock(i);\n\t\t\t\t\tdataBlockIndex = newDataBlockIndex;\n\t\t\t\t}\n\t\t\t\tyield this.getDataBlock(dataBlock, i % maxChunkSize);\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getFullDataBlock(index: number) {\n\t\tlet pointerIndex = Math.floor(index / this.cachedMaxChunkSize);\n\t\tlet cachedDataBlock = this.cachedFullDataBlock[pointerIndex];\n\t\tif(cachedDataBlock) {\n\t\t\treturn cachedDataBlock;\n\t\t}\n\t\tif(pointerIndex >= this.pointerStack.length) {\n\t\t\t// Only let a single thread append a new chunk at a time - otherwise two concurrent inserts landing in a new\n\t\t\t// chunk would each allocate + push a buffer, orphaning one and leaking memory\n\t\t\tlock(this.growLock);\n\t\t\ttry {\n\t\t\t\t// Re-check under the lock: another thread may have already appended the chunk while we were waiting\n\t\t\t\twhile(pointerIndex >= this.pointerStack.length) {\n\t\t\t\t\tlet newArray = this.memory.allocUI32(this.cachedMaxChunkSize * this.cachedDataLength * this.cachedByteMultipler);\n\t\t\t\t\tthis.pointerStack.push(newArray.pointer);\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tunlock(this.growLock);\n\t\t\t}\n\t\t}\n\n\t\tlet array = new AllocatedMemory(this.memory, getPointer(this.pointerStack.at(pointerIndex)));\n\n\t\tlet blockLength = this.cachedDataLength * this.cachedMaxChunkSize;\n\t\tlet data: T;\n\t\tswitch(this.cachedType) {\n\t\t\tcase TYPE.int32:\n\t\t\t\tdata = new Int32Array(array.data.buffer, array.bufferByteOffset, blockLength) as T;\n\t\t\t\tbreak;\n\t\t\tcase TYPE.uint32:\n\t\t\t\tdata = new Uint32Array(array.data.buffer, array.bufferByteOffset, blockLength) as T;\n\t\t\t\tbreak;\n\t\t\tcase TYPE.float32:\n\t\t\t\tdata = new Float32Array(array.data.buffer, array.bufferByteOffset, blockLength) as T;\n\t\t\t\tbreak;\n\t\t\tcase TYPE.float64:\n\t\t\t\tdata = new Float64Array(array.data.buffer, array.bufferByteOffset, blockLength) as T;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`Unknown data block type ${this.cachedType}`);\n\t\t}\n\n\t\tthis.cachedFullDataBlock[pointerIndex] = data;\n\t\treturn data;\n\t}\n\n\tprivate getDataBlock(rawData: T, index: number): T {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tconst start = index * dataLength;\n\t\treturn rawData.subarray(start, start + dataLength) as T;\n\t}\n\n\tfree() {\n\t\tthis.recycleStack.free();\n\n\t\tfor(let pointer of this.pointerStack) {\n\t\t\tlet memory = new AllocatedMemory(this.memory, getPointer(pointer));\n\t\t\tmemory.free();\n\t\t}\n\t\tthis.pointerStack.free();\n\t\tthis.firstBlock.free();\n\t}\n\n\tgetSharedMemory(): SharedPoolMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.firstBlock.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedPoolConfig<T extends Uint32Array | Int32Array | Float32Array | Float64Array> {\n\tmaxChunkSize?: number\n\ttype?: TypedArrayConstructor<T>\n\tdataLength?: number\n}\ninterface SharedPoolMemory {\n\tfirstBlock: SharedAllocatedMemory\n}\n\nexport type { SharedPoolConfig, SharedPoolMemory };\n"],"mappings":"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"}

package/dist/shared-stack.d.ts

@@ -0,0 +1,46 @@
+import type { SharedAllocatedMemory } from './allocated-memory';
+import AllocatedMemory from './allocated-memory';
+import type { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+import type MemoryHeap from './memory-heap';
+export default class SharedStack<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<number> {
+    static readonly BASE_ALLOCATE_COUNT = 7;
+    static readonly DEFAULT_ALLOCATE_COUNT: number;
+    private memory;
+    private firstBlock;
+    private uint16Array;
+    private growLock;
+    readonly maxLength: number;
+    private ownsFirstBlock;
+    private cachedSegments;
+    private cachedSequences;
+    private cachedBaseSegmentLength;
+    get length(): number;
+    get segmentCount(): number;
+    private set segmentCount(value);
+    get type(): number;
+    private set type(value);
+    get baseSegmentLength(): number;
+    private set baseSegmentLength(value);
+    get maxSegments(): number;
+    private set maxSegments(value);
+    get pointer(): number;
+    constructor(memory: MemoryHeap, config?: SharedStackConfig<T> | SharedStackMemory | (SharedStackMemory & SharedStackConfig<T>));
+    private initialize;
+    at(index: number): number;
+    push(value: number): number;
+    pop(): number | undefined;
+    clear(): void;
+    [Symbol.iterator](): Generator<number, void, unknown>;
+    private getSegment;
+    free(): void;
+    getSharedMemory(): SharedStackMemory;
+}
+interface SharedStackConfig<T extends Uint32Array | Int32Array | Float32Array> {
+    type?: TypedArrayConstructor<T>;
+    baseSegmentLength?: number;
+    segmentCount?: number;
+}
+interface SharedStackMemory {
+    firstBlock: SharedAllocatedMemory | AllocatedMemory;
+}
+export type { SharedStackConfig, SharedStackMemory };