@daneren2005/shared-memory-objects 0.0.10 → 0.0.11

package/src/shared-map.ts

@@ -1,252 +0,0 @@
-import AllocatedMemory, { type SharedAllocatedMemory } from './allocated-memory';
-import type MemoryHeap from './memory-heap';
-import SharedList from './shared-list';
-import { loadPointer, storePointer } from './utils/pointer';
-
-// TODO: Grow hashMemory
-// TODO: Add iterator
-// TODO: Add read/write locks
-const DEFAULT_HASH_SIZE = 10;
-export default class SharedMap<K extends string | number> {
-	static readonly ALLOCATE_COUNT = 4;
-
-	private memory: MemoryHeap;
-	// Memory order: Pointer, Lock, Length, MaxHash
-	private pointerMemory: AllocatedMemory;
-	private lock: Int32Array;
-	private get hashMemory(): AllocatedMemory {
-		return new AllocatedMemory(this.memory, loadPointer(this.pointerMemory.data, 0));
-	}
-
-	get length(): number {
-		return Atomics.load(this.pointerMemory.data, 2);
-	}
-	get maxHash(): number {
-		return Atomics.load(this.pointerMemory.data, 3);
-	}
-
-	constructor(memory: MemoryHeap, clone?: SharedMapMemory) {
-		this.memory = memory;
-
-		if(clone) {
-			this.pointerMemory = new AllocatedMemory(memory, clone.firstBlock);
-		} else {
-			this.pointerMemory = memory.allocUI32(SharedMap.ALLOCATE_COUNT);
-			let hashMemory = memory.allocUI32(DEFAULT_HASH_SIZE);
-			storePointer(this.pointerMemory.data, 0, hashMemory.bufferPosition, hashMemory.bufferByteOffset);
-			Atomics.store(this.pointerMemory.data, 3, DEFAULT_HASH_SIZE);
-		}
-		this.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + Uint32Array.BYTES_PER_ELEMENT, 1);
-	}
-
-	set(key: K, value: number) {
-		if(this.length >= this.maxHash * 2) {
-			this.growHashTable();
-		}
-
-		let fullHashKey = get32BitHash(key);
-		if(this.setHashKey(this.hashMemory, this.maxHash, fullHashKey, value)) {
-			Atomics.add(this.pointerMemory.data, 2, 1);
-		}
-	}
-	private setHashKey(hashMemory: AllocatedMemory, maxHash: number, fullHashKey: number, value: number) {
-		let hashKey = this.hash(fullHashKey, maxHash);
-		
-		let list: SharedList;
-		let pointer = loadPointer(hashMemory.data, hashKey);
-		if(pointer.bufferByteOffset === 0) {
-			// Initialize a list here
-			list = new SharedList(this.memory, {
-				dataLength: 2
-			});
-
-			let listMemory = list.getSharedMemory();
-			storePointer(hashMemory.data, hashKey, listMemory.firstBlock.bufferPosition, listMemory.firstBlock.bufferByteOffset);
-		} else {
-			list = new SharedList(this.memory, {
-				firstBlock: pointer
-			});
-		}
-
-		// Check if any other items in list have the same key and delete them
-		let inserted = true;
-		if(list.deleteValue(fullHashKey)) {
-			inserted = false;
-		}
-		list.insert([fullHashKey, value]);
-		
-		return inserted;
-	}
-
-	get(key: K): number | undefined {
-		let fullHashKey = get32BitHash(key);
-		let hashKey = this.hash(fullHashKey, this.maxHash);
-
-		let pointer = loadPointer(this.hashMemory.data, hashKey);
-		if(pointer.bufferByteOffset === 0) {
-			return undefined;
-		}
-
-		let list = new SharedList(this.memory, {
-			firstBlock: pointer
-		});
-
-		for(let { data } of list) {
-			if(data[0] === fullHashKey) {
-				return data[1];
-			}
-		}
-
-		return undefined;
-	}
-	has(key: K): boolean {
-		let fullHashKey = get32BitHash(key);
-		let hashKey = this.hash(fullHashKey, this.maxHash);
-
-		let pointer = loadPointer(this.hashMemory.data, hashKey);
-		if(pointer.bufferByteOffset === 0) {
-			return false;
-		}
-
-		let list = new SharedList(this.memory, {
-			firstBlock: pointer
-		});
-
-		for(let { data } of list) {
-			if(data[0] === fullHashKey) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	delete(key: K): boolean {
-		let fullHashKey = get32BitHash(key);
-		let hashKey = this.hash(fullHashKey, this.maxHash);
-
-		let pointer = loadPointer(this.hashMemory.data, hashKey);
-		if(pointer.bufferByteOffset === 0) {
-			return false;
-		}
-
-		let list = new SharedList(this.memory, {
-			firstBlock: pointer
-		});
-
-		for(let { data, deleteCurrent } of list) {
-			if(data[0] === fullHashKey) {
-				deleteCurrent();
-
-				Atomics.sub(this.pointerMemory.data, 2, 1);
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	private growHashTable() {
-		let oldMaxHash = this.maxHash;
-		let newMaxHash = oldMaxHash * 2;
-		let newHashMemory = this.memory.allocUI32(newMaxHash);
-		let oldHashMemory = this.hashMemory;
-
-		// Copy each old hash value into new hash memory
-		for(let i = 0; i < oldMaxHash; i++) {
-			let pointer = loadPointer(oldHashMemory.data, i);
-			if(pointer.bufferByteOffset === 0) {
-				continue;
-			}
-
-			let list = new SharedList(this.memory, {
-				firstBlock: pointer
-			});
-			for(let { data } of list) {
-				this.setHashKey(newHashMemory, newMaxHash, data[0], data[1]);
-			}
-		}
-
-		storePointer(this.pointerMemory.data, 0, newHashMemory.bufferPosition, newHashMemory.bufferByteOffset);
-		Atomics.store(this.pointerMemory.data, 3, newMaxHash);
-	}
-
-	private hash(key: number, maxHash: number) {
-		return key % maxHash;
-	}
-
-	free() {
-		// Loop through and free lists in hash table first
-		for(let i = 0; i < this.maxHash; i++) {
-			let pointer = loadPointer(this.hashMemory.data, i);
-			if(pointer.bufferByteOffset === 0) {
-				continue;
-			}
-
-			let list = new SharedList(this.memory, {
-				firstBlock: pointer
-			});
-			list.free();
-		}
-
-		this.hashMemory.free();
-		this.pointerMemory.free();
-	}
-
-	getSharedMemory(): SharedMapMemory {
-		return {
-			firstBlock: this.pointerMemory.getSharedMemory()
-		};
-	}
-}
-
-interface SharedMapMemory {
-	firstBlock: SharedAllocatedMemory
-}
-
-function get32BitHash<K extends string | number>(key: K): number {
-	if(typeof key === 'number') {
-		return key;
-	} else if(typeof key === 'string') {
-		return hashString(key as string);
-	} else {
-		return key;
-	}
-}
-
-// Copied from https://github.com/mmomtchev/SharedMap/blob/master/index.js - MurmurHash2
-function hashString(str: string): number {
-	let
-		l = str.length,
-		h = 17 ^ l,
-		i = 0,
-		k;
-	while(l >= 4) {
-		k =
-			((str.charCodeAt(i) & 0xff)) |
-			((str.charCodeAt(++i) & 0xff) << 8) |
-			((str.charCodeAt(++i) & 0xff) << 16) |
-			((str.charCodeAt(++i) & 0xff) << 14);
-		k = (((k & 0xffff) * 0x5bd1e995) + ((((k >>> 16) * 0x5bd1e995) & 0xffff) << 16));
-		k ^= k >>> 14;
-		k = (((k & 0xffff) * 0x5bd1e995) + ((((k >>> 16) * 0x5bd1e995) & 0xffff) << 16));
-		h = (((h & 0xffff) * 0x5bd1e995) + ((((h >>> 16) * 0x5bd1e995) & 0xffff) << 16)) ^ k;
-		l -= 4;
-		++i;
-	}
-	/* eslint-disable no-fallthrough */
-	switch(l) {
-		case 3: h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
-		case 2: h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
-		case 1: h ^= (str.charCodeAt(i) & 0xff);
-			h = (((h & 0xffff) * 0x5bd1e995) + ((((h >>> 16) * 0x5bd1e995) & 0xffff) << 16));
-	}
-	/* eslint-enable no-fallthrough */
-	h ^= h >>> 13;
-	h = (((h & 0xffff) * 0x5bd1e995) + ((((h >>> 16) * 0x5bd1e995) & 0xffff) << 16));
-	h ^= h >>> 15;
-	h = h >>> 0;
-	return h;
-}
-
-export type { SharedMapMemory };

package/src/shared-pointer-list.ts

@@ -1,80 +0,0 @@
-import AllocatedMemory from './allocated-memory';
-import type MemoryHeap from './memory-heap';
-import type { SharedListMemory } from './shared-list';
-import SharedList from './shared-list';
-import { createPointer, loadPointer } from './utils/pointer';
-
-export default abstract class SharedPointerList<T extends PointerItem> implements Iterable<T> {
-	private memory: MemoryHeap;
-	private list: SharedList;
-
-	constructor(heap: MemoryHeap, memory?: SharedListMemory) {
-		this.memory = heap;
-
-		if(memory) {
-			this.list = new SharedList(heap, memory);
-		} else {
-			this.list = new SharedList(heap);
-		}
-	}
-
-	get length() {
-		return this.list.length;
-	}
-
-	insert(item: T) {
-		this.list.insert(createPointer(item.memory.bufferPosition, item.memory.bufferByteOffset));
-	}
-	delete(item: T) {
-		return this.list.deleteValue(createPointer(item.memory.bufferPosition, item.memory.bufferByteOffset));
-	}
-
-	*[Symbol.iterator]() {
-		let iterator = this.list[Symbol.iterator]();
-
-		for(let { data: pointerData } of iterator) {
-			let { bufferPosition, bufferByteOffset } = loadPointer(pointerData, 0);
-			let allocatedMemory = new AllocatedMemory(this.memory, {
-				bufferPosition,
-				bufferByteOffset
-			});
-			yield this.createItem(allocatedMemory);
-		}
-	}
-	forEach(callback: (item: T) => void) {
-		for(let value of this) {
-			callback(value);
-		}
-	}
-
-	find(callback: (item: T) => boolean): T | undefined {
-		for(let value of this) {
-			if(callback(value)) {
-				return value;
-			}
-		}
-	}
-
-	getSharedMemory() {
-		return this.list.getSharedMemory();
-	}
-
-	protected abstract createItem(allocatedMemory: AllocatedMemory): T;
-
-	free() {
-		for(let item of this) {
-			// NOTE: Anything that allocates it's own memory (ie: type for Item) needs to call free for that class so we can clear all memory recursively
-			if('free' in item && typeof item.free === 'function') {
-				item.free();
-			} else {
-				item.memory.free();
-			}
-		}
-
-		this.list.free();
-	}
-}
-
-interface PointerItem {
-	readonly memory: AllocatedMemory
-}

package/src/shared-string.ts

@@ -1,144 +0,0 @@
-import AllocatedMemory from './allocated-memory';
-import type { SharedAllocatedMemory } from './allocated-memory';
-import { lock, unlock } from './lock/simple-lock';
-import type MemoryHeap from './memory-heap';
-import { getPointer, loadPointer, loadRawPointer, storeRawPointer } from './utils/pointer';
-
-enum CHAR_TYPE {
-	UNDEFINED,
-	ASCII,
-	UTF16
-}
-const TYPED_ARRAY_MAP = {
-	[CHAR_TYPE.ASCII]: Uint8Array,
-	[CHAR_TYPE.UTF16]: Uint16Array
-};
-
-const POINTER_INDEX = 0;
-const LENGTH_INDEX = 1;
-const TYPE_INDEX = 2;
-const LOCK_INDEX = 3;
-export default class SharedString {
-	static readonly ALLOCATE_COUNT = 4;
-
-	private memory: MemoryHeap;
-	private allocatedMemory: AllocatedMemory;
-	private lock: Int32Array;
-
-	private cachedPointer?: number;
-	private cachedString?: string;
-	
-	constructor(memory: MemoryHeap, value: string | SharedStringConfig | SharedStringMemory) {
-		this.memory = memory;
-
-		if(typeof value === 'string') {
-			this.allocatedMemory = this.memory.allocUI32(SharedString.ALLOCATE_COUNT);
-			this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + LOCK_INDEX * this.allocatedMemory.data.BYTES_PER_ELEMENT);
-			this.updateString(value);
-		} else {
-			this.allocatedMemory = new AllocatedMemory(memory, value);
-			this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + LOCK_INDEX * this.allocatedMemory.data.BYTES_PER_ELEMENT);
-
-			// We only allocated memory but didn't initialize the string yet
-			if('value' in value) {
-				this.updateString(value.value);
-			}
-		}
-	}
-	
-	private updateString(value: string) {
-		let stringMemory = this.createString(value);
-
-		lock(this.lock);
-		storeRawPointer(this.allocatedMemory.data, POINTER_INDEX, stringMemory.pointer);
-		Atomics.store(this.allocatedMemory.data, LENGTH_INDEX, value.length);
-		Atomics.store(this.allocatedMemory.data, TYPE_INDEX, stringMemory.charType);
-		unlock(this.lock);
-
-		this.cachedPointer = stringMemory.pointer;
-		this.cachedString = value;
-	}
-	private createString(value: string) {
-		if(value === '') {
-			return {
-				pointer: 0,
-				charType: CHAR_TYPE.ASCII
-			};
-		}
-
-		let charCodes = [];
-		for(let i = 0; i < value.length; i++) {
-			charCodes.push(value.charCodeAt(i));
-		}
-
-		let maxCharCode = Math.max(...charCodes);
-		let charType = maxCharCode > 255 ? CHAR_TYPE.UTF16 : CHAR_TYPE.ASCII;
-
-		let typedArray = TYPED_ARRAY_MAP[charType];
-		let allocatedMemory = this.memory.allocUI32(Math.ceil(value.length / (4 / typedArray.BYTES_PER_ELEMENT)));
-		let data = new typedArray(allocatedMemory.data.buffer, allocatedMemory.data.byteOffset, value.length);
-		for(let i = 0; i < value.length; i++) {
-			data[i] = value.charCodeAt(i);
-		}
-
-		return {
-			pointer: allocatedMemory.pointer,
-			charType
-		};
-	}
-
-	get value(): string {
-		let pointer = loadRawPointer(this.allocatedMemory.data, POINTER_INDEX);
-		if(this.cachedPointer === pointer && this.cachedString !== undefined) {
-			return this.cachedString;
-		} else if(pointer === 0) {
-			return '';
-		}
-		let { bufferPosition, bufferByteOffset } = getPointer(pointer);
-
-		lock(this.lock);
-		let charType = Atomics.load(this.allocatedMemory.data, TYPE_INDEX) as number;
-		// @ts-expect-error
-		let typedArray = TYPED_ARRAY_MAP[charType];
-		let bufferLength = Atomics.load(this.allocatedMemory.data, LENGTH_INDEX);
-
-		let data = new typedArray(this.memory.buffers[bufferPosition].buf, bufferByteOffset, bufferLength);
-		let string = String.fromCharCode.apply(null, data);
-		// NOTE: Do not unlock until after transforming the data since the second this is done it can free that memory block
-		unlock(this.lock);
-
-		this.cachedPointer = pointer;
-		this.cachedString = string;
-
-		return string;
-	}
-	set value(value: string) {
-		let { bufferPosition: oldBufferPosition, bufferByteOffset: oldBufferByteOffset } = loadPointer(this.allocatedMemory.data, POINTER_INDEX);
-		this.updateString(value);
-
-		if(oldBufferByteOffset) {
-			this.memory.buffers[oldBufferPosition].free(oldBufferByteOffset);
-		}
-	}
-
-	getSharedMemory(): SharedStringMemory {
-		return this.allocatedMemory.getSharedMemory();
-	}
-
-	get pointer() {
-		return this.allocatedMemory.pointer;
-	}
-
-	free() {
-		let { bufferPosition, bufferByteOffset } = loadPointer(this.allocatedMemory.data, POINTER_INDEX);
-		if(bufferByteOffset) {
-			this.memory.buffers[bufferPosition].free(bufferByteOffset);
-		}
-		this.allocatedMemory.free();
-	}
-}
-
-interface SharedStringConfig extends SharedStringMemory {
-	value: string
-}
-type SharedStringMemory = SharedAllocatedMemory;

package/src/shared-vector.ts

@@ -1,236 +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, storePointer } from './utils/pointer';
-
-enum TYPE {
-	uint32,
-	int32,
-	float32
-}
-
-const LIST_LENGTH_INDEX = 1;
-const BUFFER_LENGTH_INDEX = 2;
-const TYPE_INDEX = 3;
-const DEFAULT_SIZE = 4;
-export default class SharedVector<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<T> {
-	static readonly ALLOCATE_COUNT = 4;
-	private memory: MemoryHeap;
-
-	// Pointer, List Length, Buffer Length, Type/DataLength
-	private firstBlock: AllocatedMemory;
-	private uint16Array: Uint16Array;
-
-	get length(): number {
-		return Atomics.load(this.firstBlock.data, LIST_LENGTH_INDEX);
-	}
-	
-	get type(): number {
-		return 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, this.uint16Array[1]);
-	}
-	private set dataLength(value: number) {
-		Atomics.store(this.uint16Array, 1, value);
-	}
-
-	get bufferLength(): number {
-		return Atomics.load(this.firstBlock.data, BUFFER_LENGTH_INDEX);
-	}
-	private set bufferLength(value: number) {
-		Atomics.store(this.firstBlock.data, BUFFER_LENGTH_INDEX, value);
-	}
-
-	private cachedFullDataBlock?: T;
-	private cachedPointer: number;
-
-	constructor(memory: MemoryHeap, config?: SharedVectorConfig<T> | SharedVectorMemory) {
-		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 + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);
-		} else {
-			this.firstBlock = memory.allocUI32(SharedVector.ALLOCATE_COUNT);
-			this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);
-
-			let dataLength = config?.dataLength ?? 1;
-			let bufferLength = config?.bufferLength ?? DEFAULT_SIZE;
-			let dataBlock = memory.allocUI32(bufferLength * dataLength);
-			storePointer(this.firstBlock.data, 0, dataBlock.bufferPosition, dataBlock.bufferByteOffset);
-			this.bufferLength = bufferLength;
-
-			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 = dataLength;
-		}
-
-		this.cachedPointer = this.firstBlock.data[0];
-		this.cachedFullDataBlock = this.getFullDataBlock(this.dataLength);
-	}
-
-	push(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 dataBlock = this.getFullDataBlock(dataLength);
-		let currentLength = this.length;
-		dataBlock.set(values, dataLength * currentLength);
-
-		let newLength = Atomics.add(this.firstBlock.data, LIST_LENGTH_INDEX, LIST_LENGTH_INDEX) + 1;
-		if(newLength >= this.bufferLength) {
-			this.growBuffer();
-		}
-	}
-
-	pop(): T {
-		let oldLength = Atomics.sub(this.firstBlock.data, LIST_LENGTH_INDEX, LIST_LENGTH_INDEX);
-
-		let pointer = loadPointer(this.firstBlock.data, 0);
-		let dataMemory = new AllocatedMemory(this.memory, pointer);
-		return this.getDataBlock(dataMemory.data, oldLength - 1);
-	}
-
-	deleteIndex(index: number) {
-		let length = this.length;
-		if(index >= length || index < 0) {
-			throw new Error(`${index} is out of bounds ${length}`);
-		}
-
-		let dataLength = this.dataLength;
-		let dataBlock = this.getFullDataBlock(dataLength);
-		for(let i = index; i < length; i++) {
-			for(let j = 0; j < dataLength; j++) {
-				dataBlock[i * dataLength + j] = dataBlock[(i + 1) * dataLength + j];
-			}
-		}
-
-		Atomics.sub(this.firstBlock.data, LIST_LENGTH_INDEX, LIST_LENGTH_INDEX);
-	}
-
-	clear() {
-		this.firstBlock.data[LIST_LENGTH_INDEX] = 0;
-	}
-
-	*[Symbol.iterator]() {
-		let pointer = loadPointer(this.firstBlock.data, 0);
-		let dataMemory = new AllocatedMemory(this.memory, pointer);
-
-		for(let i = 0; i < this.length; i++) {
-			yield this.getDataBlock(dataMemory.data, i);
-		}
-	}
-
-	private getFullDataBlock(dataLength: number): T {
-		let pointerNumber = Atomics.load(this.firstBlock.data, 0);
-		if(this.cachedPointer === pointerNumber && this.cachedFullDataBlock) {
-			return this.cachedFullDataBlock;
-		}
-
-		let pointer = getPointer(pointerNumber);
-		let rawData = new AllocatedMemory(this.memory, pointer);
-
-		let data: T;
-		switch(this.type) {
-			case TYPE.int32:
-				// @ts-expect-error
-				data = new Int32Array(rawData.data.buffer, rawData.bufferByteOffset, dataLength * this.bufferLength);
-				break;
-			case TYPE.uint32:
-				// @ts-expect-error
-				data = new Uint32Array(rawData.data.buffer, rawData.bufferByteOffset, dataLength * this.bufferLength);
-				break;
-			case TYPE.float32:
-				// @ts-expect-error
-				data = new Float32Array(rawData.data.buffer, smemory.bufferByteOffset, dataLength * this.bufferLength);
-				break;
-			default:
-				throw new Error(`Unknown data block type ${this.type}`);
-		}
-
-		this.cachedPointer = pointerNumber;
-		this.cachedFullDataBlock = data;
-
-		return data;
-	}
-	private getDataBlock(rawData: Uint32Array, index: number): T {
-		switch(this.type) {
-			case TYPE.int32:
-				// @ts-expect-error
-				return new Int32Array(rawData.buffer, rawData.byteOffset + index * this.dataLength * 4, this.dataLength);
-			case TYPE.uint32:
-				// @ts-expect-error
-				return new Uint32Array(rawData.buffer, rawData.byteOffset + index * this.dataLength * 4, this.dataLength);
-			case TYPE.float32:
-				// @ts-expect-error
-				return new Float32Array(rawData.buffer, smemory.byteOffset + index * this.dataLength * 4, this.dataLength);
-			default:
-				throw new Error(`Unknown data block type ${this.type}`);
-		}
-	}
-
-	private growBuffer() {
-		let oldBufferLength = this.bufferLength;
-		let newBufferLength = oldBufferLength * 2;
-		let dataLength = this.dataLength;
-
-		let oldPointer = loadPointer(this.firstBlock.data, 0);
-		let oldDataMemory = new AllocatedMemory(this.memory, oldPointer);
-		let oldDataBlock = this.getFullDataBlock(dataLength);
-		let newDataBlock = this.memory.allocUI32(newBufferLength * dataLength);
-		// Copy old buffer into new buffer
-		newDataBlock.data.set(oldDataBlock);
-
-		storePointer(this.firstBlock.data, 0, newDataBlock.bufferPosition, newDataBlock.bufferByteOffset);
-		this.bufferLength = newBufferLength;
-		oldDataMemory.free();
-	}
-
-	free() {
-		let pointer = loadPointer(this.firstBlock.data, 0);
-		let dataMemory = new AllocatedMemory(this.memory, pointer);
-
-		dataMemory.free();
-		this.firstBlock.free();
-	}
-
-	getSharedMemory(): SharedVectorMemory {
-		return {
-			firstBlock: this.firstBlock.getSharedMemory()
-		};
-	}
-}
-
-interface SharedVectorConfig<T extends Uint32Array | Int32Array | Float32Array> {
-	type?: TypedArrayConstructor<T>
-	dataLength?: number
-
-	bufferLength?: number
-}
-interface SharedVectorMemory {
-	firstBlock: SharedAllocatedMemory
-}
-
-export type { SharedVectorConfig, SharedVectorMemory };