Add multi-threading example

Author: kateinoigakukun

Examples/Multithreading/.gitignore

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

Examples/Multithreading/Package.resolved

@@ -0,0 +1,14 @@
+{
+  "originHash" : "e66f4c272838a860049b7e3528f1db03ee6ae99c2b21c3b6ea58a293be4db41b",
+  "pins" : [
+    {
+      "identity" : "chibi-ray",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/kateinoigakukun/chibi-ray",
+      "state" : {
+        "revision" : "c8cab621a3338dd2f8e817d3785362409d3b8cf1"
+      }
+    }
+  ],
+  "version" : 3
+}

Examples/Multithreading/Package.swift

@@ -0,0 +1,21 @@
+// swift-tools-version: 6.0
+
+import PackageDescription
+
+let package = Package(
+    name: "Example",
+    dependencies: [
+        .package(path: "../../"),
+        .package(url: "https://github.com/kateinoigakukun/chibi-ray", revision: "c8cab621a3338dd2f8e817d3785362409d3b8cf1"),
+    ],
+    targets: [
+        .executableTarget(
+            name: "MyApp",
+            dependencies: [
+                .product(name: "JavaScriptKit", package: "JavaScriptKit"),
+                .product(name: "JavaScriptEventLoop", package: "JavaScriptKit"),
+                .product(name: "ChibiRay", package: "chibi-ray"),
+            ]
+        ),
+    ]
+)

Examples/Multithreading/README.md

@@ -0,0 +1,9 @@
+# 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:
+
+```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
+$ ./build.sh
+$ npx serve
+```

Examples/Multithreading/Sources/JavaScript/index.js

@@ -0,0 +1,74 @@
+import { instantiate } from "./instantiate.js"
+import * as WasmImportsParser from 'https://esm.run/wasm-imports-parser/polyfill.js';
+
+// TODO: Remove this polyfill once the browser supports the WebAssembly Type Reflection JS API
+// https://chromestatus.com/feature/5725002447978496
+globalThis.WebAssembly = WasmImportsParser.polyfill(globalThis.WebAssembly);
+
+class ThreadRegistry {
+  workers = new Map();
+  nextTid = 1;
+
+  constructor({ configuration }) {
+    this.configuration = configuration;
+  }
+
+  spawnThread(worker, module, memory, startArg) {
+    const tid = this.nextTid++;
+    this.workers.set(tid, worker);
+    worker.postMessage({ module, memory, tid, startArg, configuration: this.configuration });
+    return tid;
+  }
+
+  listenMessageFromWorkerThread(tid, listener) {
+    const worker = this.workers.get(tid);
+    worker.onmessage = (event) => {
+      listener(event.data);
+    };
+  }
+
+  postMessageToWorkerThread(tid, data) {
+    const worker = this.workers.get(tid);
+    worker.postMessage(data);
+  }
+
+  terminateWorkerThread(tid) {
+    const worker = this.workers.get(tid);
+    worker.terminate();
+    this.workers.delete(tid);
+  }
+}
+
+async function start(configuration = "release") {
+  const response = await fetch(`./.build/${configuration}/MyApp.wasm`);
+  const module = await WebAssembly.compileStreaming(response);
+  const memoryImport = WebAssembly.Module.imports(module).find(i => i.module === "env" && i.name === "memory");
+  if (!memoryImport) {
+    throw new Error("Memory import not found");
+  }
+  if (!memoryImport.type) {
+    throw new Error("Memory import type not found");
+  }
+  const memoryType = memoryImport.type;
+  const memory = new WebAssembly.Memory({ initial: memoryType.minimum, maximum: memoryType.maximum, shared: true });
+  const threads = new ThreadRegistry({ configuration });
+  const { instance, swiftRuntime, wasi } = await instantiate({
+    module,
+    threadChannel: threads,
+    addToImports(importObject) {
+      importObject["env"] = { memory }
+      importObject["wasi"] = {
+        "thread-spawn": (startArg) => {
+          const worker = new Worker("Sources/JavaScript/worker.js", { type: "module" });
+          return threads.spawnThread(worker, module, memory, startArg);
+        }
+      };
+    },
+    configuration
+  });
+  wasi.initialize(instance);
+
+  swiftRuntime.main();
+}
+
+start();

Examples/Multithreading/Sources/JavaScript/instantiate.js

