@daneren2005/shared-memory-objects 1.1.0 → 1.3.0

package/dist/shared-pool.js

@@ -1,165 +1,152 @@
-import f from "./allocated-memory.js";
-import s from "./shared-vector.js";
-import { getPointer as n } from "./utils/pointer.js";
-const o = 0, c = 1, u = 2, l = 3, y = l + s.ALLOCATE_COUNT;
-class k {
-  static ALLOCATE_COUNT = 3 + s.ALLOCATE_COUNT * 2;
-  memory;
-  // Current Length, Type/DataLength, MaxChunkLength, Pointer vector, Recycle vector
-  firstBlock;
-  uint16Array;
-  pointerVector;
-  recycleVector;
-  cachedFullDataBlock = {};
-  get length() {
-    return Atomics.load(this.firstBlock.data, o) - this.recycleVector.length;
-  }
-  get maxChunkSize() {
-    return this.firstBlock.data[u];
-  }
-  set maxChunkSize(t) {
-    Atomics.store(this.firstBlock.data, u, t);
-  }
-  get type() {
-    return this.uint16Array[0];
-  }
-  set type(t) {
-    Atomics.store(this.uint16Array, 0, t);
-  }
-  get dataLength() {
-    return Math.max(1, this.uint16Array[1]);
-  }
-  set dataLength(t) {
-    Atomics.store(this.uint16Array, 1, t);
-  }
-  get bufferLength() {
-    return this.maxChunkSize * this.pointerVector.length;
-  }
-  get recycleBufferLength() {
-    return this.recycleVector.bufferLength;
-  }
-  get byteMultipler() {
-    return this.type === 3 ? 2 : 1;
-  }
-  constructor(t, e) {
-    if (this.memory = t, e && "firstBlock" in e)
-      this.firstBlock = new f(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + c * Uint32Array.BYTES_PER_ELEMENT, 2), this.pointerVector = new s(t, {
-        firstBlock: {
-          bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + l * Uint32Array.BYTES_PER_ELEMENT
-        }
-      }), this.recycleVector = new s(t, {
-        firstBlock: {
-          bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + y * Uint32Array.BYTES_PER_ELEMENT
-        }
-      });
-    else {
-      this.firstBlock = t.allocUI32(k.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + c * Uint32Array.BYTES_PER_ELEMENT, 2);
-      let i = e?.dataLength ?? 1, r = e?.maxChunkSize ?? 100;
-      this.pointerVector = new s(t, {
-        type: Uint32Array,
-        firstBlock: {
-          bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + l * Uint32Array.BYTES_PER_ELEMENT
-        }
-      }), this.recycleVector = new s(t, {
-        type: Uint32Array,
-        firstBlock: {
-          bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + y * Uint32Array.BYTES_PER_ELEMENT
-        },
-        bufferLength: e?.recycleBufferLength
-      });
-      const a = e?.type ?? Uint32Array;
-      a === Uint32Array ? this.type = 0 : a === Int32Array ? this.type = 1 : a === Float32Array ? this.type = 2 : a === Float64Array && (this.type = 3), this.dataLength = i, this.maxChunkSize = r;
-      let h = t.allocUI32(r * i * this.byteMultipler);
-      this.pointerVector.push(h.pointer);
-    }
-  }
-  at(t) {
-    let e = this.getFullDataBlock(t);
-    return this.getDataBlock(e, t % this.maxChunkSize);
-  }
-  get(t, e = 0) {
-    const i = this.dataLength;
-    if (e >= i)
-      throw new Error(`${e} is out of dataLength bounds ${i}`);
-    return this.getFullDataBlock(t)[t % this.maxChunkSize * i + e];
-  }
-  push(t) {
-    typeof t == "number" && (t = [t]);
-    let e = this.dataLength;
-    if (t.length > e)
-      throw new Error(`Can't insert ${t.length} array into shared list of ${e} dataLength`);
-    let i;
-    this.recycleVector.length ? i = this.recycleVector.popNumber() : i = Atomics.add(this.firstBlock.data, o, 1);
-    let r = this.getFullDataBlock(i), a = i % this.maxChunkSize;
-    return r.set(t, e * a), i;
-  }
-  deleteIndex(t) {
-    this.recycleVector.push(t);
-  }
-  clear() {
-    this.firstBlock.data[o] = 0, this.recycleVector.clear();
-  }
-  *[Symbol.iterator]() {
-    const t = {};
-    for (let r of this.recycleVector)
-      t[r[0]] = !0;
-    let e = this.getFullDataBlock(0), i = 0;
-    for (let r = 0; r < Atomics.load(this.firstBlock.data, o); r++)
-      if (!t[r]) {
-        let a = Math.floor(r / this.maxChunkSize);
-        a !== i && (e = this.getFullDataBlock(r), i = a), yield this.getDataBlock(e, r % this.maxChunkSize);
-      }
-  }
-  getFullDataBlock(t) {
-    let e = Math.floor(t / this.maxChunkSize), i = this.cachedFullDataBlock[e];
-    if (i)
-      return i;
-    if (e >= this.pointerVector.length) {
-      let h = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
-      this.pointerVector.push(h.pointer);
-    }
-    let r = new f(this.memory, n(this.pointerVector.get(e))), a;
-    switch (this.type) {
-      case 1:
-        a = new Int32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.maxChunkSize);
-        break;
-      case 0:
-        a = new Uint32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.maxChunkSize);
-        break;
-      case 2:
-        a = new Float32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.maxChunkSize);
-        break;
-      case 3:
-        a = new Float64Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.maxChunkSize);
-        break;
-      default:
-        throw new Error(`Unknown data block type ${this.type}`);
-    }
-    return this.cachedFullDataBlock[e] = a, a;
-  }
-  getDataBlock(t, e) {
-    const i = e * this.dataLength;
-    return t.subarray(i, i + this.dataLength);
-  }
-  free() {
-    this.recycleVector.free();
-    for (let t of this.pointerVector) {
-      let e = t[0];
-      new f(this.memory, n(e)).free();
-    }
-    this.pointerVector.free(), this.firstBlock.free();
-  }
-  getSharedMemory() {
-    return {
-      firstBlock: this.firstBlock.getSharedMemory()
-    };
-  }
-}
-export {
-  k as default
+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 = 100, m = 1e6, h = 1e5, g = class g {
+	static ALLOCATE_COUNT = 6;
+	memory;
+	firstBlock;
+	uint16Array;
+	growLock;
+	pointerStack;
+	recycleStack;
+	maxLength;
+	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;
+	}
+	get usedMemory() {
+		let t = this.firstBlock.usedMemory;
+		for (let n of this.pointerStack) t += new r(this.memory, e(n)).usedMemory;
+		return t + this.pointerStack.usedMemory + this.recycleStack.usedMemory;
+	}
+	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 {
+			let e = a?.dataLength ?? 1, t = a?.maxChunkSize ?? p, r = a?.maxLength ?? m, s = a?.maxRecycledLength ?? h, l = o.getMaxSegmentLength(i.maxAllocationLength), u = r / t, _ = o.getAllocateCount(u, void 0, l), v = o.getAllocateCount(s, void 0, l);
+			this.firstBlock = i.allocUI32(g.ALLOCATE_COUNT + _ + v), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + c * Uint32Array.BYTES_PER_ELEMENT, 2), this.pointerStack = new o(i, {
+				firstBlock: this.firstBlock.getSubAllocation(g.ALLOCATE_COUNT, _),
+				type: Uint32Array,
+				maxLength: u
+			}), n(this.firstBlock.data, d, this.pointerStack.pointer), this.recycleStack = new o(i, {
+				firstBlock: this.firstBlock.getSubAllocation(g.ALLOCATE_COUNT + _, v),
+				type: Uint32Array,
+				maxLength: s
+			}), n(this.firstBlock.data, f, this.recycleStack.pointer);
+			let y = a?.type ?? Uint32Array;
+			y === Uint32Array ? this.type = 0 : y === Int32Array ? this.type = 1 : y === Float32Array ? this.type = 2 : y === Float64Array && (this.type = 3), this.dataLength = e, this.maxChunkSize = t;
+			let b = y === Float64Array ? 2 : 1, x = i.allocUI32(t * e * b);
+			this.pointerStack.push(x.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.maxLength = this.cachedMaxChunkSize * this.pointerStack.maxLength, 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() };
+	}
 };
