@daneren2005/shared-memory-objects 0.0.10 → 0.0.12

package/src/memory-heap.ts

@@ -1,206 +0,0 @@
-import AllocatedMemory, { type SharedAllocatedMemory } from './allocated-memory';
-import prettyBytes from 'pretty-bytes';
-import { MAX_BYTE_OFFSET_LENGTH, MAX_POSITION_LENGTH } from './utils/pointer';
-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> = [];
-	isClone: boolean;
-	private memory: AllocatedMemory;
-
-	get bufferSize() {
-		return this.memory.data[BUFFER_SIZE_INDEX];
-	}
-
-	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 {
-			if(!('SharedArrayBuffer' in globalThis)) {
-				console.warn('SharedArrayBuffer is not working: falling back to ArrayBuffer');
-			}
-
-			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', 3);
-			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[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++) {
-				this.buffers.push(this.createBuffer(bufferSize));
-			}
-		}
-	}
-
-	addSharedBuffer(data: GrowBufferData) {
-		this.buffers[data.bufferPosition] = new MemoryBuffer({
-			buf: data.buffer,
-			skipInitialization: true
-		});
-	}
-
-	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;
-		if('SharedArrayBuffer' in globalThis) {
-			buf = new SharedArrayBuffer(usedBufferSize);
-		} else {
-			buf = new ArrayBuffer(usedBufferSize);
-		}
-
-		return new MemoryBuffer({
-			buf,
-
-			// We can't use this unless we can 100% guarantee that every thread will stop using memory the instant it is freed
-			// ex: Allocate 16 bytes.  Thread A frees that allocation and then allocates 12 bytes and 4 bytes, but Thread B is mid-execution on the old allocation can changes the internal state of the 4-byte allocation breaking everything
-			// After the internal state is wrong MemoryBuffer will loose track of which blocks are where and how big they are
-			compact: false,
-			split: false
-		});
-	}
-
-	addOnGrowBufferHandlers(handler: OnGrowBuffer) {
-		this.onGrowBufferHandlers.push(handler);
-	}
-
-	allocUI32(count: number): AllocatedMemory {
-		count = Math.ceil(count);
-		for(let i = 0; i < this.buffers.length; i++) {
-			const buffer = this.buffers[i];
-			// Should just mean we haven't synced this buffer from another thread yet
-			if(!buffer) {
-				continue;
-			}
-
-			// 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
-				});
-			}
-		}
-
-		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
-		let buffer = this.growBuffer();
-		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`);
-		}
-	}
-
-	getSharedAlloc(shared: SharedAllocatedMemory): AllocatedMemory | undefined {
-		// Should just mean it hasn't synced to this thread yet
-		if(this.buffers[shared.bufferPosition] === undefined) {
-			return undefined;
-		}
-
-		return new AllocatedMemory(this, shared);
-	}
-
-	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: GrowBufferData) => void;
-interface GrowBufferData {
-	bufferPosition: number
-	buffer: SharedArrayBuffer
-}
-
-interface MemoryHeapConfig {
-	bufferSize?: number
-	initialBuffers?: number
-	autoGrowSize?: number
-}
-interface MemoryHeapMemory {
-	buffers: Array<SharedArrayBuffer>
-}
-
-export type { MemoryHeapConfig, MemoryHeapMemory, GrowBufferData };

package/src/serialize-object.ts

@@ -1,95 +0,0 @@
-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

@@ -1,339 +0,0 @@
-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;
-	onDelete?: (data: T) => void;
-
-	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) {
-			// TODO: How to handle referencing memory we don't have access to yet because buffer not synced from worker?
-			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);
-			// TODO: How to handle referencing memory we don't have access to yet because buffer not synced from worker?
-			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;
-				}
-			});
-		}
-	}
-
-	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);
-		let lastBlockData = this.firstBlock.data;
-		let lastBlockPosition = 0;
-		let lastBlockByteOffset = 0;
-		while(nextBlockByteOffset) {
-			let memPool = this.memory.buffers[nextBlockPosition];
-			// Short circuit iterations if we can't access memory
-			if(!memPool) {
-				return;
-			}
-
-			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);
-					}
-
-					if(this.onDelete) {
-						this.onDelete(this.getDataBlock(blockRecord));
-					}
-
-					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));
-
-			if(this.onDelete) {
-				this.onDelete(this.getDataBlock(allocatedMemory.data));
-			}
-
-			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 };