@daneren2005/shared-memory-objects 0.0.0 → 0.0.1

package/src/__tests__/shared-string.spec.ts

@@ -0,0 +1,75 @@
+import MemoryHeap from '../memory-heap';
+import SharedString from '../shared-string';
+
+describe('SharedString', () => {
+	it('can create', () => {
+		let memory = new MemoryHeap();
+		let string = new SharedString(memory, 'Test');
+
+		expect(string.value).toEqual('Test');
+	});
+
+	it('utf16 characters work', () => {
+		let memory = new MemoryHeap();
+		let string = new SharedString(memory, 'Teǭst');
+
+		expect(string.value).toEqual('Teǭst');	
+	});
+
+	it('can initialize from memory without the string allocated yet', () => {
+		let memory = new MemoryHeap();
+		let allocatedMemory = memory.allocUI32(SharedString.ALLOCATE_COUNT);
+		let string = new SharedString(memory, {
+			...allocatedMemory.getSharedMemory(),
+			value: 'Test'
+		});
+
+		expect(string.value).toEqual('Test');
+	});
+	it('can work from uninitialized memory', () => {
+		let memory = new MemoryHeap();
+		let allocatedMemory = memory.allocUI32(SharedString.ALLOCATE_COUNT);
+		let string = new SharedString(memory, allocatedMemory.getSharedMemory());
+
+		expect(string.value).toEqual('');
+	});
+
+	it('can be set to new memory strings', () => {
+		let memory = new MemoryHeap();
+		let string = new SharedString(memory, 'Tests again22222222222222222222');
+		let startMemory = memory.currentUsed;
+		let copy = new SharedString(memory, string.getSharedMemory());
+
+		expect(copy.value).toEqual('Tests again22222222222222222222');
+		
+		copy.value = 'Blows again22222222222222222222';
+		expect(string.value).toEqual('Blows again22222222222222222222');
+		expect(memory.currentUsed).toEqual(startMemory);
+
+		string.value = 'Yo';
+		expect(string.value).toEqual('Yo');
+		expect(copy.value).toEqual('Yo');
+		expect(memory.currentUsed).toBeLessThan(startMemory);
+
+		string.value = 'Yo Mama Is So Fat2222222222222222222222222222222222222222';
+		expect(memory.currentUsed).toBeGreaterThan(startMemory);
+	});
+
+	it('can set to empty string', () => {
+		let memory = new MemoryHeap();
+		let string = new SharedString(memory, '');
+
+		expect(string.value).toEqual('');
+	});
+
+	it('free', () => {
+		let memory = new MemoryHeap();
+		let startMemory = memory.currentUsed;
+		let string = new SharedString(memory, 'Tests');
+		// No memory leak from changing values
+		string.value = 'Blob';
+		string.free();
+
+		expect(memory.currentUsed).toEqual(startMemory);
+	});
+});

package/src/__tests__/shared-vector.spec.ts