-//# sourceMappingURL=shared-pool.js.map
+//#endregion
+export { g as default };
+
+//# sourceMappingURL=shared-pool.js.map

package/dist/shared-pool.js.map

@@ -1 +1 @@
-{"version":3,"file":"shared-pool.js","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 type MemoryHeap from './memory-heap';\nimport SharedVector from './shared-vector';\nimport { getPointer } 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;\nconst POINTERS_INDEX = 3;\nconst RECYCLE_INDEX = POINTERS_INDEX + SharedVector.ALLOCATE_COUNT;\n\n// Array with stable indexes and maximum contiguous memory sizes (necessary to fit large data sets into max 1MB buffers)\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 = 3 + SharedVector.ALLOCATE_COUNT * 2;\n\tprivate memory: MemoryHeap;\n\n\t// Current Length, Type/DataLength, MaxChunkLength, Pointer vector, Recycle vector\n\tprivate firstBlock: AllocatedMemory;\n\tprivate uint16Array: Uint16Array;\n\tprivate pointerVector: SharedVector<Uint32Array>;\n\tprivate recycleVector: SharedVector<Uint32Array>;\n\n\tprivate cachedFullDataBlock: { [key: number]: T } = {};\n\n\tget length(): number {\n\t\treturn Atomics.load(this.firstBlock.data, LENGTH_INDEX) - this.recycleVector.length;\n\t}\n\tget maxChunkSize(): number {\n\t\treturn this.firstBlock.data[MAX_CHUNK_SIZE_INDEX];\n\t}\n\tprivate set maxChunkSize(value: number) {\n\t\tAtomics.store(this.firstBlock.data, MAX_CHUNK_SIZE_INDEX, value);\n\t}\n\t\n\tget type(): number {\n\t\treturn 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\treturn Math.max(1, this.uint16Array[1]);\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.maxChunkSize * this.pointerVector.length;\n\t}\n\tget recycleBufferLength(): number {\n\t\treturn this.recycleVector.bufferLength;\n\t}\n\tget byteMultipler(): number {\n\t\tif(this.type === TYPE.float64) {\n\t\t\treturn 2;\n\t\t} else {\n\t\t\treturn 1;\n\t\t}\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.pointerVector = new SharedVector(memory, {\n\t\t\t\tfirstBlock: {\n\t\t\t\t\tbufferPosition: this.firstBlock.bufferPosition,\n\t\t\t\t\tbufferByteOffset: this.firstBlock.bufferByteOffset + POINTERS_INDEX * Uint32Array.BYTES_PER_ELEMENT\n\t\t\t\t}\n\t\t\t});\n\t\t\tthis.recycleVector = new SharedVector(memory, {\n\t\t\t\tfirstBlock: {\n\t\t\t\t\tbufferPosition: this.firstBlock.bufferPosition,\n\t\t\t\t\tbufferByteOffset: this.firstBlock.bufferByteOffset + RECYCLE_INDEX * Uint32Array.BYTES_PER_ELEMENT\n\t\t\t\t}\n\t\t\t});\n\t\t} else {\n\t\t\tthis.firstBlock = memory.allocUI32(SharedPool.ALLOCATE_COUNT);\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.pointerVector = new SharedVector(memory, {\n\t\t\t\ttype: Uint32Array,\n\t\t\t\tfirstBlock: {\n\t\t\t\t\tbufferPosition: this.firstBlock.bufferPosition,\n\t\t\t\t\tbufferByteOffset: this.firstBlock.bufferByteOffset + POINTERS_INDEX * Uint32Array.BYTES_PER_ELEMENT\n\t\t\t\t}\n\t\t\t});\n\t\t\tthis.recycleVector = new SharedVector(memory, {\n\t\t\t\ttype: Uint32Array,\n\t\t\t\tfirstBlock: {\n\t\t\t\t\tbufferPosition: this.firstBlock.bufferPosition,\n\t\t\t\t\tbufferByteOffset: this.firstBlock.bufferByteOffset + RECYCLE_INDEX * Uint32Array.BYTES_PER_ELEMENT\n\t\t\t\t},\n\t\t\t\tbufferLength: config?.recycleBufferLength\n\t\t\t});\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}\n\t\t\t// @ts-expect-error\n\t\t\telse if(type === Int32Array) {\n\t\t\t\tthis.type = TYPE.int32;\n\t\t\t}\n\t\t\t// @ts-expect-error\n\t\t\telse 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\tlet firstArray = memory.allocUI32(maxLength * dataLength * this.byteMultipler);\n\t\t\tthis.pointerVector.push(firstArray.pointer);\n\t\t}\n\t}\n\n\tat(index: number): T {\n\t\tlet dataBlock = this.getFullDataBlock(index);\n\t\treturn this.getDataBlock(dataBlock, index % this.maxChunkSize);\n\t}\n\tget(index: number, dataIndex = 0): number {\n\t\tconst dataLength = this.dataLength;\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.maxChunkSize) * dataLength + dataIndex];\n\t}\n\n\tpush(values: number | Array<number>): 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\n\t\tlet newIndex;\n\t\tif(this.recycleVector.length) {\n\t\t\tnewIndex = this.recycleVector.popNumber();\n\t\t} else {\n\t\t\tnewIndex = Atomics.add(this.firstBlock.data, LENGTH_INDEX, 1);\n\t\t}\n\t\t\n\t\tlet dataBlock = this.getFullDataBlock(newIndex);\n\t\tlet blockIndex = newIndex % this.maxChunkSize;\n\t\tdataBlock.set(values, dataLength * blockIndex);\n\n\t\treturn newIndex;\n\t}\n\n\tdeleteIndex(index: number) {\n\t\tthis.recycleVector.push(index);\n\t}\n\n\tclear() {\n\t\tthis.firstBlock.data[LENGTH_INDEX] = 0;\n\t\tthis.recycleVector.clear();\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycleVector) {\n\t\t\trecycledValues[value[0]] = true;\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < Atomics.load(this.firstBlock.data, LENGTH_INDEX); i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / this.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 % this.maxChunkSize);\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getFullDataBlock(index: number) {\n\t\tlet pointerIndex = Math.floor(index / this.maxChunkSize);\n\t\tlet cachedDataBlock = this.cachedFullDataBlock[pointerIndex];\n\t\tif(cachedDataBlock) {\n\t\t\treturn cachedDataBlock;\n\t\t}\n\t\tif(pointerIndex >= this.pointerVector.length) {\n\t\t\tlet newArray = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);\n\t\t\tthis.pointerVector.push(newArray.pointer);\n\t\t}\n\n\t\tlet array = new AllocatedMemory(this.memory, getPointer(this.pointerVector.get(pointerIndex)));\n\n\t\tlet data: T;\n\t\tswitch(this.type) {\n\t\t\tcase TYPE.int32:\n\t\t\t\tdata = new Int32Array(array.data.buffer, array.bufferByteOffset, this.dataLength * this.maxChunkSize) 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, this.dataLength * this.maxChunkSize) 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, this.dataLength * this.maxChunkSize) 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, this.dataLength * this.maxChunkSize) as T;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`Unknown data block type ${this.type}`);\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 start = index * this.dataLength;\n\t\treturn rawData.subarray(start, start + this.dataLength) as T;\n\t}\n\n\tfree() {\n\t\tthis.recycleVector.free();\n\n\t\tfor(let pointerArray of this.pointerVector) {\n\t\t\tlet pointer = pointerArray[0];\n\t\t\tlet memory = new AllocatedMemory(this.memory, getPointer(pointer));\n\t\t\tmemory.free();\n\t\t}\n\t\tthis.pointerVector.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\trecycleBufferLength?: number\n}\ninterface SharedPoolMemory {\n\tfirstBlock: SharedAllocatedMemory\n}\n\nexport type { SharedPoolConfig, SharedPoolMemory };"],"names":["LENGTH_INDEX","TYPE_INDEX","MAX_CHUNK_SIZE_INDEX","POINTERS_INDEX","RECYCLE_INDEX","SharedVector","SharedPool","value","memory","config","AllocatedMemory","dataLength","maxLength","type","firstArray","index","dataBlock","dataIndex","values","newIndex","blockIndex","recycledValues","dataBlockIndex","i","newDataBlockIndex","pointerIndex","cachedDataBlock","newArray","array","getPointer","data","rawData","start","pointerArray","pointer"],"mappings":"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"}
+{"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\nconst DEFAULT_MAX_CHUNK_SIZE = 100;\nconst DEFAULT_MAX_LENGTH = 1_000_000;\nconst DEFAULT_MAX_RECYCLED_LENGTH = 100_000;\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\treadonly maxLength: number;\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\t// Own internal memory (which already includes both stacks' inlined firstBlocks) plus every chunk buffer and the\n\t// segments each stack has grown. The stacks' usedMemory excludes their inlined firstBlocks, so they aren't double-counted.\n\tget usedMemory(): number {\n\t\tlet total = this.firstBlock.usedMemory;\n\t\tfor(let pointer of this.pointerStack) {\n\t\t\ttotal += new AllocatedMemory(this.memory, getPointer(pointer)).usedMemory;\n\t\t}\n\t\treturn total + this.pointerStack.usedMemory + this.recycleStack.usedMemory;\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\tlet dataLength = config?.dataLength ?? 1;\n\t\t\tlet maxChunkSize = config?.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;\n\t\t\tlet maxLength = config?.maxLength ?? DEFAULT_MAX_LENGTH;\n\t\t\tlet maxRecycledLength = config?.maxRecycledLength ?? DEFAULT_MAX_RECYCLED_LENGTH;\n\n\t\t\t// Each stack sizes its inlined firstBlock from its own maxLength, so compute both up front to lay them out. The\n\t\t\t// stacks cap their segments at what a buffer can hold, so size the inlined blocks against that same cap.\n\t\t\tlet maxSegmentLength = SharedStack.getMaxSegmentLength(memory.maxAllocationLength);\n\t\t\tlet pointerStackMaxLength = maxLength / maxChunkSize;\n\t\t\tlet pointerStackAllocateCount = SharedStack.getAllocateCount(pointerStackMaxLength, undefined, maxSegmentLength);\n\t\t\tlet recycleStackAllocateCount = SharedStack.getAllocateCount(maxRecycledLength, undefined, maxSegmentLength);\n\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 + pointerStackAllocateCount + recycleStackAllocateCount);\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\tthis.pointerStack = new SharedStack(memory, {\n\t\t\t\tfirstBlock: this.firstBlock.getSubAllocation(SharedPool.ALLOCATE_COUNT, pointerStackAllocateCount),\n\t\t\t\ttype: Uint32Array,\n\t\t\t\tmaxLength: pointerStackMaxLength,\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 + pointerStackAllocateCount, recycleStackAllocateCount),\n\t\t\t\ttype: Uint32Array,\n\t\t\t\tmaxLength: maxRecycledLength,\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 = maxChunkSize;\n\n\t\t\t// @ts-expect-error\n\t\t\tlet byteMultipler = type === Float64Array ? 2 : 1;\n\t\t\tlet firstArray = memory.allocUI32(maxChunkSize * 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\t\tthis.maxLength = this.cachedMaxChunkSize * this.pointerStack.maxLength;\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\tmaxLength?: number\n\tmaxRecycledLength?: 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,59 @@
+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 = 8;
+    static readonly DEFAULT_ALLOCATE_COUNT: number;
+    static getMaxSegmentLength(maxAllocationLength: number, baseSegmentLength?: number): number;
+    static getMaxSegments(maxLength: number, baseSegmentLength?: number, maxSegmentLength?: number): number;
+    static getCapacity(segments: number, baseSegmentLength?: number, maxSegmentLength?: number): number;
+    static getAllocateCount(maxLength: number, baseSegmentLength?: number, maxSegmentLength?: number): number;
+    private memory;
+    private firstBlock;
+    private uint16Array;
+    private growLock;
+    readonly maxLength: number;
+    private ownsFirstBlock;
+    private cachedSegments;
+    private cachedSequences;
+    private cachedBaseSegmentLength;
+    private cachedMaxSegmentLength;
+    private cachedCapSegmentCount;
+    private cachedGeometricCapacity;
+    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 maxSegmentLength(): number;
+    private set maxSegmentLength(value);
+    get pointer(): number;
+    get usedMemory(): number;
+    constructor(memory: MemoryHeap, config?: SharedStackConfig<T> | SharedStackMemory | (SharedStackMemory & SharedStackConfig<T>));
+    private resolveMaxSegmentLength;
+    private resolveMaxSegments;
+    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;
+    maxLength?: number;
+    maxSegmentLength?: number;
+}
+interface SharedStackMemory {
+    firstBlock: SharedAllocatedMemory | AllocatedMemory;
+}
+export type { SharedStackConfig, SharedStackMemory };