@daneren2005/shared-memory-objects 0.0.8 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daneren2005/shared-memory-objects",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "author": "daneren2005@gmail.com",
   "description": "Creating objects with a SharedArrayBuffer",
   "homepage": "https://github.com/daneren2005/shared-memory-objects#readme",

package/src/cached-item-list.ts

@@ -0,0 +1,143 @@
+import type { SharedAllocatedMemory } from './allocated-memory';
+import type MemoryHeap from './memory-heap';
+import SharedList, { type SharedListMemory } from './shared-list';
+
+export default abstract class CachedItemList<T extends Item> implements Iterable<{ item: T, deleteCurrent: () => void }> {
+	static readonly ALLOCATE_COUNT = SharedList.ALLOCATE_COUNT;
+
+	protected heap: MemoryHeap;
+	protected list: SharedList;
+	protected cache: Map<number, T> = new Map();
+
+	constructor(heap: MemoryHeap, config?: CachedListConfig | SharedListMemory) {
+		if(config) {
+			this.list = new SharedList(heap, config);
+		} else {
+			this.list = new SharedList(heap);
+		}
+		this.heap = heap;
+
+		this.list.onDelete = (pointerData: Uint32Array) => {
+			let pointer = Atomics.load(pointerData, 0);
+			if(pointer) {
+				let item = this.cache.get(pointer);
+				if(!item) {
+					item = this.initItem(pointer);
+				}
+
+				if(item) {
+					item.free();
+					this.cache.delete(pointer);
+				}
+			}
+		};
+	}
+
+	get length() {
+		return this.list.length;
+	}
+
+	clear() {
+		this.list.clear();
+		this.cache.clear();
+	}
+
+	insert(item: T) {
+		this.list.insert(item.pointer);
+		this.cache.set(item.pointer, item);
+	}
+	delete(item: T) {
+		this.cache.delete(item.pointer);
+		return this.list.deleteValue(item.pointer);
+	}
+
+	getByPointer(pointer: number): T | undefined {
+		let item = this.cache.get(pointer);
+		if(!item) {
+			item = this.initItem(pointer);
+			if(item) {
+				this.cache.set(pointer, item);
+			}
+		}
+
+		return item;
+	}
+	protected abstract initItem(pointer: number): T | undefined
+
+	*[Symbol.iterator]() {
+		let iterator = this.list[Symbol.iterator]();
+
+		for(let { data: pointerData, deleteCurrent } of iterator) {
+			let pointer = Atomics.load(pointerData, 0);
+			if(!pointer) {
+				continue;
+			}
+
+			let item = this.cache.get(pointer);
+			if(!item) {
+				item = this.initItem(pointer);
+				if(item) {
+					this.cache.set(pointer, item);
+				}
+			}
+
+			if(item) {
+				yield {
+					item,
+					deleteCurrent
+				};
+			}
+		}
+	}
+	forEach(callback: (item: T) => void, filter?: (item: T) => boolean) {
+		for(let { item } of this) {
+			if(!filter || filter(item)) {
+				callback(item);
+			}
+		}
+	}
+
+	find(callback: (item: T) => boolean): T | undefined {
+		for(let { item } of this) {
+			if(callback(item)) {
+				return item;
+			}
+		}
+	}
+	filter(callback: (entity: T) => boolean): Array<T> {
+		let items = [];
+		for(let { item } of this) {
+			if(callback(item)) {
+				items.push(item);
+			}
+		}
+
+		return items;
+	}
+	map<X>(callback: (item: T) => X): Array<X> {
+		const array: Array<X> = [];
+		for(let { item } of this) {
+			array.push(callback(item));
+		}
+
+		return array;
+	}
+
+	getSharedMemory() {
+		return this.list.getSharedMemory();
+	}
+
+	free() {
+		this.list.free();
+		this.cache.clear();
+	}
+}
+
+export interface CachedListConfig {
+	initWithBlock: SharedAllocatedMemory
+}
+
+interface Item {
+	pointer: number
+	free: () => void
+}

package/src/main.ts

@@ -7,6 +7,7 @@ import SharedMap, { type SharedMapMemory } from './shared-map';
 import SharedPointerList from './shared-pointer-list';
 import SharedString from './shared-string';
 import SharedVector, { type SharedVectorMemory } from './shared-vector';
+import CachedItemList, { type CachedListConfig } from './cached-item-list';
 
 export * from './interfaces/typed-array';
 export * from './interfaces/typed-array-constructor';
