react-native-webgpu 0.6.1 → 0.6.2

package/README.md

@@ -8,20 +8,6 @@ WebGPU for React Native, powered by Dawn.
 
 [Installation instructions](https://wcandillon.github.io/react-native-webgpu/docs/getting-started/installation)
 
-## Expo config plugin
-
-The package ships with an Expo config plugin that disables Metal API validation in the iOS Xcode scheme, which is required to run WebGPU on the iOS Simulator (Metal API validation reports false positives for Dawn that do not occur on device). Because the plugin is part of the package, plugin and package versions are always aligned.
-
-```json
-{
-  "expo": {
-    "plugins": ["react-native-webgpu"]
-  }
-}
-```
-
-See the [Expo guide](https://wcandillon.github.io/react-native-webgpu/docs/getting-started/expo#config-plugin) for details.
-
 ## Contributing
 
-For detailed information on library development, building, testing, and contributing guidelines, please see [CONTRIBUTING.md](packages/webgpu/CONTRIBUTING.md).
+For detailed information on library development, building, testing, and contributing guidelines, please see [CONTRIBUTING.md](packages/webgpu/CONTRIBUTING.md).

package/cpp/jsi/NativeObject.h

@@ -9,6 +9,7 @@
 #include <memory>
 #include <mutex>
 #include <optional>
+#include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
@@ -48,6 +49,12 @@ public:
 
   void registerInstaller(const std::string &brand, InstallerFunc installer) {
     std::lock_guard<std::mutex> lock(_mutex);
+    if (_installers.count(brand) != 0) {
+      // The brand is the key unbox() uses to rebuild objects on worklet
+      // runtimes - a duplicate would let one class hijack another's unboxing.
+      throw std::runtime_error("Duplicate native object brand registered: " +
+                               brand);
+    }
     _installers[brand] = std::move(installer);
   }
 
@@ -235,6 +242,10 @@ public:
    * Each NativeObject<Derived> type has its own static cache.
    * Uses StaticRuntimeAwareCache to properly handle runtime lifecycle
    * and hot reload (where the main runtime is destroyed and recreated).
+   *
+   * Callers must hold getPrototypeCacheMutex(): the cache is reached
+   * concurrently from the main JS thread (create()) and from worklet
+   * runtime threads (BoxedWebGPUObject::unbox() -> installPrototype()).
    */
   static RuntimeAwareCache<PrototypeCacheEntry> &
   getPrototypeCache(jsi::Runtime &runtime) {
@@ -242,11 +253,22 @@ public:
     return cache.get(runtime);
   }
 
+  /**
+   * Per-class mutex guarding getPrototypeCache() and prototype
+   * installation. Serializes the StaticRuntimeAwareCache pointer swap
+   * (hot reload) and the per-runtime cache lookups.
+   */
+  static std::mutex &getPrototypeCacheMutex() {
+    static std::mutex mutex;
+    return mutex;
+  }
+
   /**
    * Ensure the prototype is installed for this runtime.
    * Called automatically by create(), but can be called manually.
    */
   static void installPrototype(jsi::Runtime &runtime) {
+    std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
     auto &entry = getPrototypeCache(runtime).get(runtime);
     if (entry.prototype.has_value()) {
       return; // Already installed
@@ -278,6 +300,49 @@ public:
       defineProperty.call(runtime, prototype, toStringTag, descriptor);
     }
 
+    // Install a generic toJSON so JSON.stringify works: data properties live
+    // as getters on this shared prototype, and JSON.stringify only serializes
+    // own enumerable properties (so it would otherwise produce {}).
+    auto toJSON = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "toJSON"), 0,
+        [](jsi::Runtime &rt, const jsi::Value &thisVal,
+           const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
+          auto thisObj = thisVal.getObject(rt);
+          auto objectCtor = rt.global().getPropertyAsObject(rt, "Object");
+          auto getPrototypeOf =
+              objectCtor.getPropertyAsFunction(rt, "getPrototypeOf");
+          auto proto = getPrototypeOf.call(rt, thisObj);
+          jsi::Object result(rt);
+          if (!proto.isObject()) {
+            return std::move(result);
+          }
+          auto getOwnPropertyNames =
+              objectCtor.getPropertyAsFunction(rt, "getOwnPropertyNames");
+          auto names =
+              getOwnPropertyNames.call(rt, proto).getObject(rt).getArray(rt);
+          size_t length = names.size(rt);
+          for (size_t i = 0; i < length; i++) {
+            auto nameValue = names.getValueAtIndex(rt, i);
+            if (!nameValue.isString()) {
+              continue;
+            }
+            auto name = nameValue.getString(rt).utf8(rt);
+            if (name == "constructor" || name == "toJSON") {
+              continue;
+            }
+            // Read off `this` so prototype getters evaluate against the
+            // object's native state. Getters that throw keep throwing.
+            auto value = thisObj.getProperty(rt, name.c_str());
+            if (value.isObject() && value.getObject(rt).isFunction(rt)) {
+              // Skip methods - JSON.stringify would drop them anyway
+              continue;
+            }
+            result.setProperty(rt, name.c_str(), value);
+          }
+          return std::move(result);
+        });
+    prototype.setProperty(runtime, "toJSON", toJSON);
+
     // Cache the prototype
     entry.prototype = std::move(prototype);
   }
