Pass around a DataView on the JS side; cha nge memory layout for numbers

The use of a DataView reduces function paramater count.

There are now only two payload slots. Numbers use them as a single Double, while every other type just uses them as two UInt32s

Co-Authored-By: Manuel <unkaputtbar@users.noreply.github.com>

Author: j-f1

Runtime/src/index.ts

@@ -59,7 +59,7 @@ class SwiftRuntimeHeap {
 
     allocHeap(value: any) {
         const isObject = typeof value == "object";
-        const entry = this._heapEntryByValue.get(value); 
+        const entry = this._heapEntryByValue.get(value);
         if (isObject && entry) {
             entry.rc++
             return entry.id
@@ -124,10 +124,12 @@ export class SwiftRuntime {
             const exports = this.instance.exports as any as SwiftRuntimeExportedFunctions;
             const argc = args.length
             const argv = exports.swjs_prepare_host_function_call(argc)
+            const uint32Memory = new Uint32Array(memory().buffer, argv, args.length * 3)
             for (let index = 0; index < args.length; index++) {
                 const argument = args[index]
-                const base = argv + 24 * index
-                writeValue(argument, base, base + 4, base + 8, base + 16)
+                const offset = 12 * index
+                const dataView = new DataView(memory().buffer, argv + offset, 12);
+                writeValue(argument, dataView)
             }
             let output: any;
             const callback_func_ref = this.heap.allocHeap(function (result: any) {
@@ -142,24 +144,20 @@ export class SwiftRuntime {
         const textEncoder = new TextEncoder(); // Only support utf-8
 
         const readString = (ptr: pointer, len: number) => {
-            const uint8Memory = new Uint8Array(memory().buffer);
-            return textDecoder.decode(uint8Memory.subarray(ptr, ptr + len));
+            const uint8Memory = new Uint8Array(memory().buffer, ptr, len);
+            return textDecoder.decode(uint8Memory);
         }
 
         const writeString = (ptr: pointer, bytes: Uint8Array) => {
-            const uint8Memory = new Uint8Array(memory().buffer);
+            const uint8Memory = new Uint8Array(memory().buffer, ptr);
             for (const [index, byte] of bytes.entries()) {
-                uint8Memory[ptr + index] = byte
+                uint8Memory[index] = byte
             }
-            uint8Memory[ptr]
         }
 
         const readUInt32 = (ptr: pointer) => {
-            const uint8Memory = new Uint8Array(memory().buffer);
-            return uint8Memory[ptr + 0]
-                + (uint8Memory[ptr + 1] << 8)
-                + (uint8Memory[ptr + 2] << 16)
-                + (uint8Memory[ptr + 3] << 24)
+            const uint32Memory = new Uint32Array(memory().buffer, ptr, 1);
+            return uint32Memory[0];
         }
 
         const readFloat64 = (ptr: pointer) => {
@@ -168,37 +166,37 @@ export class SwiftRuntime {
         }
 
         const writeUint32 = (ptr: pointer, value: number) => {
-            const uint8Memory = new Uint8Array(memory().buffer);
-            uint8Memory[ptr + 0] = (value & 0x000000ff) >> 0
-            uint8Memory[ptr + 1] = (value & 0x0000ff00) >> 8
-            uint8Memory[ptr + 2] = (value & 0x00ff0000) >> 16
-            uint8Memory[ptr + 3] = (value & 0xff000000) >> 24
+            const uint32Memory = new Uint32Array(memory().buffer, ptr);
+            uint32Memory[0] = (value & 0xffffffff);
         }
 
         const writeFloat64 = (ptr: pointer, value: number) => {
             const dataView = new DataView(memory().buffer);
             dataView.setFloat64(ptr, value, true);
         }
 
-        const decodeValue = (
-            kind: JavaScriptValueKind,
-            payload1: number, payload2: number, payload3: number
-        ) => {
+        const decodeValue = (dataView: DataView) => {
+            const kind = dataView.getUint32(0, true);
+            const payload1_ptr = Uint32Array.BYTES_PER_ELEMENT
+            const payload2_ptr = 2 * Uint32Array.BYTES_PER_ELEMENT
             switch (kind) {
                 case JavaScriptValueKind.Boolean: {
-                    switch (payload1) {
+                    switch (dataView.getUint32(payload1_ptr, true)) {
                         case 0: return false
                         case 1: return true
                     }
                 }
                 case JavaScriptValueKind.Number: {
-                    return payload3;
+                    return dataView.getFloat64(payload1_ptr, true);
                 }
                 case JavaScriptValueKind.String: {
-                    return readString(payload1, payload2)
+                    return readString(
+                      dataView.getUint32(payload1_ptr, true),
+                      dataView.getUint32(payload2_ptr, true)
+                    );
                 }
                 case JavaScriptValueKind.Object: {
-                    return this.heap.referenceHeap(payload1)
+                    return this.heap.referenceHeap(dataView.getUint32(payload1_ptr, true))
                 }
                 case JavaScriptValueKind.Null: {
                     return null
@@ -207,60 +205,57 @@ export class SwiftRuntime {
                     return undefined
                 }
                 case JavaScriptValueKind.Function: {
-                    return this.heap.referenceHeap(payload1)
+                    return this.heap.referenceHeap(dataView.getUint32(payload1_ptr, true))
                 }
                 default:
                     throw new Error(`Type kind "${kind}" is not supported`)
             }
         }
 
-        const writeValue = (
-            value: any, kind_ptr: pointer,
-            payload1_ptr: pointer, payload2_ptr: pointer, payload3_ptr: pointer
-        ) => {
+        const writeValue = (value: any, dataView: DataView) => {
+            const payload1_ptr = Uint32Array.BYTES_PER_ELEMENT
+            const payload2_ptr = 2 * Uint32Array.BYTES_PER_ELEMENT
             if (value === null) {
-                writeUint32(kind_ptr, JavaScriptValueKind.Null);
-                writeUint32(payload1_ptr, 0);
-                writeUint32(payload2_ptr, 0);
+                dataView.setUint32(0, JavaScriptValueKind.Null, true);
+                dataView.setUint32(payload1_ptr, 0, true);
+                dataView.setUint32(payload2_ptr, 0, true);
                 return;
             }
             switch (typeof value) {
                 case "boolean": {
-                    writeUint32(kind_ptr, JavaScriptValueKind.Boolean);
-                    writeUint32(payload1_ptr, value ? 1 : 0);
-                    writeUint32(payload2_ptr, 0);
+                    dataView.setUint32(0, JavaScriptValueKind.Boolean, true);
+                    dataView.setUint32(payload1_ptr, value ? 1 : 0, true);
+                    dataView.setUint32(payload2_ptr, 0, true);
                     break;
                 }
                 case "number": {
-                    writeUint32(kind_ptr, JavaScriptValueKind.Number);
-                    writeUint32(payload1_ptr, 0);
-                    writeUint32(payload2_ptr, 0);
-                    writeFloat64(payload3_ptr, value);
+                    dataView.setUint32(0, JavaScriptValueKind.Number, true);
+                    dataView.setFloat64(payload1_ptr, value, true);
                     break;
                 }
                 case "string": {
                     const bytes = textEncoder.encode(value);
-                    writeUint32(kind_ptr, JavaScriptValueKind.String);
-                    writeUint32(payload1_ptr, this.heap.allocHeap(bytes));
-                    writeUint32(payload2_ptr, bytes.length);
+                    dataView.setUint32(0, JavaScriptValueKind.String, true);
+                    dataView.setUint32(payload1_ptr, this.heap.allocHeap(bytes), true);
+                    dataView.setUint32(payload2_ptr, bytes.length, true);
                     break;
                 }
                 case "undefined": {
-                    writeUint32(kind_ptr, JavaScriptValueKind.Undefined);
-                    writeUint32(payload1_ptr, 0);
-                    writeUint32(payload2_ptr, 0);
+                    dataView.setUint32(0, JavaScriptValueKind.Undefined, true);
+                    dataView.setUint32(payload1_ptr, 0, true);
+                    dataView.setUint32(payload2_ptr, 0, true);
                     break;
                 }
                 case "object": {
-                    writeUint32(kind_ptr, JavaScriptValueKind.Object);
-                    writeUint32(payload1_ptr, this.heap.allocHeap(value));
-                    writeUint32(payload2_ptr, 0);
+                    dataView.setUint32(0, JavaScriptValueKind.Object, true);
+                    dataView.setUint32(payload1_ptr, this.heap.allocHeap(value), true);
+                    dataView.setUint32(payload2_ptr, 0, true);
                     break;
                 }
                 case "function": {
-                    writeUint32(kind_ptr, JavaScriptValueKind.Function);
-                    writeUint32(payload1_ptr, this.heap.allocHeap(value));
-                    writeUint32(payload2_ptr, 0);
+                    dataView.setUint32(0, JavaScriptValueKind.Function, true);
+                    dataView.setUint32(payload1_ptr, this.heap.allocHeap(value), true);
+                    dataView.setUint32(payload2_ptr, 0, true);
                     break;
                 }
                 default:
@@ -274,74 +269,71 @@ export class SwiftRuntime {
         const decodeValues = (ptr: pointer, length: number) => {
             let result = []
             for (let index = 0; index < length; index++) {
-                const base = ptr + 24 * index
-                const kind = readUInt32(base)
-                const payload1 = readUInt32(base + 4)
-                const payload2 = readUInt32(base + 8)
-                const payload3 = readFloat64(base + 16)
-                result.push(decodeValue(kind, payload1, payload2, payload3))
+                const offset = 12 * index
+                const dataView = new DataView(memory().buffer, ptr + offset, 12);
+                result.push(decodeValue(dataView))
             }
             return result
         }
 
         return {
             swjs_set_prop: (
                 ref: ref, name: pointer, length: number,
-                kind: JavaScriptValueKind,
-                payload1: number, payload2: number, payload3: number
+                rawJSValuePtr: pointer
             ) => {
                 const obj = this.heap.referenceHeap(ref);
-                Reflect.set(obj, readString(name, length), decodeValue(kind, payload1, payload2, payload3))
+                const dataView = new DataView(memory().buffer, rawJSValuePtr, 12);
+                Reflect.set(obj, readString(name, length), decodeValue(dataView))
             },
             swjs_get_prop: (
                 ref: ref, name: pointer, length: number,
-                kind_ptr: pointer,
-                payload1_ptr: pointer, payload2_ptr: pointer, payload3_ptr: number
+                rawJSValuePtr: pointer
             ) => {
                 const obj = this.heap.referenceHeap(ref);
                 const result = Reflect.get(obj, readString(name, length));
-                writeValue(result, kind_ptr, payload1_ptr, payload2_ptr, payload3_ptr);
+                const dataView = new DataView(memory().buffer, rawJSValuePtr, 12);
+                writeValue(result, dataView);
             },
             swjs_set_subscript: (
                 ref: ref, index: number,
-                kind: JavaScriptValueKind,
-                payload1: number, payload2: number, payload3: number
+                rawJSValuePtr: pointer
             ) => {
                 const obj = this.heap.referenceHeap(ref);
-                Reflect.set(obj, index, decodeValue(kind, payload1, payload2, payload3))
+                const dataView = new DataView(memory().buffer, rawJSValuePtr, 12);
+                Reflect.set(obj, index, decodeValue(dataView))
             },
             swjs_get_subscript: (
                 ref: ref, index: number,
-                kind_ptr: pointer,
-                payload1_ptr: pointer, payload2_ptr: pointer, payload3_ptr: pointer
+                rawJSValuePtr: pointer
             ) => {
                 const obj = this.heap.referenceHeap(ref);
                 const result = Reflect.get(obj, index);
-                writeValue(result, kind_ptr, payload1_ptr, payload2_ptr, payload3_ptr);
+                const dataView = new DataView(memory().buffer, rawJSValuePtr, 12);
+                writeValue(result, dataView);
             },
             swjs_load_string: (ref: ref, buffer: pointer) => {
                 const bytes = this.heap.referenceHeap(ref);
                 writeString(buffer, bytes);
             },
             swjs_call_function: (
                 ref: ref, argv: pointer, argc: number,
-                kind_ptr: pointer,
-                payload1_ptr: pointer, payload2_ptr: pointer, payload3_ptr: pointer
+                rawJSValuePtr: pointer
             ) => {
                 const func = this.heap.referenceHeap(ref)
                 const result = Reflect.apply(func, undefined, decodeValues(argv, argc))
-                writeValue(result, kind_ptr, payload1_ptr, payload2_ptr, payload3_ptr);
+                const dataView = new DataView(memory().buffer, rawJSValuePtr, 12);
+                writeValue(result, dataView);
             },
             swjs_call_function_with_this: (
                 obj_ref: ref, func_ref: ref,
                 argv: pointer, argc: number,
-                kind_ptr: pointer,
-                payload1_ptr: pointer, payload2_ptr: pointer, payload3_ptr: pointer
+                rawJSValuePtr: pointer
             ) => {
                 const obj = this.heap.referenceHeap(obj_ref)
                 const func = this.heap.referenceHeap(func_ref)
                 const result = Reflect.apply(func, obj, decodeValues(argv, argc))
-                writeValue(result, kind_ptr, payload1_ptr, payload2_ptr, payload3_ptr);
+                const dataView = new DataView(memory().buffer, rawJSValuePtr, 12);
+                writeValue(result, dataView);
             },
             swjs_create_function: (
                 host_func_id: number,

Sources/JavaScriptKit/JSFunction.swift

@@ -9,10 +9,7 @@ public class JSFunctionRef: JSObjectRef {
                 let argv = bufferPointer.baseAddress
                 let argc = bufferPointer.count
                 var result = RawJSValue()
-                _call_function(
-                    self.id, argv, Int32(argc),
-                    &result.kind, &result.payload1, &result.payload2, &result.payload3
-                )
+                _call_function(self.id, argv, Int32(argc), &result)
                 return result
             }
         }
@@ -29,9 +26,7 @@ public class JSFunctionRef: JSObjectRef {
                 let argv = bufferPointer.baseAddress
                 let argc = bufferPointer.count
                 var result = RawJSValue()
-                _call_function_with_this(this.id,
-                                         self.id, argv, Int32(argc),
-                                         &result.kind, &result.payload1, &result.payload2, &result.payload3)
+                _call_function_with_this(this.id, self.id, argv, Int32(argc), &result)
                 return result
             }
         }

Sources/JavaScriptKit/JSValue.swift

@@ -71,30 +71,24 @@ extension JSValue: ExpressibleByIntegerLiteral {
 
 public func getJSValue(this: JSObjectRef, name: String) -> JSValue {
     var rawValue = RawJSValue()
-    _get_prop(this.id, name, Int32(name.count),
-              &rawValue.kind,
-              &rawValue.payload1, &rawValue.payload2, &rawValue.payload3)
+    _get_prop(this.id, name, Int32(name.count), &rawValue)
     return rawValue.jsValue()
 }
 
 public func setJSValue(this: JSObjectRef, name: String, value: JSValue) {
     value.withRawJSValue { rawValue in
-        _set_prop(this.id, name, Int32(name.count), rawValue.kind, rawValue.payload1, rawValue.payload2, rawValue.payload3)
+        _set_prop(this.id, name, Int32(name.count), &rawValue)
     }
 }
 
 public func getJSValue(this: JSObjectRef, index: Int32) -> JSValue {
     var rawValue = RawJSValue()
-    _get_subscript(this.id, index,
-                   &rawValue.kind,
-                   &rawValue.payload1, &rawValue.payload2, &rawValue.payload3)
+    _get_subscript(this.id, index, &rawValue)
     return rawValue.jsValue()
 }
 
 public func setJSValue(this: JSObjectRef, index: Int32, value: JSValue) {
     value.withRawJSValue { rawValue in
-        _set_subscript(this.id, index,
-                       rawValue.kind,
-                       rawValue.payload1, rawValue.payload2, rawValue.payload3)
+        _set_subscript(this.id, index, &rawValue)
     }
 }

Sources/JavaScriptKit/JSValueConvertible.swift

@@ -101,7 +101,7 @@ extension RawJSValue: JSValueConvertible {
         case .boolean:
             return .boolean(payload1 != 0)
         case .number:
-            return .number(payload3)
+            return .number(Double(bitPattern: UInt64(payload1) | (UInt64(payload2) << 32)))
         case .string:
             // +1 for null terminator
             let buffer = malloc(Int(payload2 + 1))!.assumingMemoryBound(to: UInt8.self)
@@ -125,27 +125,25 @@ extension RawJSValue: JSValueConvertible {
 }
 
 extension JSValue {
-    func withRawJSValue<T>(_ body: (RawJSValue) -> T) -> T {
+    func withRawJSValue<T>(_ body: (inout RawJSValue) -> T) -> T {
         let kind: JavaScriptValueKind
         let payload1: JavaScriptPayload1
         let payload2: JavaScriptPayload2
-        var payload3: JavaScriptPayload3 = 0
         switch self {
         case let .boolean(boolValue):
             kind = .boolean
             payload1 = boolValue ? 1 : 0
             payload2 = 0
         case let .number(numberValue):
             kind = .number
-            payload1 = 0
-            payload2 = 0
-            payload3 = numberValue
+            payload1 = UInt32(numberValue.bitPattern & 0x00000000ffffffff)
+            payload2 = UInt32((numberValue.bitPattern & 0xffffffff00000000) >> 32)
         case var .string(stringValue):
             kind = .string
             return stringValue.withUTF8 { bufferPtr in
                 let ptrValue = UInt32(UInt(bitPattern: bufferPtr.baseAddress!))
-                let rawValue = RawJSValue(kind: kind, payload1: JavaScriptPayload1(ptrValue), payload2: JavaScriptPayload2(bufferPtr.count), payload3: 0)
-                return body(rawValue)
+                var rawValue = RawJSValue(kind: kind, payload1: JavaScriptPayload1(ptrValue), payload2: JavaScriptPayload2(bufferPtr.count))
+                return body(&rawValue)
             }
         case let .object(ref):
             kind = .object
@@ -164,8 +162,8 @@ extension JSValue {
             payload1 = JavaScriptPayload1(functionRef.id)
             payload2 = 0
         }
-        let rawValue = RawJSValue(kind: kind, payload1: payload1, payload2: payload2, payload3: payload3)
-        return body(rawValue)
+        var rawValue = RawJSValue(kind: kind, payload1: payload1, payload2: payload2)
+        return body(&rawValue)
     }
 }