@daneren2005/shared-memory-objects 0.0.0 → 0.0.1

package/src/memory-heap.ts

@@ -0,0 +1,149 @@
+import AllocatedMemory from './allocated-memory';
+import prettyBytes from 'pretty-bytes';
+import { MAX_BYTE_OFFSET_LENGTH, MAX_POSITION_LENGTH } from './utils/pointer';
+import MemoryBuffer from './memory-buffer';
+
+// TODO: Once we are certain this behaves correctly we should probably up to something like 1MB - we will have a ton of entities so don't want to waste time allocating new buffers constantly
+const DEFAULT_BUFFER_SIZE = 8_192;
+export default class MemoryHeap {
+	buffers: Array<MemoryBuffer>;
+	onGrowBufferHandlers: Array<OnGrowBuffer> = [];
+	isClone: boolean;
+	private memory: AllocatedMemory;
+
+	get bufferSize() {
+		return this.memory.data[0];
+	}
+
+	constructor(config?: MemoryHeapConfig | MemoryHeapMemory) {
+		if(config && 'buffers' in config) {
+			this.buffers = config.buffers.map(buffer => {
+				return new MemoryBuffer({
+					buf: buffer,
+					skipInitialization: true
+				});
+			});
+
+			// TODO: This should be programic instead of hoping the first allocation is always byte 40
+			this.memory = new AllocatedMemory(this, {
+				bufferPosition: 0,
+				bufferByteOffset: 40
+			});
+			this.isClone = true;
+		} else {
+			const bufferSize = config?.bufferSize ?? DEFAULT_BUFFER_SIZE;
+			if(bufferSize > MAX_BYTE_OFFSET_LENGTH) {
+				throw new Error(`Buffer size ${bufferSize} is greater than max ${MAX_BYTE_OFFSET_LENGTH} that we can reference with pointers`);
+			}
+			
+			let startBuffer = this.createBuffer(bufferSize);
+			this.buffers = [
+				startBuffer
+			];
+			const data = startBuffer.callocAs('u32', 1);
+			if(data) {
+				this.memory = new AllocatedMemory(this, {
+					bufferPosition: 0,
+					bufferByteOffset: data.byteOffset
+				});
+			} else {
+				throw new Error('Failed to initialize first byte from buffer');
+			}
+			this.memory.data[0] = bufferSize;
+			this.isClone = false;
+
+			for(let i = 1; i < (config?.initialBuffers ?? 1); i++) {
+				this.buffers.push(this.createBuffer(bufferSize));
+			}
+		}
+	}
+
+	addSharedBuffer(buffer: SharedArrayBuffer) {
+		this.buffers.push(new MemoryBuffer({
+			buf: buffer,
+			skipInitialization: true
+		}));
+	}
+
+	private createBuffer(bufferSize?: number): MemoryBuffer {
+		if(this.isClone) {
+			throw new Error('Creating new buffer from worker threads not currently supported');
+		}
+
+		// TODO: Look into if we should turn off splitting - I think memory is going to get fragmented really quick if we free an Entity with 100 bytes and re-allocate a new one with 80 bytes and just lose the rest
+		//       As we add stuff like ListMemory that does tons of small allocations that might be fine since they can fill in any small space we have
+		return new MemoryBuffer({
+			buf: new SharedArrayBuffer(bufferSize ?? this.bufferSize)
+		});
+	}
+
+	allocUI32(count: number): AllocatedMemory {
+		for(let i = 0; i < this.buffers.length; i++) {
+			const buffer = this.buffers[i];
+			// 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) {
+				return new AllocatedMemory(this, {
+					data,
+					buffer
+				});
+			}
+		}
+
+		if(this.buffers.length >= MAX_POSITION_LENGTH) {
+			throw new Error(`Can't initialize a new buffer since it would have a position greater than the max of ${MAX_POSITION_LENGTH}`);
+		}
+
+		// If we get here we need to grow another buffer to continue allocating new memory
+		const buffer = this.createBuffer();
+		this.buffers.push(buffer);
+		this.onGrowBufferHandlers.forEach(handler => handler(buffer.buf as SharedArrayBuffer));
+
+		const data = buffer.callocAs('u32', count);
+		if(data) {
+			return new AllocatedMemory(this, {
+				data,
+				buffer
+			});
+		} else {
+			throw new Error(`Unable to allocate ${count} numbers even after adding a new buffer`);
+		}
+	}
+
+	get currentUsed() {
+		return this.totalAllocated - this.buffers.reduce((total, memPool) => total + memPool.stats().available, 0);
+	}
+	get totalAllocated() {
+		return this.buffers[0].buf.byteLength * this.buffers.length;
+	}
+
+	prettyMemory() {
+		return `${myPrettyBytes(this.currentUsed)} / ${myPrettyBytes(this.totalAllocated)}`;
+	}
+
+	getSharedMemory(): MemoryHeapMemory {
+		return {
+			buffers: this.buffers.map(buffer => buffer.buf as SharedArrayBuffer)
+		};
+	}
+}
+
+function myPrettyBytes(bytes: number) {
+	return prettyBytes(bytes, {
+		binary: true,
+		minimumFractionDigits: 1,
+		maximumFractionDigits: 1
+	});
+}
+
+type OnGrowBuffer = (newBuffer: SharedArrayBuffer) => void;
+
+interface MemoryHeapConfig {
+	bufferSize?: number
+	initialBuffers?: number
+}
+interface MemoryHeapMemory {
+	buffers: Array<SharedArrayBuffer>
+}
+
+export type { MemoryHeapConfig, MemoryHeapMemory };

