echogarden 2.7.0 → 2.8.0

package/src/utilities/WasmMemoryManager.ts

@@ -1,566 +0,0 @@
-import { decodeUtf8, encodeUtf8 } from "../encodings/Utf8.js"
-import { TypedArray } from "../typings/TypedArray.js"
-import { concatUint8Arrays } from "./Utilities.js"
-
-export class WasmMemoryManager {
-	wasmModule: any
-
-	private wasmAlloc: WasmAllocMethod
-	private wasmFree: WasmFreeMethod
-
-	private allocatedReferences = new Set<WasmRef>()
-
-	constructor(wasmModule: any, options?: WasmMemoryManagerOptions) {
-		options = options ?? {}
-
-		this.wasmModule = wasmModule
-
-		if (options.wasmAlloc) {
-			this.wasmAlloc = options.wasmAlloc
-		} else {
-			if (!wasmModule._malloc) {
-				throw new Error(`Couldn't find a '_malloc' function in the module and no custom 'wasmAlloc' was provided in the options`)
-			}
-
-			this.wasmAlloc = wasmModule._malloc
-		}
-
-		if (options.wasmFree) {
-			this.wasmFree = options.wasmFree
-		} else {
-			if (!wasmModule._free) {
-				throw new Error(`Couldn't find a '_malloc' function in the module and no custom 'wasmFree' was provided in the options`)
-			}
-
-			this.wasmFree = wasmModule._free
-		}
-	}
-
-	allocInt8() {
-		const address = this.alloc(1)
-		return this.wrapInt8(address).clear()
-	}
-
-	wrapInt8(address: number) {
-		const ref = new Int8Ref(address, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocUint8() {
-		const address = this.alloc(1)
-		return this.wrapUint8(address).clear()
-	}
-
-	wrapUint8(address: number) {
-		const ref = new Uint8Ref(address, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocInt16() {
-		const address = this.alloc(2)
-		return this.wrapInt16(address).clear()
-	}
-
-	wrapInt16(address: number) {
-		const ref = new Int16Ref(address, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocUint16() {
-		const address = this.alloc(2)
-		return this.wrapUint16(address).clear()
-	}
-
-	wrapUint16(address: number) {
-		const ref = new Uint16Ref(address, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocInt32() {
-		const address = this.alloc(4)
-		return this.wrapInt32(address).clear()
-	}
-
-	wrapInt32(address: number) {
-		const ref = new Int32Ref(address, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocUint32() {
-		const address = this.alloc(4)
-		return this.wrapUint32(address).clear()
-	}
-
-	wrapUint32(address: number) {
-		const ref = new Uint32Ref(address, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocPointer() {
-		const address = this.alloc(4)
-		return this.wrapPointer(address).clear()
-	}
-
-	wrapPointer(address: number) {
-		const ref = new PointerRef(address, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocFloat32() {
-		const address = this.alloc(4)
-		return this.wrapFloat64(address).clear()
-	}
-
-	wrapFloat32(address: number) {
-		const ref = new Float32Ref(address, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocFloat64() {
-		const address = this.alloc(8)
-		return this.wrapFloat64(address).clear()
-	}
-
-	wrapFloat64(address: number) {
-		const ref = new Float64Ref(address, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	// Allocate or wrap arrays
-	allocInt8Array(length: number) {
-		const address = this.alloc(length << 0)
-		return this.wrapInt8Array(address, length).clear()
-	}
-
-	wrapInt8Array(address: number, length: number) {
-		const ref = new Int8ArrayRef(address, length, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocUint8Array(length: number) {
-		const address = this.alloc(length << 0)
-		return this.wrapUint8Array(address, length).clear()
-	}
-
-	wrapUint8Array(address: number, length: number) {
-		const ref = new Uint8ArrayRef(address, length, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocInt16Array(length: number) {
-		const address = this.alloc(length << 1)
-		return this.wrapInt16Array(address, length).clear()
-	}
-
-	wrapInt16Array(address: number, length: number) {
-		const ref = new Int16ArrayRef(address, length, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocUint16Array(length: number) {
-		const address = this.alloc(length << 1)
-		return this.wrapUint16Array(address, length).clear()
-	}
-
-	wrapUint16Array(address: number, length: number) {
-		const ref = new Uint16ArrayRef(address, length, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocInt32Array(length: number) {
-		const address = this.alloc(length << 2)
-		return this.wrapInt32Array(address, length).clear()
-	}
-
-	wrapInt32Array(address: number, length: number) {
-		const ref = new Int32ArrayRef(address, length, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocUint32Array(length: number) {
-		const address = this.alloc(length << 2)
-		return this.wrapUint32Array(address, length).clear()
-	}
-
-	wrapUint32Array(address: number, length: number) {
-		const ref = new Uint32ArrayRef(address, length, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocFloat32Array(length: number) {
-		const address = this.alloc(length << 2)
-		return this.wrapFloat32Array(address, length).clear()
-	}
-
-	wrapFloat32Array(address: number, length: number) {
-		const ref = new Float32ArrayRef(address, length, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocFloat64Array(length: number) {
-		const address = this.alloc(length << 3)
-		return this.wrapFloat64Array(address, length).clear()
-	}
-
-	wrapFloat64Array(address: number, length: number) {
-		const ref = new Float64ArrayRef(address, length, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	allocNullTerminatedUtf8String(str: string) {
-		const strBuffer = concatUint8Arrays([encodeUtf8(str), new Uint8Array(1)])
-		const ref = this.allocUint8Array(strBuffer.length)
-		ref.view.set(strBuffer)
-		return ref
-	}
-
-	wrapNullTerminatedUtf8String(address: number) {
-		const ref = new NullTerminatedUtf8StringRef(address, this)
-		this.allocatedReferences.add(ref)
-		return ref
-	}
-
-	private alloc(size: number) {
-		const ptr = this.wasmAlloc(size)
-
-		return ptr
-	}
-
-	free(wasmReference: WasmRef) {
-		if (wasmReference.isFreed) {
-			return
-		}
-
-		this.wasmFree(wasmReference.address)
-
-		this.allocatedReferences.delete(wasmReference)
-		wasmReference.clearAddress()
-	}
-
-	freeAll() {
-		for (const wasmReference of this.allocatedReferences) {
-			this.free(wasmReference)
-		}
-	}
-
-	detach<T extends WasmRef>(wasmReference: T) {
-		this.allocatedReferences.delete(wasmReference)
-
-		return wasmReference
-	}
-}
-
-abstract class ValueRef<T extends number | string> {
-	protected ptr: number
-	private readonly manager: WasmMemoryManager
-
-	protected get module() { return this.manager.wasmModule }
-
-	constructor(ptr: number, manager: WasmMemoryManager) {
-		this.ptr = ptr
-		this.manager = manager
-	}
-
-	get value(): T {
-		this.assertNotFreed()
-		return this.getValue()
-	}
-
-	set value(newValue: T) {
-		this.assertNotFreed()
-		this.setValue(newValue)
-	}
-
-	abstract getValue(): T
-	abstract setValue(newValue: T): void
-
-	get address() {
-		this.assertNotFreed()
-		return this.ptr
-	}
-
-	clear() {
-		this.assertNotFreed()
-
-		if (typeof this.value == 'number') {
-			this.value = 0 as any
-		} else if (typeof this.value == 'string') {
-			throw new Error('Unimplemented')
-		}
-
-		return this
-	}
-
-	free() {
-		this.manager.free(this as any)
-	}
-
-	detach() {
-		return this.manager.detach(this as any) as this
-	}
-
-	clearAddress() {
-		this.ptr = 0
-	}
-
-	get isFreed() { return this.ptr == 0 }
-
-	protected assertNotFreed() {
-		if (this.isFreed) {
-			throw new Error('Attempt to read a freed WASM value reference.')
-		}
-	}
-}
-
-export class Int8Ref extends ValueRef<number> {
-	getValue() {
-		return this.module.HEAP8[this.ptr >>> 0] as number
-	}
-
-	setValue(newValue: number) {
-		this.module.HEAP8[this.ptr >>> 0] = newValue
-	}
-}
-
-export class Uint8Ref extends ValueRef<number> {
-	getValue() {
-		return this.module.HEAPU8[this.ptr >>> 0] as number
-	}
-
-	setValue(newValue: number) {
-		this.module.HEAPU8[this.ptr >>> 0] = newValue
-	}
-}
-
-export class Int16Ref extends ValueRef<number> {
-	getValue() {
-		return this.module.HEAP16[this.ptr >>> 1] as number
-	}
-
-	setValue(newValue: number) {
-		this.module.HEAP16[this.ptr >>> 1] = newValue
-	}
-}
-
-export class Uint16Ref extends ValueRef<number> {
-	getValue() {
-		return this.module.HEAPU16[this.ptr >>> 1] as number
-	}
-
-	setValue(newValue: number) {
-		this.module.HEAPU16[this.ptr >>> 1] = newValue
-	}
-}
-
-export class Int32Ref extends ValueRef<number> {
-	getValue() {
-		return this.module.HEAP32[this.ptr >>> 2] as number
-	}
-
-	setValue(newValue: number) {
-		this.module.HEAP32[this.ptr >>> 2] = newValue
-	}
-}
-
-export class Uint32Ref extends ValueRef<number> {
-	getValue() {
-		return this.module.HEAPU32[this.ptr >>> 2] as number
-	}
-
-	setValue(newValue: number) {
-		this.module.HEAPU32[this.ptr >>> 2] = newValue
-	}
-}
-
-export class PointerRef extends Uint32Ref { }
-
-export class Float32Ref extends ValueRef<number> {
-	getValue() {
-		return this.module.HEAPF32[this.ptr >>> 2] as number
-	}
-
-	setValue(newValue: number) {
-		this.module.HEAPF32[this.ptr >>> 2] = newValue
-	}
-}
-
-export class Float64Ref extends ValueRef<number> {
-	getValue() {
-		return this.module.HEAPF64[this.ptr >>> 3] as number
-	}
-
-	setValue(newValue: number) {
-		this.module.HEAPF64[this.ptr >>> 3] = newValue
-	}
-}
-
-export class NullTerminatedUtf8StringRef extends ValueRef<string> {
-	getValue() {
-		const ptr = this.ptr >>> 0
-
-		const heapU8 = this.module.HEAPU8
-
-		const endByteOffset = heapU8.subarray(ptr).indexOf(0)
-
-		const strBytes = heapU8.subarray(ptr, ptr + endByteOffset)
-
-		const str = decodeUtf8(strBytes)
-
-		return str
-	}
-
-	setValue(newValue: string) {
-		throw new Error('Unimplemented')
-	}
-}
-
-abstract class TypedArrayRef<T extends TypedArray> {
-	protected ptr: number
-	readonly length: number
-	private readonly manager: WasmMemoryManager
-
-	get module() { return this.manager.wasmModule }
-
-	constructor(ptr: number, length: number, manager: WasmMemoryManager) {
-		this.ptr = ptr
-		this.length = length
-		this.manager = manager
-	}
-
-	get view() {
-		this.assertNotFreed()
-		return this.getView()
-	}
-
-	protected abstract getView(): T
-
-	slice(start?: number, end?: number) {
-		return this.view.slice(start, end)
-	}
-
-	get address() {
-		this.assertNotFreed()
-		return this.ptr
-	}
-
-	clear() {
-		this.view.fill(0)
-		return this
-	}
-
-	free() {
-		this.manager.free(this)
-	}
-
-	clearAddress() {
-		this.ptr = 0
-	}
-
-	detach() {
-		return this.manager.detach(this)
-	}
-
-	get isFreed() { return this.ptr == 0 }
-
-	protected assertNotFreed() {
-		if (this.isFreed) {
-			throw new Error('Attempt to read a freed WASM typed array reference.')
-		}
-	}
-}
-
-export class Int8ArrayRef extends TypedArrayRef<Int8Array> {
-	getView() {
-		const startIndex = this.ptr >>> 0
-		return this.module.HEAP8.subarray(startIndex, startIndex + this.length) as Int8Array
-	}
-}
-
-export class Uint8ArrayRef extends TypedArrayRef<Uint8Array> {
-	getView() {
-		const startIndex = this.ptr >>> 0
-		return this.module.HEAPU8.subarray(startIndex, startIndex + this.length) as Uint8Array
-	}
-
-	readAsNullTerminatedUtf8String(): string {
-		let strBytes = this.view
-
-		const indexOfFirstZero = strBytes.indexOf(0)
-
-		if (indexOfFirstZero >= 0) {
-			strBytes = strBytes.subarray(0, indexOfFirstZero)
-		}
-
-		const str = decodeUtf8(strBytes)
-
-		return str
-	}
-}
-
-export class Int16ArrayRef extends TypedArrayRef<Int16Array> {
-	getView() {
-		const startIndex = this.ptr >>> 1
-		return this.module.HEAP16.subarray(startIndex, startIndex + this.length) as Int16Array
-	}
-}
-
-export class Uint16ArrayRef extends TypedArrayRef<Uint16Array> {
-	getView() {
-		const startIndex = this.ptr >>> 1
-		return this.module.HEAPU16.subarray(startIndex, startIndex + this.length) as Uint16Array
-	}
-}
-
-export class Int32ArrayRef extends TypedArrayRef<Int32Array> {
-	getView() {
-		const startIndex = this.ptr >>> 2
-		return this.module.HEAP32.subarray(startIndex, startIndex + this.length) as Int32Array
-	}
-}
-
-export class Uint32ArrayRef extends TypedArrayRef<Uint32Array> {
-	getView() {
-		const startIndex = this.ptr >>> 2
-		return this.module.HEAPU32.subarray(startIndex, startIndex + this.length) as Uint32Array
-	}
-}
-
-export class Float32ArrayRef extends TypedArrayRef<Float32Array> {
-	getView() {
-		const startIndex = this.ptr >>> 2
-		return this.module.HEAPF32.subarray(startIndex, startIndex + this.length) as Float32Array
-	}
-}
-
-export class Float64ArrayRef extends TypedArrayRef<Float64Array> {
-	getView() {
-		const startIndex = this.ptr >>> 3
-		return this.module.HEAPF64.subarray(startIndex, startIndex + this.length) as Float64Array
-	}
-}
-export type WasmRef = ValueRef<number> | ValueRef<string> | TypedArrayRef<TypedArray>
-
-export interface WasmMemoryManagerOptions {
-	wasmAlloc?: WasmAllocMethod
-	wasmFree?: WasmFreeMethod
-}
-
-export type WasmAllocMethod = (size: number) => number
-export type WasmFreeMethod = (address: number) => void