@@ -0,0 +1,163 @@
+import MemoryHeap from '../memory-heap';
+import SharedVector from '../shared-vector';
+
+describe('SharedVector', () => {
+	let memory: MemoryHeap;
+	beforeEach(() => {
+		memory = new MemoryHeap({
+			bufferSize: 1024 * 16
+		});
+	});
+
+	it('insert into vector', () => {
+		let vector = new SharedVector(memory, {
+			type: Uint32Array
+		});
+
+		vector.push(10);
+		vector.push(52);
+		vector.push(4);
+
+		expect(vector.length).toEqual(3);
+		expect(flat(vector)).toEqual([10, 52, 4]);
+	});
+
+	it('continually grows memory as needed', () => {
+		let vector = new SharedVector(memory, {
+			type: Uint32Array
+		});
+
+		const expectedValues = [];
+		for(let i = 0; i < 1_000; i++) {
+			vector.push(i);
+			expectedValues.push(i);
+		}
+
+		expect(vector.length).toEqual(1_000);
+		expect(flat(vector)).toEqual(expectedValues);
+	});
+
+	it('pop', () => {
+		let vector = new SharedVector(memory);
+
+		vector.push(10);
+		vector.push(52);
+		vector.push(4);
+		vector.push(8);
+
+		expect([...vector.pop()]).toEqual([8]);
+		expect(vector.length).toEqual(3);
+		expect([...vector.pop()]).toEqual([4]);
+		expect(vector.length).toEqual(2);
+		expect(flat(vector)).toEqual([10, 52]);
+	});
+
+	it('deleteIndex', () => {
+		let vector = new SharedVector(memory);
+
+		vector.push(10);
+		vector.push(52);
+		vector.push(4);
+		vector.push(8);
+
+		vector.deleteIndex(3);
+		expect(vector.length).toEqual(3);
+		expect(flat(vector)).toEqual([10, 52, 4]);
+		
+		vector.deleteIndex(1);
+		expect(vector.length).toEqual(2);
+		expect(flat(vector)).toEqual([10, 4]);
+		
+		vector.deleteIndex(0);
+		expect(vector.length).toEqual(1);
+		expect(flat(vector)).toEqual([4]);
+	});
+
+	it('with dataLength: 3', () => {
+		let vector = new SharedVector(memory, {
+			type: Uint32Array,
+			dataLength: 3
+		});
+
+		vector.push(10);
+		vector.push([52, 32, 6]);
+		vector.push([40, 41, 42]);
+
+		expect(vector.length).toEqual(3);
+		expect(flat(vector)).toEqual([
+			10, 0, 0,
+			52, 32, 6,
+			40, 41, 42
+		]);
+
+		expect([...vector.pop()]).toEqual([40, 41, 42]);
+		expect(vector.length).toEqual(2);
+		expect(flat(vector)).toEqual([
+			10, 0, 0,
+			52, 32, 6
+		]);
+
+		vector.deleteIndex(0);
+		expect(vector.length).toEqual(1);
+		expect(flat(vector)).toEqual([
+			52, 32, 6
+		]);
+	});
+
+	it('can work from memory', () => {
+		let mainVector = new SharedVector(memory, {
+			type: Uint32Array,
+			dataLength: 3
+		});
+		let cloneVector = new SharedVector(memory, mainVector.getSharedMemory());
+
+		mainVector.push(10);
+		mainVector.push([52, 32, 6]);
+		mainVector.push([40, 41, 42]);
+
+		expect(mainVector.length).toEqual(3);
+		expect(flat(mainVector)).toEqual([
+			10, 0, 0,
+			52, 32, 6,
+			40, 41, 42
+		]);
+		expect(cloneVector.length).toEqual(3);
+		expect(flat(cloneVector)).toEqual([
+			10, 0, 0,
+			52, 32, 6,
+			40, 41, 42
+		]);
+
+		// Make sure growing works
+		for(let i = 0; i < 10; i++) {
+			cloneVector.push(i);
+		}
+		for(let i = 0; i < 10; i++) {
+			mainVector.push(i);
+		}
+		expect(mainVector.length).toEqual(23);
+		expect(cloneVector.length).toEqual(23);
+	});
+
+	it('free', () => {
+		let startMemory = memory.currentUsed;
+		let vector = new SharedVector(memory, {
+			type: Uint32Array
+		});
+
+		for(let i = 0; i < 1_000; i++) {
+			vector.push(i);
+		}
+
+		vector.free();
+		expect(memory.currentUsed).toEqual(startMemory);
+	});
+});
+
+function flat(list: SharedVector<any>) {
+	return [...list].reduce((array, value) => {
+		array.push(...value);
+
+		return array;
+	}, []);
+}

package/src/allocated-memory.ts