@@ -33,5 +34,7 @@ export {
 	SharedPointerList,
 	SharedString,
 	SharedVector,
-	type SharedVectorMemory
+	type SharedVectorMemory,
+	CachedItemList,
+	type CachedListConfig
 };

package/src/memory-buffer.ts

@@ -338,7 +338,7 @@ export default class MemoryBuffer {
 		this.state[STATE_ALIGN] = x;
 	}
 
-	protected get end() {
+	get end() {
 		return this.state[STATE_END];
 	}
 
@@ -346,7 +346,7 @@ export default class MemoryBuffer {
 		this.state[STATE_END] = x;
 	}
 
-	protected get top() {
+	get top() {
 		return Atomics.load(this.state, STATE_TOP);
 	}
 

package/src/memory-heap.ts

@@ -6,6 +6,7 @@ import MemoryBuffer from './memory-buffer';
 const DEFAULT_BUFFER_SIZE = 8_192;
 const BUFFER_SIZE_INDEX = 0;
 const BUFFER_COUNT_INDEX = 1;
+const BUFFER_AUTO_GROW_INDEX = 2;
 export default class MemoryHeap {
 	buffers: Array<MemoryBuffer>;
 	private onGrowBufferHandlers: Array<OnGrowBuffer> = [];
@@ -45,7 +46,7 @@ export default class MemoryHeap {
 			this.buffers = [
 				startBuffer
 			];
-			const data = startBuffer.callocAs('u32', 2);
+			const data = startBuffer.callocAs('u32', 3);
 			if(data) {
 				this.memory = new AllocatedMemory(this, {
 					bufferPosition: 0,
@@ -56,6 +57,7 @@ export default class MemoryHeap {
 			}
 			this.memory.data[BUFFER_SIZE_INDEX] = bufferSize;
 			this.memory.data[BUFFER_COUNT_INDEX] = 1;
+			this.memory.data[BUFFER_AUTO_GROW_INDEX] = config?.autoGrowSize ?? 100;
 			this.isClone = false;
 
 			for(let i = 1; i < (config?.initialBuffers ?? 1); i++) {
@@ -71,6 +73,18 @@ export default class MemoryHeap {
 		});
 	}
 
+	private growBuffer() {
+		const buffer = this.createBuffer();
+		let nextBufferPosition = Atomics.add(this.memory.data, BUFFER_COUNT_INDEX, 1);
+		// Setting index set by internal Atomic count so we can create new buffers from multiple threads and keep position consistent
+		this.buffers[nextBufferPosition] = buffer;
+		this.onGrowBufferHandlers.forEach(handler => handler({
+			bufferPosition: nextBufferPosition,
+			buffer: buffer.buf as SharedArrayBuffer
+		}));
+
+		return buffer;
+	}
 	private createBuffer(bufferSize?: number): MemoryBuffer {
 		const usedBufferSize = bufferSize ?? this.bufferSize;
 		let buf: ArrayBuffer | SharedArrayBuffer;
@@ -107,6 +121,14 @@ export default class MemoryHeap {
 			// Should be fine to initialize all values as 0s since unsigned/signed ints and floats all store 0 as all 0s
 			const data = buffer.callocAs('u32', count);
 			if(data) {
+				// Auto grow when nearly full when we need buffer to already be sync'd between threads BEFORE we try to use it
+				if(i === (this.buffers.length - 1) && Atomics.load(this.memory.data, BUFFER_COUNT_INDEX) === this.buffers.length && this.memory.data[BUFFER_AUTO_GROW_INDEX] < 100 && this.memory.data[BUFFER_AUTO_GROW_INDEX] > 0) {
+					const percentFull = buffer.top / buffer.end;
+					if(percentFull > (this.memory.data[BUFFER_AUTO_GROW_INDEX] / 100)) {
+						this.growBuffer();
+					}
+				}
+
 				return new AllocatedMemory(this, {
 					data,
 					buffer
@@ -119,15 +141,7 @@ export default class MemoryHeap {
 		}
 
 		// If we get here we need to grow another buffer to continue allocating new memory
-		const buffer = this.createBuffer();
-		let nextBufferPosition = Atomics.add(this.memory.data, BUFFER_COUNT_INDEX, 1);
-		// Setting index set by internal Atomic count so we can create new buffers from multiple threads and keep position consistent
-		this.buffers[nextBufferPosition] = buffer;
-		this.onGrowBufferHandlers.forEach(handler => handler({
-			bufferPosition: nextBufferPosition,
-			buffer: buffer.buf as SharedArrayBuffer
-		}));
-
+		let buffer = this.growBuffer();
 		const data = buffer.callocAs('u32', count);
 		if(data) {
 			return new AllocatedMemory(this, {
@@ -183,6 +197,7 @@ interface GrowBufferData {
 interface MemoryHeapConfig {
 	bufferSize?: number
 	initialBuffers?: number
+	autoGrowSize?: number
 }
 interface MemoryHeapMemory {
 	buffers: Array<SharedArrayBuffer>

package/src/shared-list.ts

@@ -39,6 +39,7 @@ export default class SharedList<T extends Uint32Array | Int32Array | Float32Arra
 	*/
 	private firstBlock: AllocatedMemory;
 	private uint16Array: Uint16Array;
+	onDelete?: (data: T) => void;
 
 	get length(): number {
 		return Atomics.load(this.firstBlock.data, LENGTH_INDEX);
@@ -169,6 +170,54 @@ export default class SharedList<T extends Uint32Array | Int32Array | Float32Arra
 		}
 	}
 
+	clear() {
+		let firstBlockPointer, lastBlockPointer;
+		let updateWorked = false;
+		while(!updateWorked) {
+			firstBlockPointer = loadRawPointer(this.firstBlock.data, 0);
+			lastBlockPointer = loadRawPointer(this.firstBlock.data, 1);
+			// Already cleared
+			if(!lastBlockPointer) {
+				return;
+			}
+
+			updateWorked = replaceRawPointer(this.firstBlock.data, 1, 0, lastBlockPointer);
+		}
+		
+		// Shouldn't be possible to hit: making Typescript happy
+		if(!firstBlockPointer) {
+			return;
+		}
+
+		// We only want to update the last block if this is ran before something new was inserted
+		replaceRawPointer(this.firstBlock.data, 0, 0, firstBlockPointer);
+
+		// Iterate through  inaccessible nodes and delete them
+		let deletedItems = 0;
+		let nextBlockPointer = firstBlockPointer;
+		while(nextBlockPointer) {
+			let { bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = getPointer(nextBlockPointer);
+			let memPool = this.memory.buffers[nextBlockPosition];
+			// Short circuit iterations if we can't access memory
+			if(!memPool) {
+				break;
+			}
+
+			let blockRecord = new Uint32Array(memPool.buf, nextBlockByteOffset, 2);
+			nextBlockPointer = loadRawPointer(blockRecord, 0);
+			deletedItems++;
+
+			if(this.onDelete) {
+				this.onDelete(this.getDataBlock(blockRecord));
+			}
+
+			memPool.free(blockRecord.byteOffset);
+		}
+		
+		// Subtract by however many we deleted so that a insert during this operation is accurate
+		Atomics.sub(this.firstBlock.data, LENGTH_INDEX, deletedItems);
+	}
+
 	*[Symbol.iterator]() {
 		let currentIndex = 0;
 		let { bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = loadPointer(this.firstBlock.data, 0);
@@ -202,6 +251,10 @@ export default class SharedList<T extends Uint32Array | Int32Array | Float32Arra
 						storePointer(this.firstBlock.data, 1, lastBlockPosition, lastBlockByteOffset);
 					}
 
+					if(this.onDelete) {
+						this.onDelete(this.getDataBlock(blockRecord));
+					}
+
 					memPool.free(blockRecord.byteOffset);
 					Atomics.sub(this.firstBlock.data, LENGTH_INDEX, 1);
 					updateLastBlock = false;
@@ -256,6 +309,11 @@ export default class SharedList<T extends Uint32Array | Int32Array | Float32Arra
 			});
 
 			({ bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = loadPointer(allocatedMemory.data, 0));
+
+			if(this.onDelete) {
+				this.onDelete(this.getDataBlock(allocatedMemory.data));
+			}
+
 			allocatedMemory.free();
 		}
 

package/src/shared-string.ts

@@ -125,6 +125,10 @@ export default class SharedString {
 		return this.allocatedMemory.getSharedMemory();
 	}
 
+	get pointer() {
+		return this.allocatedMemory.pointer;
+	}
+
 	free() {
 		let { bufferPosition, bufferByteOffset } = loadPointer(this.allocatedMemory.data, POINTER_INDEX);
 		if(bufferByteOffset) {