@@ -303,6 +368,7 @@ public:
 
     installPrototype(runtime);
 
+    std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
     auto &entry = getPrototypeCache(runtime).get(runtime);
     if (!entry.prototype.has_value()) {
       return;
@@ -346,14 +412,17 @@ public:
     obj.setNativeState(runtime, instance);
 
     // Set prototype
-    auto &entry = getPrototypeCache(runtime).get(runtime);
-    if (entry.prototype.has_value()) {
-      // Use Object.setPrototypeOf to set the prototype
-      auto objectCtor =
-          runtime.global().getPropertyAsObject(runtime, "Object");
-      auto setPrototypeOf =
-          objectCtor.getPropertyAsFunction(runtime, "setPrototypeOf");
-      setPrototypeOf.call(runtime, obj, *entry.prototype);
+    {
+      std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
+      auto &entry = getPrototypeCache(runtime).get(runtime);
+      if (entry.prototype.has_value()) {
+        // Use Object.setPrototypeOf to set the prototype
+        auto objectCtor =
+            runtime.global().getPropertyAsObject(runtime, "Object");
+        auto setPrototypeOf =
+            objectCtor.getPropertyAsFunction(runtime, "setPrototypeOf");
+        setPrototypeOf.call(runtime, obj, *entry.prototype);
+      }
     }
 
     // Set memory pressure hint for GC

package/cpp/jsi/RuntimeAwareCache.cpp

@@ -2,6 +2,6 @@
 
 namespace rnwgpu {
 
-jsi::Runtime *BaseRuntimeAwareCache::_mainRuntime = nullptr;
+std::atomic<jsi::Runtime *> BaseRuntimeAwareCache::_mainRuntime{nullptr};
 
 } // namespace rnwgpu

package/cpp/jsi/RuntimeAwareCache.h

@@ -2,8 +2,10 @@
 
 #include <jsi/jsi.h>
 
+#include <atomic>
 #include <cassert>
 #include <memory>
+#include <mutex>
 #include <unordered_map>
 #include <utility>
 
@@ -15,17 +17,22 @@ namespace jsi = facebook::jsi;
 
 class BaseRuntimeAwareCache {
 public:
-  static void setMainJsRuntime(jsi::Runtime *rt) { _mainRuntime = rt; }
+  static void setMainJsRuntime(jsi::Runtime *rt) {
+    // Atomic: hot reload rewrites this from the JS thread while worklet
+    // runtime threads read it concurrently.
+    _mainRuntime.store(rt, std::memory_order_release);
+  }
   static jsi::Runtime *getMainJsRuntime() {
-    assert(_mainRuntime != nullptr &&
+    auto *rt = _mainRuntime.load(std::memory_order_acquire);
+    assert(rt != nullptr &&
            "Expected main Javascript runtime to be set in the "
            "BaseRuntimeAwareCache class.");
 
-    return _mainRuntime;
+    return rt;
   }
 
 private:
-  static jsi::Runtime *_mainRuntime;
+  static std::atomic<jsi::Runtime *> _mainRuntime;
 };
 
 /**
@@ -56,7 +63,10 @@ class RuntimeAwareCache : public BaseRuntimeAwareCache,
 public:
   void onRuntimeDestroyed(jsi::Runtime *rt) override {
     if (getMainJsRuntime() != rt) {
-      // We are removing a secondary runtime
+      // We are removing a secondary runtime. This is invoked by
+      // RuntimeLifecycleMonitor on the destroyed runtime's thread, which may
+      // run concurrently with get() on another runtime's thread.
+      std::lock_guard<std::mutex> lock(_secondaryCachesMutex);
       _secondaryRuntimeCaches.erase(rt);
     }
   }
@@ -75,6 +85,14 @@ public:
     if (getMainJsRuntime() == &rt) {
       return _primaryCache;
     } else {
+      // Guard the secondary map: it can be mutated concurrently by get()
+      // on a worklet runtime's thread and by onRuntimeDestroyed() when
+      // another secondary runtime is torn down. The main-runtime path above
+      // stays lock-free. References into the map remain valid after the
+      // lock is released (unordered_map never invalidates references on
+      // insert/erase of other keys, and this runtime's entry can only be
+      // erased from this runtime's own thread).
+      std::lock_guard<std::mutex> lock(_secondaryCachesMutex);
       if (_secondaryRuntimeCaches.count(&rt) == 0) {
         // we only add listener when the secondary runtime is used, this assumes
         // that the secondary runtime is terminated first. This lets us avoid
@@ -88,11 +106,12 @@ public:
         T cache;
         _secondaryRuntimeCaches.emplace(&rt, std::move(cache));
       }
+      return _secondaryRuntimeCaches.at(&rt);
     }
-    return _secondaryRuntimeCaches.at(&rt);
   }
 
 private:
+  std::mutex _secondaryCachesMutex;
   std::unordered_map<void *, T> _secondaryRuntimeCaches;
   T _primaryCache;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-webgpu",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "React Native WebGPU",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",