package/src/serialize-object.ts

@@ -0,0 +1,95 @@
+import AllocatedMemory from './allocated-memory';
+import type MemoryHeap from './memory-heap';
+import { getPointer } from './utils/pointer';
+
+enum VALUE_TYPE {
+	UNDEFINED,
+	NUMBER,
+	STRING
+}
+
+// Be able to serialize a simple object into memory and re-create the object in another thread
+// This does NOT support updating objects across threads
+const MAGIC_NUMBER = 52361700;
+export function serializeObjectToMemory<T extends object>(heap: MemoryHeap, object: T): AllocatedMemory {
+	const data: Array<number> = [];
+	const keys = Object.keys(object);
+	data.push(MAGIC_NUMBER);
+	data.push(keys.length);
+
+	// Create index first so we can quickly construct index
+	let keyIndexes: { [key:string]:number } = {};
+	keys.forEach(key => {
+		data.push(key.length);
+		addCharCodes(data, key);
+
+		keyIndexes[key] = data.length;
+		data.push(0);
+	});
+
+	keys.forEach(key => {
+		let keyIndex = keyIndexes[key];
+		// @ts-expect-error
+		let value = object[key];
+		if(Number.isFinite(value)) {
+			data[keyIndex] = data.length;
+			data.push(VALUE_TYPE.NUMBER);
+			data.push(value);
+		} else if(typeof value === 'string') {
+			data[keyIndex] = data.length;
+			data.push(VALUE_TYPE.STRING);
+			data.push(value.length);
+			addCharCodes(data, value);
+		}
+	});
+	
+	let memory = heap.allocUI32(data.length);
+	let sharedData = memory.getArray(Float32Array, 0, data.length);
+	sharedData.set(data);
+
+	return memory;
+}
+
+export function createObjectFromPointer<T extends object>(heap: MemoryHeap, pointer: number) {
+	let memory = new AllocatedMemory(heap, getPointer(pointer));
+	return createObjectFromMemory<T>(memory);
+}
+export function createObjectFromMemory<T extends object>(memory: AllocatedMemory): T {
+	let sharedData = new Float32Array(memory.data.buffer, memory.bufferByteOffset);
+	if(sharedData[0] !== MAGIC_NUMBER) {
+		throw new Error('Trying to create object from invalid memory location');
+	}
+
+	const sharedObject: { [key:string]:any } = {};
+	const keyCount = sharedData[1];
+	let keyStartIndex = 2;
+	for(let i = 0; i < keyCount; i++) {
+		let keyLength = sharedData[keyStartIndex];
+		let keyData = new Float32Array(memory.data.buffer, memory.bufferByteOffset + (keyStartIndex + 1) * sharedData.BYTES_PER_ELEMENT, keyLength);
+		let key = String.fromCharCode.apply(null, [...keyData]);
+		let valueIndex = sharedData[keyStartIndex + keyLength + 1];
+		let valueType = sharedData[valueIndex];
+		switch(valueType) {
+			case VALUE_TYPE.NUMBER: {
+				sharedObject[key] = sharedData[valueIndex + 1];
+				break;
+			}
+			case VALUE_TYPE.STRING: {
+				let length = sharedData[valueIndex + 1];
+				let valueData = new Float32Array(memory.data.buffer, memory.bufferByteOffset + (valueIndex + 2) * sharedData.BYTES_PER_ELEMENT, length);
+				sharedObject[key] = String.fromCharCode.apply(null, [...valueData]);
+				break;
+			}
+		}
+
+		keyStartIndex += 2 + keyLength;
+	}
+
+	return sharedObject as T;
+}
+
+function addCharCodes(data: Array<number>, value: string) {
+	for(let i = 0; i < value.length; i++) {
+		data.push(value.charCodeAt(i));
+	}
+}

package/src/shared-list.ts

