diff options
Diffstat (limited to 'src/zilch/app/object-store.js')
| -rw-r--r-- | src/zilch/app/object-store.js | 185 |
1 files changed, 185 insertions, 0 deletions
diff --git a/src/zilch/app/object-store.js b/src/zilch/app/object-store.js new file mode 100644 index 0000000..8a4715d --- /dev/null +++ b/src/zilch/app/object-store.js @@ -0,0 +1,185 @@ +class ObjectStore { + static types = Object.freeze({ + 0: "object", + 1: "string", + 2: "int", + 3: "uint", + 4: "float", + 5: "undefined", + 6: "future", + + "object": 0, + "string": 1, + "int": 2, + "uint": 3, + "float": 4, + "undefined": 5, + "future": 6, + }); + + static store = { 0: null }; + static methods = {}; + + static generateFreeId() { + let id = 0; + + while (id in ObjectStore.store) { + id = Math.floor(Math.random() * (2**32 - 1)) + } + + return id; + } + + static decodeString(base, len) { + const slice = new Uint8Array(wasm.memory.buffer, base, len); + return new TextDecoder().decode(slice); + } + + static decodeCall(view, offset) { + const method = ObjectStore.methods[view.getUint32(offset, true)] + + if (!method) throw "unknown method, cannot decode"; + + return { + method: method, + num_args: view.getUint8(offset + 4, true), + } + } + + static decodeValue(view, offset, results) { + const kind = ObjectStore.types[view.getUint8(offset, true)]; + + if (!kind) throw "unknown type, cannot decode"; + + if (kind === 'string') { + const ptr = view.getUint32(offset + 8, true) + const len = view.getUint32(offset + 12, true) + return ObjectStore.decodeString(ptr, len); + } + + if (kind === 'int') { + return view.getInt32(offset + 8, true); + } + + if (kind === 'uint') { + return view.getUint32(offset + 8, true); + } + + if (kind === 'object') { + const id = view.getUint32(offset + 8, true); + return ObjectStore.store[id]; + } + + if (kind === 'float') { + return view.getFloat64(offset + 8, true); + } + + if (kind === 'future') { + return results[view.getUint32(offset + 8, true)]; + } + } + + static registerObject(id, obj) { + ObjectStore.store[id] = obj; + Object.defineProperty(obj, ZsId, { + enumerable: false, + writable: false, + configurable: true, + value: id, + }) + } + + static writeValue(ptr, value) { + if (ptr === 0) return; + + const mem = new DataView(wasm.memory.buffer, ptr); + + if (typeof value === 'object' || typeof value === 'function') { + mem.setUint8(0, ObjectStore.types['object'], true); + let id = value == null ? 0 : value[ZsId]; + + if (id === undefined) { + id = ObjectStore.generateFreeId(); + ObjectStore.registerObject(id, value); + } + + mem.setUint32(8, id, true); + + return; + } + + if (typeof value === 'number' && Number.isInteger(value) && value >= 0) { + mem.setUint8(0, ObjectStore.types['uint'], true); + mem.setUint32(8, value, true) + return; + } + + if (typeof value === 'number' && Number.isInteger(value)) { + mem.setUint8(0, ObjectStore.types['int'], true); + mem.setInt32(8, value, true) + return; + } + + if (typeof value === 'number') { + mem.setUint8(0, ObjectStore.types['float'], true); + mem.setFloat64(8, value, true) + return; + } + + if (typeof value === 'string') { + const string_ptr = wasm.exports.valueAllocBuffer(ptr, value.length); + const encoder = new TextEncoder(); + const string = encoder.encode(value); + const memory = new Uint8Array(wasm.memory.buffer); + memory.set(string, string_ptr); + return; + } + + if (typeof value === 'undefined') { + mem.setUint8(0, ObjectStore.types['undefined'], true); + return; + } + } + + static async processWasm( + calls_base, + values_base, + result_base, + length, + ) { + const offset = { + call: 0, + value: 0, + result: 0, + } + + const calls_view = new DataView(wasm.memory.buffer, calls_base); + const values_view = new DataView(wasm.memory.buffer, values_base); + const results_view = new DataView(wasm.memory.buffer, result_base); + const results = []; + + for (let i = 0; i < length; ++i) { + const call = ObjectStore.decodeCall(calls_view, offset.call); + offset.call += wasm.size_of.Call; + + let args = new Array(call.num_args).fill().map(_ => { + const value = ObjectStore.decodeValue(values_view, offset.value, results); + offset.value += wasm.size_of.Value; + return value; + }); + + let result = call.method.fn(...args); + + if (call.method.await) { + result = await result; + } + + const result_ptr = results_view.getUint32(offset.result, true); + offset.result += wasm.size_of.Ptr; + + results.push(result); + + ObjectStore.writeValue(result_ptr, result); + } + } +} |