@@ -0,0 +1,29 @@
+import { WASI, File, OpenFile, ConsoleStdout, PreopenDirectory } from 'https://esm.run/@bjorn3/browser_wasi_shim@0.3.0';
+
+export async function instantiate({ module, addToImports, threadChannel, configuration }) {
+  const args = ["main.wasm"]
+  const env = []
+  const fds = [
+    new OpenFile(new File([])), // stdin
+    ConsoleStdout.lineBuffered((stdout) => {
+      console.log(stdout);
+    }),
+    ConsoleStdout.lineBuffered((stderr) => {
+      console.error(stderr);
+    }),
+    new PreopenDirectory("/", new Map()),
+  ];
+  const wasi = new WASI(args, env, fds);
+
+  const { SwiftRuntime } = await import(`/.build/${configuration}/JavaScriptKit_JavaScriptKit.resources/Runtime/index.mjs`);
+  const swiftRuntime = new SwiftRuntime({ sharedMemory: true, threadChannel });
+  const importObject = {
+    wasi_snapshot_preview1: wasi.wasiImport,
+    javascript_kit: swiftRuntime.wasmImports,
+  };
+  addToImports(importObject);
+  const instance = await WebAssembly.instantiate(module, importObject);
+
+  swiftRuntime.setInstance(instance);
+  return { swiftRuntime, wasi, instance };
+}

Examples/Multithreading/Sources/JavaScript/worker.js

@@ -0,0 +1,28 @@
+import { instantiate } from "./instantiate.js"
+
+self.onmessage = async (event) => {
+  const { module, memory, tid, startArg, configuration } = event.data;
+  const { instance, wasi, swiftRuntime } = await instantiate({
+    module,
+    threadChannel: {
+      postMessageToMainThread: (message) => {
+        // Send the job to the main thread
+        postMessage(message);
+      },
+      listenMessageFromMainThread: (listener) => {
+        self.onmessage = (event) => listener(event.data);
+      }
+    },
+    addToImports(importObject) {
+      importObject["env"] = { memory }
+      importObject["wasi"] = {
+        "thread-spawn": () => { throw new Error("Cannot spawn a new thread from a worker thread"); }
+      };
+    },
+    configuration
+  });
+
+  swiftRuntime.setInstance(instance);
+  wasi.inst = instance;
+  swiftRuntime.startThread(tid, startArg);
+}

Examples/Multithreading/Sources/MyApp/Scene.swift

@@ -0,0 +1,93 @@
+import ChibiRay
+
+func createDemoScene() -> Scene {
+    return Scene(
+        width: 800,
+        height: 800,
+        fov: 90,
+        elements: [
+            .sphere(
+                Sphere(
+                    center: Point(x: 1.0, y: -1.0, z: -7.0),
+                    radius: 1.0,
+                    material: Material(
+                        color: Color(red: 0.8, green: 0.2, blue: 0.4),
+                        albedo: 0.6,
+                        surface: .reflective(reflectivity: 0.9)
+                    )
+                )
+            ),
+            .sphere(
+                Sphere(
+                    center: Point(x: -2.0, y: 1.0, z: -10.0),
+                    radius: 3.0,
+                    material: Material(
+                        color: Color(red: 1.0, green: 0.4, blue: 0.4),
+                        albedo: 0.7,
+                        surface: .diffuse
+                    )
+                )
+            ),
+            .sphere(
+                Sphere(
+                    center: Point(x: 3.0, y: 2.0, z: -5.0),
+                    radius: 2.0,
+                    material: Material(
+                        color: Color(red: 0.4, green: 0.4, blue: 0.8),
+                        albedo: 0.5,
+                        surface: .refractive(index: 2, transparency: 0.9)
+                    )
+                )
+            ),
+            .plane(
+                Plane(
+                    origin: Point(x: 0.0, y: -2.0, z: -5.0),
+                    normal: Vector3(x: 0.0, y: -1.0, z: 0.0),
+                    material: Material(
+                        color: Color(red: 1.0, green: 1.0, blue: 1.0),
+                        albedo: 0.18,
+                        surface: .reflective(reflectivity: 0.5)
+                    )
+                )
+            ),
+            .plane(
+                Plane(
+                    origin: Point(x: 0.0, y: 0.0, z: -20.0),
+                    normal: Vector3(x: 0.0, y: 0.0, z: -1.0),
+                    material: Material(
+                        color: Color(red: 0.2, green: 0.3, blue: 1.0),
+                        albedo: 0.38,
+                        surface: .diffuse
+                    )
+                )
+            )
+        ],
+        lights: [
+            .spherical(
+                SphericalLight(
+                    position: Point(x: 5.0, y: 10.0, z: -3.0),
+                    color: Color(red: 1.0, green: 1.0, blue: 1.0),
+                    intensity: 16000
+                )
+            ),
+            .spherical(
+                SphericalLight(
+                    position: Point(x: -3.0, y: 3.0, z: -5.0),
+                    color: Color(red: 0.3, green: 0.3, blue: 1.0),
+                    intensity: 1000
+                )
+            ),
+            .directional(
+                DirectionalLight(
+                    direction: Vector3(x: 0.0, y: -1.0, z: -1.0),
+                    color: Color(red: 0.8, green: 0.8, blue: 0.8),
+                    intensity: 0.2
+                )
+            )
+        ],
+        shadowBias: 1e-13,
+        maxRecursionDepth: 10
+    )
+}
+
+extension Scene: @retroactive @unchecked Sendable {}