@@ -0,0 +1,274 @@
+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';
+import { getPointer, loadPointer, loadRawPointer, replaceRawPointer, storePointer, storeRawPointer } from './utils/pointer';
+
+enum TYPE {
+	uint32,
+	int32,
+	float32
+}
+
+// TODO: We need some sort of locking on insert/deletes!
+const FIRST_BLOCK_RECORD_KEEPING_COUNT = 4;
+const DATA_BLOCK_RECORD_KEEPING_COUNT = 1;
+const LENGTH_INDEX = 2;
+export default class SharedList<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<SharedListIterable<T>> {
+	static readonly ALLOCATE_COUNT = FIRST_BLOCK_RECORD_KEEPING_COUNT;
+
+	private memory: MemoryHeap;
+	/* First block
+		32 index 0
+		uint16 0 - next buffer position
+		uint16 1 - next buffer index
+		32 index 1
+		uint16 2 - last buffer position
+		uint16 3 - last buffer index
+		32 index 2
+		uint32 4 - length
+		32 index 3
+		uint16 6 - type
+		uint16 7 - data length (defaults to 1 number per data)
+	*/
+	/* Other blocks
+		32 index 0
+		uint16 0 - next buffer position
+		uint16 1 - next buffer index
+		32 index 1 => data
+	*/
+	private firstBlock: AllocatedMemory;
+	private uint16Array: Uint16Array;
+
+	get length(): number {
+		return Atomics.load(this.firstBlock.data, LENGTH_INDEX);
+	}
+	
+	get type(): number {
+		return Atomics.load(this.uint16Array, 0);
+	}
+	private set type(value: number) {
+		Atomics.store(this.uint16Array, 0, value);
+	}
+	get dataLength(): number {
+		// Can technically be initialized by passing memory without actually every being called - need to make sure dataLength is always at least one
+		return Math.max(1, Atomics.load(this.uint16Array, 1));
+	}
+	private set dataLength(value: number) {
+		Atomics.store(this.uint16Array, 1, value);
+	}
+
+	constructor(memory: MemoryHeap, config?: SharedListConfig<T> | SharedListMemory) {
+		this.memory = memory;
+
+		if(config && 'firstBlock' in config) {
+			this.firstBlock = new AllocatedMemory(memory, config.firstBlock);
+			this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (LENGTH_INDEX + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
+		} else {
+			if(config && config.initWithBlock) {
+				this.firstBlock = new AllocatedMemory(memory, config.initWithBlock);
+			} else {
+				this.firstBlock = memory.allocUI32(FIRST_BLOCK_RECORD_KEEPING_COUNT);
+			}
+			this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (LENGTH_INDEX + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
+
+			const type = config?.type ?? Uint32Array;
+			if(type === Uint32Array) {
+				this.type = TYPE.uint32;
+			}
+			// @ts-expect-error
+			else if(type === Int32Array) {
+				this.type = TYPE.int32;
+			}
+			// @ts-expect-error
+			else if(type === Float32Array) {
+				this.type = TYPE.float32;
+			}
+			this.dataLength = config?.dataLength ?? 1;
+		}
+	}
+
+	insert(values: number | Array<number>) {
+		if(typeof values === 'number') {
+			values = [values];
+		}
+
+		let dataLength = this.dataLength;
+		if(values.length > dataLength) {
+			throw new Error(`Can't insert ${values.length} array into shared list of ${dataLength} dataLength`);
+		}
+		let newBlock = this.memory.allocUI32(DATA_BLOCK_RECORD_KEEPING_COUNT + dataLength);
+		let newData = this.getDataBlock(newBlock.data);
+		let newBlockPointer = newBlock.pointer;
+		
+		for(let i = 0; i < values.length; i++) {
+			if(newData instanceof Int32Array || newData instanceof Uint32Array) {
+				Atomics.store(newData, i, values[i]);
+			} else {
+				// TODO: Should we replace with pass thru float32 conversion -> store?
+				newData[i] = values[i];
+			}
+		}
+
+		let lastBlockPointer;
+		let updateWorked = false;
+		while(!updateWorked) {
+			lastBlockPointer = loadRawPointer(this.firstBlock.data, 1);
+			updateWorked = replaceRawPointer(this.firstBlock.data, 1, newBlockPointer, lastBlockPointer);
+		}
+
+		if(lastBlockPointer) {
+			let { bufferPosition: lastBlockPosition, bufferByteOffset: lastBlockByteOffset } = getPointer(lastBlockPointer);
+			let lastBlock = new Uint32Array(this.memory.buffers[lastBlockPosition].buf, lastBlockByteOffset, 1);
+			storeRawPointer(lastBlock, 0, newBlockPointer);
+		} else {
+			// First item - store on first block
+			storeRawPointer(this.firstBlock.data, 0, newBlockPointer);
+		}
+		
+		// Always update new last buffer position and length
+		Atomics.add(this.firstBlock.data, LENGTH_INDEX, 1);
+	}
+
+	deleteMatch(callback: (values: T, index: number) => boolean): boolean {
+		for(let { data, index, deleteCurrent } of this) {
+			if(callback(data, index)) {
+				deleteCurrent();
+				return true;
+			}
+		}
+
+		return false;
+	}
+	deleteIndex(deleteIndex: number): boolean {
+		if(deleteIndex >= this.length || deleteIndex < 0) {
+			return false;
+		}
+
+		return this.deleteMatch((values, index) => index === deleteIndex);
+	}
+	deleteValue(deleteValues: number | Array<number>) {
+		if(typeof deleteValues === 'number') {
+			return this.deleteMatch(values => values[0] === deleteValues);
+		} else {
+			return this.deleteMatch(values => {
+				if(values.length !== deleteValues.length) {
+					return false;
+				} else {
+					for(let i = 0; i < values.length; i++) {
+						if(values[i] !== deleteValues[i]) {
+							return false;
+						}
+					}
+
+					return true;
+				}
+			});
+		}
+	}
+
+	*[Symbol.iterator]() {
+		let currentIndex = 0;
+		let { bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = loadPointer(this.firstBlock.data, 0);
+		let lastBlockData = this.firstBlock.data;
+		let lastBlockPosition = 0;
+		let lastBlockByteOffset = 0;
+		while(nextBlockByteOffset) {
+			let memPool = this.memory.buffers[nextBlockPosition];
+			let blockRecord = new Uint32Array(memPool.buf, nextBlockByteOffset, 2);
+			let blockData = this.getDataBlock(blockRecord);
+
+			let currentBlockPosition = nextBlockPosition;
+			let currentBlockByteOffset = nextBlockByteOffset;
+			({ bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = loadPointer(blockRecord, 0));
+
+			let updateLastBlock = true;
+			yield {
+				data: blockData,
+				index: currentIndex,
+				deleteCurrent: () => {
+					// Move previous index to point to one after
+					storePointer(lastBlockData, 0, nextBlockPosition, nextBlockByteOffset);
+
+					// If this is the last item, update last block to be previous location
+					if(!nextBlockByteOffset) {
+						storePointer(this.firstBlock.data, 1, lastBlockPosition, lastBlockByteOffset);
+					}
+
+					memPool.free(blockRecord.byteOffset);
+					Atomics.sub(this.firstBlock.data, LENGTH_INDEX, 1);
+					updateLastBlock = false;
+				}
+			};
+
+			if(updateLastBlock) {
+				lastBlockData = blockRecord;
+				lastBlockPosition = currentBlockPosition;
+				lastBlockByteOffset = currentBlockByteOffset;
+				currentIndex++;
+			}
+		}
+	}
+
+	forEach(callback: (data: T) => void) {
+		for(let value of this) {
+			callback(value.data);
+		}
+	}
+
+	getSharedMemory(): SharedListMemory {
+		return {
+			firstBlock: this.firstBlock.getSharedMemory()
+		};
+	}
+
+	private getDataBlock(memory: Uint32Array): T {
+		const startIndex = memory.byteOffset + DATA_BLOCK_RECORD_KEEPING_COUNT * memory.BYTES_PER_ELEMENT;
+
+		switch(this.type) {
+			case TYPE.int32:
+				// @ts-expect-error
+				return new Int32Array(memory.buffer, startIndex, this.dataLength);
+			case TYPE.uint32:
+				// @ts-expect-error
+				return new Uint32Array(memory.buffer, startIndex, this.dataLength);
+			case TYPE.float32:
+				// @ts-expect-error
+				return new Float32Array(memory.buffer, startIndex, this.dataLength);
+			default:
+				throw new Error(`Unknown data block type ${this.type}`);
+		}
+	}
+
+	free() {
+		let { bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = loadPointer(this.firstBlock.data, 0);
+		while(nextBlockByteOffset) {
+			let allocatedMemory = new AllocatedMemory(this.memory, {
+				bufferPosition: nextBlockPosition,
+				bufferByteOffset: nextBlockByteOffset
+			});
+
+			({ bufferPosition: nextBlockPosition, bufferByteOffset: nextBlockByteOffset } = loadPointer(allocatedMemory.data, 0));
+			allocatedMemory.free();
+		}
+
+		this.firstBlock.free();
+	}
+}
+
+interface SharedListConfig<T extends Uint32Array | Int32Array | Float32Array> {
+	initWithBlock?: SharedAllocatedMemory
+	type?: TypedArrayConstructor<T>
+	dataLength?: number
+}
+interface SharedListMemory {
+	firstBlock: SharedAllocatedMemory
+}
+
+interface SharedListIterable<T extends Uint32Array | Int32Array | Float32Array> {
+	data: T
+	index: number
+	deleteCurrent: () => void
+}
+
+export { type SharedListMemory };