Add a mechanism to "Transfer" JSObject between Workers

Examples/Multithreading/README.md

@@ -1,9 +1,21 @@
 # Multithreading example
 
-Install Development Snapshot toolchain `DEVELOPMENT-SNAPSHOT-2024-07-08-a` from [swift.org/install](https://www.swift.org/install/) and run the following commands:
+Install Development Snapshot toolchain `DEVELOPMENT-SNAPSHOT-2024-07-08-a` or later from [swift.org/install](https://www.swift.org/install/) and run the following commands:
 
 ```sh
-$ swift sdk install https://github.com/swiftwasm/swift/releases/download/swift-wasm-DEVELOPMENT-SNAPSHOT-2024-07-09-a/swift-wasm-DEVELOPMENT-SNAPSHOT-2024-07-09-a-wasm32-unknown-wasip1-threads.artifactbundle.zip
+$ (
+  set -eo pipefail; \
+  V="$(swiftc --version | head -n1)"; \
+  TAG="$(curl -sL "https://raw.githubusercontent.com/swiftwasm/swift-sdk-index/refs/heads/main/v1/tag-by-version.json" | jq -e -r --arg v "$V" '.[$v] | .[-1]')"; \
+  curl -sL "https://raw.githubusercontent.com/swiftwasm/swift-sdk-index/refs/heads/main/v1/builds/$TAG.json" | \
+  jq -r '.["swift-sdks"]["wasm32-unknown-wasip1-threads"] | "swift sdk install \"\(.url)\" --checksum \"\(.checksum)\""' | sh -x
+)
+$ export SWIFT_SDK_ID=$(
+  V="$(swiftc --version | head -n1)"; \
+  TAG="$(curl -sL "https://raw.githubusercontent.com/swiftwasm/swift-sdk-index/refs/heads/main/v1/tag-by-version.json" | jq -e -r --arg v "$V" '.[$v] | .[-1]')"; \
+  curl -sL "https://raw.githubusercontent.com/swiftwasm/swift-sdk-index/refs/heads/main/v1/builds/$TAG.json" | \
+  jq -r '.["swift-sdks"]["wasm32-unknown-wasip1-threads"]["id"]'
+)
 $ ./build.sh
 $ npx serve
 ```

Examples/Multithreading/Sources/JavaScript/index.js

@@ -27,9 +27,9 @@ class ThreadRegistry {
     };
   }
 
-  postMessageToWorkerThread(tid, data) {
+  postMessageToWorkerThread(tid, data, transfer) {
     const worker = this.workers.get(tid);
-    worker.postMessage(data);
+    worker.postMessage(data, transfer);
   }
 
   terminateWorkerThread(tid) {

Examples/Multithreading/Sources/JavaScript/worker.js

@@ -5,9 +5,9 @@ self.onmessage = async (event) => {
   const { instance, wasi, swiftRuntime } = await instantiate({
     module,
     threadChannel: {
-      postMessageToMainThread: (message) => {
+      postMessageToMainThread: (message, transfer) => {
         // Send the job to the main thread
-        postMessage(message);
+        postMessage(message, transfer);
       },
       listenMessageFromMainThread: (listener) => {
         self.onmessage = (event) => listener(event.data);

Examples/Multithreading/build.sh

@@ -1 +1 @@
-swift build --swift-sdk DEVELOPMENT-SNAPSHOT-2024-07-09-a-wasm32-unknown-wasip1-threads -Xswiftc -Xclang-linker -Xswiftc -mexec-model=reactor -Xlinker --export=__main_argc_argv -c release -Xswiftc -g
+swift build --swift-sdk "${SWIFT_SDK_ID:-wasm32-unknown-wasip1-threads}" -Xswiftc -Xclang-linker -Xswiftc -mexec-model=reactor -Xlinker --export=__main_argc_argv -c release -Xswiftc -g

Examples/OffscrenCanvas/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+/.build
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

Examples/OffscrenCanvas/Package.swift

@@ -0,0 +1,20 @@
+// swift-tools-version: 5.10
+
+import PackageDescription
+
+let package = Package(
+    name: "Example",
+    platforms: [.macOS("15"), .iOS("18"), .watchOS("11"), .tvOS("18"), .visionOS("2")],
+    dependencies: [
+        .package(path: "../../"),
+    ],
+    targets: [
+        .executableTarget(
+            name: "MyApp",
+            dependencies: [
+                .product(name: "JavaScriptKit", package: "JavaScriptKit"),
+                .product(name: "JavaScriptEventLoop", package: "JavaScriptKit"),
+            ]
+        ),
+    ]
+)

Examples/OffscrenCanvas/README.md

@@ -0,0 +1,21 @@
+# OffscreenCanvas example
+
+Install Development Snapshot toolchain `DEVELOPMENT-SNAPSHOT-2024-07-08-a` or later from [swift.org/install](https://www.swift.org/install/) and run the following commands:
+
+```sh
+$ (
+  set -eo pipefail; \
+  V="$(swiftc --version | head -n1)"; \
+  TAG="$(curl -sL "https://raw.githubusercontent.com/swiftwasm/swift-sdk-index/refs/heads/main/v1/tag-by-version.json" | jq -e -r --arg v "$V" '.[$v] | .[-1]')"; \
+  curl -sL "https://raw.githubusercontent.com/swiftwasm/swift-sdk-index/refs/heads/main/v1/builds/$TAG.json" | \
+  jq -r '.["swift-sdks"]["wasm32-unknown-wasip1-threads"] | "swift sdk install \"\(.url)\" --checksum \"\(.checksum)\""' | sh -x
+)
+$ export SWIFT_SDK_ID=$(
+  V="$(swiftc --version | head -n1)"; \
+  TAG="$(curl -sL "https://raw.githubusercontent.com/swiftwasm/swift-sdk-index/refs/heads/main/v1/tag-by-version.json" | jq -e -r --arg v "$V" '.[$v] | .[-1]')"; \
+  curl -sL "https://raw.githubusercontent.com/swiftwasm/swift-sdk-index/refs/heads/main/v1/builds/$TAG.json" | \
+  jq -r '.["swift-sdks"]["wasm32-unknown-wasip1-threads"]["id"]'
+)
+$ ./build.sh
+$ npx serve
+```

Examples/OffscrenCanvas/Sources/JavaScript

@@ -0,0 +1 @@
+../../Multithreading/Sources/JavaScript

Examples/OffscrenCanvas/Sources/MyApp/main.swift

@@ -0,0 +1,139 @@
+import JavaScriptEventLoop
+import JavaScriptKit
+
+JavaScriptEventLoop.installGlobalExecutor()
+WebWorkerTaskExecutor.installGlobalExecutor()
+
+protocol CanvasRenderer {
+    func render(canvas: JSObject, size: Int) async throws
+}
+
+struct BackgroundRenderer: CanvasRenderer {
+    func render(canvas: JSObject, size: Int) async throws {
+        let executor = try await WebWorkerTaskExecutor(numberOfThreads: 1)
+        let transfer = JSSending.transfer(canvas)
+        let renderingTask = Task(executorPreference: executor) {
+            let canvas = try await transfer.receive()
+            try await renderAnimation(canvas: canvas, size: size)
+        }
+        await withTaskCancellationHandler {
+            try? await renderingTask.value
+        } onCancel: {
+            renderingTask.cancel()
+        }
+        executor.terminate()
+    }
+}
+
+struct MainThreadRenderer: CanvasRenderer {
+    func render(canvas: JSObject, size: Int) async throws {
+        try await renderAnimation(canvas: canvas, size: size)
+    }
+}
+
+// FPS Counter for CSS animation
+func startFPSMonitor() {
+    let fpsCounterElement = JSObject.global.document.getElementById("fps-counter").object!
+
+    var lastTime = JSObject.global.performance.now().number!
+    var frames = 0
+
+    // Create a frame counter function
+    func countFrame() {
+        frames += 1
+        let currentTime = JSObject.global.performance.now().number!
+        let elapsed = currentTime - lastTime
+
+        if elapsed >= 1000 {
+            let fps = Int(Double(frames) * 1000 / elapsed)
+            fpsCounterElement.textContent = .string("FPS: \(fps)")
+            frames = 0
+            lastTime = currentTime
+        }
+
+        // Request next frame
+        _ = JSObject.global.requestAnimationFrame!(
+            JSClosure { _ in
+                countFrame()
+                return .undefined
+            })
+    }
+
+    // Start counting
+    countFrame()
+}
+
+@MainActor
+func onClick(renderer: CanvasRenderer) async throws {
+    let document = JSObject.global.document
+
+    let canvasContainerElement = document.getElementById("canvas-container").object!
+
+    // Remove all child elements from the canvas container
+    for i in 0..<Int(canvasContainerElement.children.length.number!) {
+        let child = canvasContainerElement.children[i]
+        _ = canvasContainerElement.removeChild!(child)
+    }
+
+    let canvasElement = document.createElement("canvas").object!
+    _ = canvasContainerElement.appendChild!(canvasElement)
+
+    let size = 800
+    canvasElement.width = .number(Double(size))
+    canvasElement.height = .number(Double(size))
+
+    let offscreenCanvas = canvasElement.transferControlToOffscreen!().object!
+    try await renderer.render(canvas: offscreenCanvas, size: size)
+}
+
+func main() async throws {
+    let renderButtonElement = JSObject.global.document.getElementById("render-button").object!
+    let cancelButtonElement = JSObject.global.document.getElementById("cancel-button").object!
+    let rendererSelectElement = JSObject.global.document.getElementById("renderer-select").object!
+
+    var renderingTask: Task<Void, Error>? = nil
+
+    // Start the FPS monitor for CSS animations
+    startFPSMonitor()
+
+    _ = renderButtonElement.addEventListener!(
+        "click",
+        JSClosure { _ in
+            renderingTask?.cancel()
+            renderingTask = Task {
+                let selectedValue = rendererSelectElement.value.string!
+                let renderer: CanvasRenderer =
+                    selectedValue == "main" ? MainThreadRenderer() : BackgroundRenderer()
+                try await onClick(renderer: renderer)
+            }
+            return JSValue.undefined
+        })
+
+    _ = cancelButtonElement.addEventListener!(
+        "click",
+        JSClosure { _ in
+            renderingTask?.cancel()
+            return JSValue.undefined
+        })
+}
+
+Task {
+    try await main()
+}
+
+#if canImport(wasi_pthread)
+    import wasi_pthread
+    import WASILibc
+
+    /// Trick to avoid blocking the main thread. pthread_mutex_lock function is used by
+    /// the Swift concurrency runtime.
+    @_cdecl("pthread_mutex_lock")
+    func pthread_mutex_lock(_ mutex: UnsafeMutablePointer<pthread_mutex_t>) -> Int32 {
+        // DO NOT BLOCK MAIN THREAD
+        var ret: Int32
+        repeat {
+            ret = pthread_mutex_trylock(mutex)
+        } while ret == EBUSY
+        return ret
+    }
+#endif