@@ -0,0 +1,84 @@
+import type { TypedArray } from './interfaces/typed-array';
+import type { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+import type MemoryBuffer from './memory-buffer';
+import type MemoryHeap from './memory-heap';
+import { createPointer } from './utils/pointer';
+
+export default class AllocatedMemory {
+	private readonly memory: MemoryHeap;
+
+	readonly bufferPosition: number;
+	get bufferByteOffset(): number {
+		return this.data.byteOffset;
+	}
+	get pointer(): number {
+		return createPointer(this.bufferPosition, this.bufferByteOffset);
+	}
+	private buffer: MemoryBuffer;
+	data: Uint32Array;
+
+	constructor(memory: MemoryHeap, config: AllocatedMemoryConfig | SharedAllocatedMemory) {
+		this.memory = memory;
+
+		if('buffer' in config) {
+			this.data = config.data;
+			this.buffer = config.buffer;
+			this.bufferPosition = this.memory.buffers.indexOf(config.buffer);
+		} else {
+			this.bufferPosition = config.bufferPosition;
+			this.buffer = memory.buffers[config.bufferPosition];
+
+			// Making sure these are the correct size is slow but in dev we want to make sure we aren't allowing to go out of bounds
+			if(import.meta.env.MODE === 'production') {
+				this.data = new Uint32Array(this.buffer.buf, config.bufferByteOffset);
+			} else {
+				this.data = new Uint32Array(this.buffer.buf, config.bufferByteOffset, this.buffer.lengthOf(config.bufferByteOffset));
+			}
+		}
+	}
+
+	getArray<T extends TypedArray>(type: TypedArrayConstructor<T>, offset: number, length: number): T {
+		if(import.meta.env.MODE === 'development') {
+			if(offset + length > this.data.length) {
+				console.warn(`Trying to grab more memory from AllocatedMemory.getArray then we have: ${offset} + ${length} > ${this.data.length}`);
+			}
+		}
+
+		return new type(this.data.buffer, this.data.byteOffset + offset * type.BYTES_PER_ELEMENT, length);
+	}
+	getArrayMemory(offset: number, length: number): SharedAllocatedMemory {
+		if(import.meta.env.MODE === 'development') {
+			if(offset + length > this.data.length) {
+				console.warn(`Trying to grab more memory from AllocatedMemory.getArrayMemory then we have: ${offset} + ${length} > ${this.data.length}`);
+			}
+		}
+
+		return {
+			bufferPosition: this.bufferPosition,
+			bufferByteOffset: this.bufferByteOffset + offset * this.data.BYTES_PER_ELEMENT
+		};
+	}
+
+	free() {
+		// NOTE: From worker thread you can't pass the array, you have to pass an explicit address to free
+		this.buffer.free(this.data.byteOffset);
+	}
+
+	getSharedMemory(): SharedAllocatedMemory {
+		return {
+			bufferPosition: this.bufferPosition,
+			bufferByteOffset: this.bufferByteOffset
+		};
+	}
+}
+
+interface AllocatedMemoryConfig {
+	data: Uint32Array
+	buffer: MemoryBuffer
+}
+
+interface SharedAllocatedMemory {
+	bufferPosition: number
+	bufferByteOffset: number
+}
+export type { SharedAllocatedMemory };

package/src/interfaces/pow2.ts

@@ -0,0 +1,3 @@
+type Pow2 = 0x1 | 0x2 | 0x4 | 0x8 | 0x10 | 0x20 | 0x40 | 0x80 | 0x100 | 0x200 | 0x400 | 0x800 | 0x1000 | 0x2000 | 0x4000 | 0x8000 | 0x10000 | 0x20000 | 0x40000 | 0x80000 | 0x100000 | 0x200000 | 0x400000 | 0x800000 | 0x1000000 | 0x2000000 | 0x4000000 | 0x8000000 | 0x10000000 | 0x20000000 | 0x40000000 | 0x80000000;
+
+export type { Pow2 };

package/src/interfaces/typed-array-constructor.ts

@@ -0,0 +1,6 @@
+interface TypedArrayConstructor<T> {
+	new(buffer: ArrayBufferLike, byteOffset: number, length: number): T
+	BYTES_PER_ELEMENT: number
+}
+
+export type { TypedArrayConstructor };

package/src/interfaces/typed-array.ts

@@ -0,0 +1 @@
+export type TypedArray = Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;

package/src/lock/read-write-lock.ts

@@ -0,0 +1,41 @@
+const UNLOCKED = 0;
+const READ_LOCKED = 1;
+const WRITE_LOCKED = 2;
+
+export function readLock(data: Int32Array, index: number = 0) {
+	// Wait over and over again until we get that it was unlocked or read locked
+	while(Atomics.compareExchange(data, index, UNLOCKED, READ_LOCKED) === WRITE_LOCKED) {
+		Atomics.wait(data, index, WRITE_LOCKED);
+	}
+
+	Atomics.add(data, index + 1, 1);
+}
+export function writeLock(data: Int32Array, index: number = 0) {
+	// Write lock needs to be exclusive - wait until we were in UNLOCKED to proceed
+	let oldValue = Atomics.compareExchange(data, index, UNLOCKED, WRITE_LOCKED);
+	while(oldValue !== UNLOCKED) {
+		Atomics.wait(data, index, oldValue);
+		oldValue = Atomics.compareExchange(data, index, UNLOCKED, WRITE_LOCKED);
+	}
+}
+
+export function readUnlock(data: Int32Array, index: number = 0) {
+	let readCount = Atomics.sub(data, index + 1, 1) - 1;
+
+	if(readCount <= 0) {
+		if(Atomics.compareExchange(data, index, READ_LOCKED, UNLOCKED) !== READ_LOCKED) {
+			console.warn('We are unlocking when it was not read locked!');
+		}
+
+		Atomics.notify(data, index);
+	}
+}
+export function writeUnlock(data: Int32Array, index: number = 0) {
+	if(Atomics.compareExchange(data, index, WRITE_LOCKED, UNLOCKED) !== WRITE_LOCKED) {
+		console.warn('We are unlocking when it was not write locked!');
+	}
+
+	Atomics.notify(data, index);
+}
+
+export const READ_WRITE_LOCK_ALLOCATE_COUNT = 2;

package/src/lock/simple-lock.ts

@@ -0,0 +1,21 @@
+const UNLOCKED = 0;
+const LOCKED = 1;
+export function lock(data: Int32Array, index: number = 0) {
+	// Wait over and over again until we are one who set this from UNLOCKED to LOCKED
+	while(Atomics.compareExchange(data, index, UNLOCKED, LOCKED) !== UNLOCKED) {
+		if('WorkerGlobalScope' in self) {
+			Atomics.wait(data, index, LOCKED);
+		} else {
+			// TODO: Spin-locks suck....
+		}
+	}
+}
+export function unlock(data: Int32Array, index: number = 0) {
+	if(Atomics.compareExchange(data, index, LOCKED, UNLOCKED) !== LOCKED) {
+		console.warn('We are unlocking when it was not locked!');
+	}
+
+	Atomics.notify(data, index);
+}
+
+export const SIMPLE_LOCK_ALLOCATE_COUNT = 1;

package/src/main.ts

@@ -0,0 +1,35 @@
+import AllocatedMemory, { type SharedAllocatedMemory } from './allocated-memory';
+import MemoryBuffer from './memory-buffer';
+import MemoryHeap, { type MemoryHeapMemory } from './memory-heap';
+
+import SharedList, { type SharedListMemory } from './shared-list';
+import SharedMap from './shared-map';
+import SharedPointerList from './shared-pointer-list';
+import SharedString from './shared-string';
+import SharedVector from './shared-vector';
+
+import type { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+
+export * from './utils/16-from-32-array';
+export * from './utils/16-from-64-array';
+export * from './utils/float32-atomics';
+export * from './utils/pointer';
+export * from './lock/simple-lock';
+export * from './lock/read-write-lock';
+
+export {
+	AllocatedMemory,
+	type SharedAllocatedMemory,
+	MemoryBuffer,
+	MemoryHeap,
+	type MemoryHeapMemory,
+
+	SharedList,
+	type SharedListMemory,
+	SharedMap,
+	SharedPointerList,
+	SharedString,
+	SharedVector,
+
+	type TypedArrayConstructor
+};