@daneren2005/shared-memory-objects 0.0.7 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daneren2005/shared-memory-objects",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "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/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) {

package/src/utils/float32-atomics.ts

@@ -3,22 +3,24 @@ const buffer = new ArrayBuffer(4);
 const float32 = new Float32Array(buffer);
 const int32 = new Int32Array(buffer);
 
-function loadFloat32(data: Int32Array, index: number) {
+export function loadFloat32(data: Int32Array | Uint32Array, index: number) {
 	return convertInt32ToFloat32(Atomics.load(data, index));
 }
-function storeFloat32(data: Int32Array, index: number, value: number) {
+export function storeFloat32(data: Int32Array | Uint32Array, index: number, value: number) {
 	Atomics.store(data, index, convertFloat32ToInt32(value));
 }
 
-function convertInt32ToFloat32(value: number) {
+export function convertInt32ToFloat32(value: number) {
 	int32[0] = value;
 
 	return float32[0];
 }
-function convertFloat32ToInt32(value: number) {
+export function convertFloat32ToInt32(value: number) {
 	float32[0] = value;
 
 	return int32[0];
 }
 
-export { loadFloat32, storeFloat32, convertInt32ToFloat32, convertFloat32ToInt32 };
+export function exchangeFloat32(data: Int32Array | Uint32Array, index: number, value: number) {
+	return convertInt32ToFloat32(Atomics.exchange(data, index, convertFloat32ToInt32(value)));
+}