Add JSSending.receive(...) to receive multiple objects at once

Author: kateinoigakukun

Diff for: Examples/OffscrenCanvas/Sources/MyApp/main.swift

@@ -11,7 +11,7 @@ protocol CanvasRenderer {
 struct BackgroundRenderer: CanvasRenderer {
     func render(canvas: JSObject, size: Int) async throws {
         let executor = try await WebWorkerTaskExecutor(numberOfThreads: 1)
-        let transfer = JSTransferring(canvas)
+        let transfer = JSSending.transfer(canvas)
         let renderingTask = Task(executorPreference: executor) {
             let canvas = try await transfer.receive()
             try await renderAnimation(canvas: canvas, size: size)

Diff for: Runtime/src/index.ts

@@ -11,6 +11,7 @@ import {
 import * as JSValue from "./js-value.js";
 import { Memory } from "./memory.js";
 import { deserializeError, MainToWorkerMessage, MessageBroker, ResponseMessage, ITCInterface, serializeError, SwiftRuntimeThreadChannel, WorkerToMainMessage } from "./itc.js";
+import { decodeObjectRefs } from "./js-value.js";
 
 export type SwiftRuntimeOptions = {
     /**
@@ -208,7 +209,7 @@ export class SwiftRuntime {
                     } catch (error) {
                         responseMessage.data.response = {
                             ok: false,
-                            error: serializeError(new TypeError(`Failed to serialize response message: ${error}`))
+                            error: serializeError(new TypeError(`Failed to serialize message: ${error}`))
                         };
                         newBroker.reply(responseMessage);
                     }
@@ -648,24 +649,56 @@ export class SwiftRuntime {
                 // Main thread's tid is always -1
                 return this.tid || -1;
             },
-            swjs_request_transferring_object: (
-                object_ref: ref,
+            swjs_request_sending_object: (
+                sending_object: ref,
+                transferring_objects: pointer,
+                transferring_objects_count: number,
                 object_source_tid: number,
-                transferring: pointer,
+                sending_context: pointer,
             ) => {
                 if (!this.options.threadChannel) {
                     throw new Error("threadChannel is not set in options given to SwiftRuntime. Please set it to request transferring objects.");
                 }
                 const broker = getMessageBroker(this.options.threadChannel);
+                const memory = this.memory;
+                const transferringObjects = decodeObjectRefs(transferring_objects, transferring_objects_count, memory);
+                broker.request({
+                    type: "request",
+                    data: {
+                        sourceTid: this.tid ?? MAIN_THREAD_TID,
+                        targetTid: object_source_tid,
+                        context: sending_context,
+                        request: {
+                            method: "send",
+                            parameters: [sending_object, transferringObjects, sending_context],
+                        }
+                    }
+                })
+            },
+            swjs_request_sending_objects: (
+                sending_objects: pointer,
+                sending_objects_count: number,
+                transferring_objects: pointer,
+                transferring_objects_count: number,
+                object_source_tid: number,
+                sending_context: pointer,
+            ) => {
+                if (!this.options.threadChannel) {
+                    throw new Error("threadChannel is not set in options given to SwiftRuntime. Please set it to request transferring objects.");
+                }
+                const broker = getMessageBroker(this.options.threadChannel);
+                const memory = this.memory;
+                const sendingObjects = decodeObjectRefs(sending_objects, sending_objects_count, memory);
+                const transferringObjects = decodeObjectRefs(transferring_objects, transferring_objects_count, memory);
                 broker.request({
                     type: "request",
                     data: {
                         sourceTid: this.tid ?? MAIN_THREAD_TID,
                         targetTid: object_source_tid,
-                        context: transferring,
+                        context: sending_context,
                         request: {
-                            method: "transfer",
-                            parameters: [object_ref, transferring],
+                            method: "sendObjects",
+                            parameters: [sendingObjects, transferringObjects, sending_context],
                         }
                     }
                 })

Diff for: Runtime/src/itc.ts

@@ -85,9 +85,16 @@ export type SwiftRuntimeThreadChannel =
 export class ITCInterface {
     constructor(private memory: Memory) {}
 
-    transfer(objectRef: ref, transferring: pointer): { object: any, transferring: pointer, transfer: Transferable[] } {
-        const object = this.memory.getObject(objectRef);
-        return { object, transferring, transfer: [object] };
+    send(sendingObject: ref, transferringObjects: ref[], sendingContext: pointer): { object: any, sendingContext: pointer, transfer: Transferable[] } {
+        const object = this.memory.getObject(sendingObject);
+        const transfer = transferringObjects.map(ref => this.memory.getObject(ref));
+        return { object, sendingContext, transfer };
+    }
+
+    sendObjects(sendingObjects: ref[], transferringObjects: ref[], sendingContext: pointer): { object: any[], sendingContext: pointer, transfer: Transferable[] } {
+        const objects = sendingObjects.map(ref => this.memory.getObject(ref));
+        const transfer = transferringObjects.map(ref => this.memory.getObject(ref));
+        return { object: objects, sendingContext, transfer };
     }
 
     release(objectRef: ref): { object: undefined, transfer: Transferable[] } {

Diff for: Runtime/src/js-value.ts

@@ -1,5 +1,5 @@
 import { Memory } from "./memory.js";
-import { assertNever, JavaScriptValueKindAndFlags, pointer } from "./types.js";
+import { assertNever, JavaScriptValueKindAndFlags, pointer, ref } from "./types.js";
 
 export const enum Kind {
     Boolean = 0,
@@ -142,3 +142,11 @@ export const writeAndReturnKindBits = (
     }
     throw new Error("Unreachable");
 };
+
+export function decodeObjectRefs(ptr: pointer, length: number, memory: Memory): ref[] {
+    const result: ref[] = new Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = memory.readUint32(ptr + 4 * i);
+    }
+    return result;
+}

Diff for: Runtime/src/types.ts

@@ -115,10 +115,20 @@ export interface ImportedFunctions {
     swjs_listen_message_from_worker_thread: (tid: number) => void;
     swjs_terminate_worker_thread: (tid: number) => void;
     swjs_get_worker_thread_id: () => number;
-    swjs_request_transferring_object: (
-        object_ref: ref,
+    swjs_request_sending_object: (
+        sending_object: ref,
+        transferring_objects: pointer,
+        transferring_objects_count: number,
         object_source_tid: number,
-        transferring: pointer,
+        sending_context: pointer,
+    ) => void;
+    swjs_request_sending_objects: (
+        sending_objects: pointer,
+        sending_objects_count: number,
+        transferring_objects: pointer,
+        transferring_objects_count: number,
+        object_source_tid: number,
+        sending_context: pointer,
     ) => void;
 }