Relax deinit requirement

Author: kateinoigakukun

Runtime/src/index.ts

@@ -189,6 +189,7 @@ export class SwiftRuntime {
                 onRequest: (message) => {
                     let returnValue: ResponseMessage["data"]["response"];
                     try {
+                        // @ts-ignore
                         const result = itcInterface[message.data.request.method](...message.data.request.parameters);
                         returnValue = { ok: true, value: result };
                     } catch (error) {
@@ -526,6 +527,25 @@ export class SwiftRuntime {
                 this.memory.release(ref);
             },
 
+            swjs_release_remote: (tid: number, ref: ref) => {
+                if (!this.options.threadChannel) {
+                    throw new Error("threadChannel is not set in options given to SwiftRuntime. Please set it to release objects on remote threads.");
+                }
+                const broker = getMessageBroker(this.options.threadChannel);
+                broker.request({
+                    type: "request",
+                    data: {
+                        sourceTid: this.tid ?? MAIN_THREAD_TID,
+                        targetTid: tid,
+                        context: 0,
+                        request: {
+                            method: "release",
+                            parameters: [ref],
+                        }
+                    }
+                })
+            },
+
             swjs_i64_to_bigint: (value: bigint, signed: number) => {
                 return this.memory.retain(
                     signed ? value : BigInt.asUintN(64, value)

Runtime/src/itc.ts

@@ -89,6 +89,11 @@ export class ITCInterface {
         const object = this.memory.getObject(objectRef);
         return { object, transferring, transfer: [object] };
     }
+
+    release(objectRef: ref): { object: undefined, transfer: Transferable[] } {
+        this.memory.release(objectRef);
+        return { object: undefined, transfer: [] };
+    }
 }
 
 type AllRequests<Interface extends Record<string, any>> = {

Runtime/src/types.ts

@@ -104,6 +104,7 @@ export interface ImportedFunctions {
     ): number;
     swjs_load_typed_array(ref: ref, buffer: pointer): void;
     swjs_release(ref: number): void;
+    swjs_release_remote(tid: number, ref: number): void;
     swjs_i64_to_bigint(value: bigint, signed: bool): ref;
     swjs_bigint_to_i64(ref: ref, signed: bool): bigint;
     swjs_i64_to_bigint_slow(lower: number, upper: number, signed: bool): ref;

Sources/JavaScriptEventLoop/JSObject+Transferring.swift

@@ -56,7 +56,7 @@ public struct JSTransferring<T>: @unchecked Sendable {
     ///
     /// ```swift
     /// let canvas = JSObject.global.document.createElement("canvas").object!
-    /// let transferring = JSObject.transfer(canvas.transferControlToOffscreen().object!)
+    /// let transferring = JSTransferring(canvas.transferControlToOffscreen().object!)
     /// let executor = try await WebWorkerTaskExecutor(numberOfThreads: 1)
     /// Task(executorPreference: executor) {
     ///     let canvas = try await transferring.receive()
@@ -65,12 +65,6 @@ public struct JSTransferring<T>: @unchecked Sendable {
     @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
     public func receive(isolation: isolated (any Actor)? = #isolation, file: StaticString = #file, line: UInt = #line) async throws -> T {
         #if compiler(>=6.1) && _runtime(_multithreaded)
-        // The following sequence of events happens when a `JSObject` is transferred from
-        // the owner thread to the receiver thread:
-        //
-        // [Owner Thread]               [Receiver Thread]
-        //        <-----requestTransfer------ swjs_request_transferring_object    
-        //        ---------transfer---------> swjs_receive_object
         let idInDestination = try await withCheckedThrowingContinuation { continuation in
             self.storage.context.withLock { context in
                 guard context.continuation == nil else {
@@ -148,8 +142,9 @@ extension JSTransferring where T == JSObject {
 @_cdecl("swjs_receive_response")
 #endif
 @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
-func _swjs_receive_response(_ object: JavaScriptObjectRef, _ transferring: UnsafeRawPointer) {
+func _swjs_receive_response(_ object: JavaScriptObjectRef, _ transferring: UnsafeRawPointer?) {
     #if compiler(>=6.1) && _runtime(_multithreaded)
+    guard let transferring = transferring else { return }
     let context = Unmanaged<_JSTransferringContext>.fromOpaque(transferring).takeRetainedValue()
     context.withLock { state in
         assert(state.continuation != nil, "JSObject.Transferring object is not yet received!?")
@@ -169,8 +164,9 @@ func _swjs_receive_response(_ object: JavaScriptObjectRef, _ transferring: Unsaf
 @_cdecl("swjs_receive_error")
 #endif
 @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
-func _swjs_receive_error(_ error: JavaScriptObjectRef, _ transferring: UnsafeRawPointer) {
+func _swjs_receive_error(_ error: JavaScriptObjectRef, _ transferring: UnsafeRawPointer?) {
     #if compiler(>=6.1) && _runtime(_multithreaded)
+    guard let transferring = transferring else { return }
     let context = Unmanaged<_JSTransferringContext>.fromOpaque(transferring).takeRetainedValue()
     context.withLock { state in
         assert(state.continuation != nil, "JSObject.Transferring object is not yet received!?")

Sources/JavaScriptKit/FundamentalObjects/JSObject.swift

@@ -203,7 +203,13 @@ public class JSObject: Equatable {
     })
 
     deinit {
-        assertOnOwnerThread(hint: "deinitializing")
+        #if compiler(>=6.1) && _runtime(_multithreaded)
+        if ownerTid != swjs_get_worker_thread_id_cached() {
+            // If the object is not owned by the current thread
+            swjs_release_remote(ownerTid, id)
+            return
+        }
+        #endif
         swjs_release(id)
     }
 

Sources/JavaScriptKit/Runtime/index.js

@@ -290,6 +290,12 @@ IMPORT_JS_FUNCTION(swjs_load_typed_array, void, (const JavaScriptObjectRef ref,
 /// @param ref The target JavaScript object.
 IMPORT_JS_FUNCTION(swjs_release, void, (const JavaScriptObjectRef ref))
 
+/// Decrements reference count of `ref` retained by `SwiftRuntimeHeap` in `object_tid` thread.
+///
+/// @param object_tid The TID of the thread that owns the target object.
+/// @param ref The target JavaScript object.
+IMPORT_JS_FUNCTION(swjs_release_remote, void, (int object_tid, const JavaScriptObjectRef ref))
+
 /// Yields current program control by throwing `UnsafeEventLoopYield` JavaScript exception.
 /// See note on `UnsafeEventLoopYield` for more details
 ///

Sources/JavaScriptKit/Runtime/index.mjs

@@ -264,7 +264,7 @@ final class WebWorkerTaskExecutorTests: XCTestCase {
         executor.terminate()
     }
 
-    func testTransfer() async throws {
+    func testTransferMainToWorker() async throws {
         let Uint8Array = JSObject.global.Uint8Array.function!
         let buffer = Uint8Array.new(100).buffer.object!
         let transferring = JSTransferring(buffer)
@@ -275,8 +275,19 @@ final class WebWorkerTaskExecutorTests: XCTestCase {
         }
         let byteLength = try await task.value
         XCTAssertEqual(byteLength, 100)
-        // Deinit the transferring object on the thread that was created
-        withExtendedLifetime(transferring) {}
+    }
+
+    func testTransferWorkerToMain() async throws {
+        let executor = try await WebWorkerTaskExecutor(numberOfThreads: 1)
+        let task = Task(executorPreference: executor) {
+            let Uint8Array = JSObject.global.Uint8Array.function!
+            let buffer = Uint8Array.new(100).buffer.object!
+            let transferring = JSTransferring(buffer)
+            return transferring
+        }
+        let transferring = await task.value
+        let buffer = try await transferring.receive()
+        XCTAssertEqual(buffer.byteLength.number!, 100)
     }
 
     func testTransferNonTransferable() async throws {
@@ -296,8 +307,24 @@ final class WebWorkerTaskExecutorTests: XCTestCase {
             return
         }
         XCTAssertTrue(jsErrorMessage.contains("Failed to serialize response message"))
-        // Deinit the transferring object on the thread that was created
-        withExtendedLifetime(transferring) {}
+    }
+
+    func testTransferBetweenWorkers() async throws {
+        let executor1 = try await WebWorkerTaskExecutor(numberOfThreads: 1)
+        let executor2 = try await WebWorkerTaskExecutor(numberOfThreads: 1)
+        let task = Task(executorPreference: executor1) {
+            let Uint8Array = JSObject.global.Uint8Array.function!
+            let buffer = Uint8Array.new(100).buffer.object!
+            let transferring = JSTransferring(buffer)
+            return transferring
+        }
+        let transferring = await task.value
+        let task2 = Task(executorPreference: executor2) {
+            let buffer = try await transferring.receive()
+            return buffer.byteLength.number!
+        }
+        let byteLength = try await task2.value
+        XCTAssertEqual(byteLength, 100)
     }
 
 /*