react-native-webgpu 0.8.1 → 0.8.3

package/apple/WebGPUView.mm

@@ -10,12 +10,29 @@
 
 using namespace facebook::react;
 
+static const std::shared_ptr<const WebGPUViewProps> &defaultWebGPUViewProps() {
+  static const auto props = std::make_shared<const WebGPUViewProps>();
+  return props;
+}
+
 @implementation WebGPUView
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
   return concreteComponentDescriptorProvider<WebGPUViewComponentDescriptor>();
 }
 
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    /*
+      The base class initializes _props with a plain ViewProps instance;
+      updateProps: casts _props to WebGPUViewProps, so it must hold our
+      concrete props type from the start (RN 0.87+ asserts on this).
+    */
+    _props = defaultWebGPUViewProps();
+  }
+  return self;
+}
+
 - (void)prepareForRecycle {
   [super prepareForRecycle];
   /*
@@ -24,6 +41,11 @@ using namespace facebook::react;
     the last usage in the new context.
   */
   self.contentView = nil;
+  /*
+    Reset to the default props (contextId == 0) so the next mount always
+    detects a contextId change and configures a fresh Metal layer.
+  */
+  _props = defaultWebGPUViewProps();
 }
 
 - (MetalView *)getContentView {

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -19,9 +19,35 @@
 
 namespace rnwgpu {
 
+namespace {
+
+// Hidden own properties used by device.lost. The promise cache lives on the
+// device wrapper (the spec requires `lost` to return a stable promise) and
+// the resolve function lives on the promise object itself, so both are traced
+// by the GC as part of the device's JS object graph instead of being rooted
+// from C++ (issue #445).
+constexpr const char *kLostPromiseProp = "__rnwgpuLostPromise";
+constexpr const char *kLostResolveProp = "__rnwgpuLostResolve";
+
+void defineHiddenProperty(jsi::Runtime &runtime, const jsi::Object &target,
+                          const char *name, const jsi::Value &value) {
+  auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
+  auto defineProperty =
+      objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+  jsi::Object descriptor(runtime);
+  descriptor.setProperty(runtime, "value", value);
+  descriptor.setProperty(runtime, "enumerable", false);
+  descriptor.setProperty(runtime, "writable", false);
+  descriptor.setProperty(runtime, "configurable", false);
+  defineProperty.call(runtime, target,
+                      jsi::String::createFromUtf8(runtime, name), descriptor);
+}
+
+} // namespace
+
 void GPUDevice::notifyDeviceLost(wgpu::DeviceLostReason reason,
                                  std::string message) {
-  std::optional<async::AsyncTaskHandle::ResolveFunction> resolveToCall;
+  std::vector<PendingLostPromise> toResolve;
   std::shared_ptr<GPUDeviceLostInfo> info;
   {
     std::lock_guard<std::mutex> lock(_lostMutex);
@@ -32,22 +58,49 @@ void GPUDevice::notifyDeviceLost(wgpu::DeviceLostReason reason,
     _lostSettled = true;
     _lostInfo = std::make_shared<GPUDeviceLostInfo>(reason, std::move(message));
     info = _lostInfo;
+    toResolve = std::move(_lostPromises);
+    _lostPromises.clear();
+  }
 
-    if (_lostResolve.has_value()) {
-      resolveToCall = std::move(*_lostResolve);
-      _lostResolve.reset();
-    }
-
-    _lostHandle.reset();
+  if (toResolve.empty()) {
+    return;
   }
 
-  // Settle outside the lock: resolve() only enqueues onto the JS thread.
-  if (resolveToCall.has_value()) {
-    (*resolveToCall)([info](jsi::Runtime &runtime) mutable {
-      return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(runtime,
-                                                                     info);
-    });
+  // getLost() only registers promises when the device's context has a
+  // CallInvoker (main JS runtime), so a non-empty list implies an invoker.
+  auto invoker = _async ? _async->callInvoker() : nullptr;
+  if (!invoker) {
+    return;
   }
+
+  // Settle on the owning runtime's JS thread. The promises are held weakly:
+  // if the device graph was collected in the meantime there is nothing to do,
+  // since nobody could observe the resolution anyway. The shared_ptr is only
+  // there because jsi::WeakObject is move-only and std::function requires a
+  // copyable closure; it also ensures the WeakObjects are destroyed on the JS
+  // thread.
+  auto pending =
+      std::make_shared<std::vector<PendingLostPromise>>(std::move(toResolve));
+  invoker->invokeAsync([pending, info]() {
+    for (auto &entry : *pending) {
+      auto &runtime = *entry.runtime;
+      auto locked = entry.promise.lock(runtime);
+      if (!locked.isObject()) {
+        continue;
+      }
+      auto promiseObj = locked.getObject(runtime);
+      auto resolveProp = promiseObj.getProperty(runtime, kLostResolveProp);
+      if (!resolveProp.isObject() ||
+          !resolveProp.getObject(runtime).isFunction(runtime)) {
+        continue;
+      }
+      auto resolveFn = resolveProp.getObject(runtime).getFunction(runtime);
+      resolveFn.call(runtime,
+                     JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
+                         runtime, info));
+    }
+    pending->clear();
+  });
 }
 
 void GPUDevice::forceLossForTesting() {
@@ -523,47 +576,84 @@ std::unordered_set<std::string> GPUDevice::getFeatures() {
   return result;
 }
 
-async::AsyncTaskHandle GPUDevice::getLost() {
-  // Held across the whole body: the postTask callback below runs synchronously
-  // on this (JS) thread and touches the same _lost* fields, so it must not
-  // re-lock. notifyDeviceLost() takes the same lock from its (possibly worker)
-  // thread.
-  std::lock_guard<std::mutex> lock(_lostMutex);
-  if (_lostHandle.has_value()) {
-    return *_lostHandle;
-  }
-
-  if (_lostSettled && _lostInfo) {
-    return _async->postTask(
-        [info = _lostInfo](
-            const async::AsyncTaskHandle::ResolveFunction &resolve,
-            const async::AsyncTaskHandle::RejectFunction & /*reject*/) {
-          resolve([info](jsi::Runtime &runtime) mutable {
-            return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
-                runtime, info);
-          });
-        },
-        /*keepPumping=*/false);
-  }
-
-  auto handle = _async->postTask(
-      [this](const async::AsyncTaskHandle::ResolveFunction &resolve,
-             const async::AsyncTaskHandle::RejectFunction & /*reject*/) {
-        if (_lostSettled && _lostInfo) {
-          resolve([info = _lostInfo](jsi::Runtime &runtime) mutable {
-            return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
-                runtime, info);
-          });
-          return;
-        }
-
-        // Resolved later from notifyDeviceLost().
-        _lostResolve = resolve;
-      },
-      /*keepPumping=*/false);
-
-  _lostHandle = handle;
-  return handle;
+jsi::Value GPUDevice::getLost(jsi::Runtime &runtime,
+                              const jsi::Object &wrapper) {
+  // The promise is cached on the wrapper, not natively: a strong native
+  // reference would be a GC root, keeping the promise's .then reactions (and
+  // anything they capture, e.g. a whole three.js renderer) alive forever
+  // (issue #445).
+  auto cached = wrapper.getProperty(runtime, kLostPromiseProp);
+  if (cached.isObject()) {
+    return cached;
+  }
+
+  auto promiseCtor = runtime.global().getPropertyAsObject(runtime, "Promise");
+
+  std::shared_ptr<GPUDeviceLostInfo> settledInfo;
+  {
+    std::lock_guard<std::mutex> lock(_lostMutex);
+    if (_lostSettled) {
+      settledInfo = _lostInfo;
+    }
+  }
+
+  jsi::Value promiseValue;
+  if (settledInfo) {
+    auto info = JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
+        runtime, settledInfo);
+    promiseValue = promiseCtor.getPropertyAsFunction(runtime, "resolve")
+                       .callWithThis(runtime, promiseCtor, info);
+  } else {
+    // new Promise(executor): the executor runs synchronously inside the
+    // constructor call, capturing the resolve function.
+    auto capturedResolve = std::make_shared<jsi::Value>();
+    auto executor = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "lostExecutor"), 2,
+        [capturedResolve](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
+                          const jsi::Value *args, size_t count) -> jsi::Value {
+          if (count > 0) {
+            *capturedResolve = jsi::Value(rt, args[0]);
+          }
+          return jsi::Value::undefined();
+        });
+    auto promiseObj = promiseCtor.asFunction(runtime)
+                          .callAsConstructor(runtime, executor)
+                          .getObject(runtime);
+
+    // Stash the resolve function on the promise itself so the GC traces it as
+    // part of the promise graph.
+    defineHiddenProperty(runtime, promiseObj, kLostResolveProp,
+                         *capturedResolve);
+
+    // Register a WEAK reference so notifyDeviceLost() can settle the promise
+    // if it is still alive. Only wired for the device's own runtime when a
+    // CallInvoker exists (main JS runtime): spontaneous events are delivered
+    // through that invoker. A promise created on another runtime stays
+    // pending, matching the previous best-effort behavior.
+    bool settledMeanwhile = false;
+    if (_async && _async->callInvoker() && &runtime == &_async->runtime()) {
+      std::lock_guard<std::mutex> lock(_lostMutex);
+      if (_lostSettled) {
+        // The device was lost between the check above and now.
+        settledMeanwhile = true;
+        settledInfo = _lostInfo;
+      } else {
+        _lostPromises.push_back(
+            PendingLostPromise{&runtime, jsi::WeakObject(runtime, promiseObj)});
+      }
+    }
+    if (settledMeanwhile) {
+      auto resolveFn =
+          promiseObj.getPropertyAsFunction(runtime, kLostResolveProp);
+      resolveFn.call(runtime,
+                     JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
+                         runtime, settledInfo));
+    }
+    promiseValue = jsi::Value(runtime, promiseObj);
+  }
+
+  defineHiddenProperty(runtime, wrapper, kLostPromiseProp, promiseValue);
+  return promiseValue;
 }
 void GPUDevice::addEventListener(std::string type, jsi::Function callback) {
   auto funcPtr = std::make_shared<jsi::Function>(std::move(callback));

package/cpp/rnwgpu/api/GPUDevice.h

@@ -45,11 +45,11 @@
 #include "GPURenderPipelineDescriptor.h"
 #include "GPUSampler.h"
 #include "GPUSamplerDescriptor.h"
+#include "GPUShaderModule.h"
+#include "GPUShaderModuleDescriptor.h"
 #include "GPUSharedFenceDescriptor.h"
 #include "GPUSharedTextureMemory.h"
 #include "GPUSharedTextureMemoryDescriptor.h"
-#include "GPUShaderModule.h"
-#include "GPUShaderModuleDescriptor.h"
 #include "GPUSupportedLimits.h"
 #include "GPUTexture.h"
 #include "GPUTextureDescriptor.h"
@@ -121,8 +121,8 @@ public:
       std::shared_ptr<GPUExternalTextureDescriptor> descriptor);
   std::shared_ptr<GPUSharedTextureMemory> importSharedTextureMemory(
       std::shared_ptr<GPUSharedTextureMemoryDescriptor> descriptor);
-  std::shared_ptr<GPUSharedFence> importSharedFence(
-      std::shared_ptr<GPUSharedFenceDescriptor> descriptor);
+  std::shared_ptr<GPUSharedFence>
+  importSharedFence(std::shared_ptr<GPUSharedFenceDescriptor> descriptor);
   std::shared_ptr<GPUBindGroupLayout> createBindGroupLayout(
       std::shared_ptr<GPUBindGroupLayoutDescriptor> descriptor);
   std::shared_ptr<GPUPipelineLayout>
@@ -153,7 +153,7 @@ public:
   std::unordered_set<std::string> getFeatures();
   std::shared_ptr<GPUSupportedLimits> getLimits();
   std::shared_ptr<GPUQueue> getQueue();
-  async::AsyncTaskHandle getLost();
+  jsi::Value getLost(jsi::Runtime &runtime, const jsi::Object &wrapper);
   void notifyDeviceLost(wgpu::DeviceLostReason reason, std::string message);
   void notifyUncapturedError(wgpu::ErrorType type, std::string message);
   void forceLossForTesting();
@@ -211,7 +211,30 @@ public:
     installGetter(runtime, prototype, "features", &GPUDevice::getFeatures);
     installGetter(runtime, prototype, "limits", &GPUDevice::getLimits);
     installGetter(runtime, prototype, "queue", &GPUDevice::getQueue);
-    installGetter(runtime, prototype, "lost", &GPUDevice::getLost);
+    // `lost` is installed manually: the getter needs the wrapper object
+    // itself, because the promise (and its resolve function) are cached as
+    // hidden properties on the JS side so the GC traces them as part of the
+    // device graph. Holding them strongly from C++ would root the promise's
+    // .then reactions forever (issue #445).
+    {
+      auto lostGetter = jsi::Function::createFromHostFunction(
+          runtime, jsi::PropNameID::forUtf8(runtime, "get_lost"), 0,
+          [](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
+            auto native = GPUDevice::fromValue(rt, thisVal);
+            return native->getLost(rt, thisVal.getObject(rt));
+          });
+      auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
+      auto defineProperty =
+          objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+      jsi::Object descriptor(runtime);
+      descriptor.setProperty(runtime, "get", lostGetter);
+      descriptor.setProperty(runtime, "enumerable", true);
+      descriptor.setProperty(runtime, "configurable", true);
+      defineProperty.call(runtime, prototype,
+                          jsi::String::createFromUtf8(runtime, "lost"),
+                          descriptor);
+    }
     installGetterSetter(runtime, prototype, "label", &GPUDevice::getLabel,
                         &GPUDevice::setLabel);
     installMethod(runtime, prototype, "forceLossForTesting",
@@ -262,15 +285,28 @@ private:
   wgpu::Device _instance;
   std::shared_ptr<async::RuntimeContext> _async;
   std::string _label;
-  // Guards the device-lost state below. In the ProcessEvents model both
-  // notifyDeviceLost() (fired by Dawn during ProcessEvents) and getLost() run on
-  // the owning runtime's own thread, but device destruction can also trigger
-  // notifyDeviceLost() synchronously, so the mutex keeps these fields safe.
+  // Guards the device-lost state below. getLost() runs on a JS thread, but
+  // Dawn's AllowSpontaneous device-lost callback (and device destruction) can
+  // fire notifyDeviceLost() from other threads, so the mutex keeps these
+  // fields safe.
   std::mutex _lostMutex;
-  std::optional<async::AsyncTaskHandle> _lostHandle;
   std::shared_ptr<GPUDeviceLostInfo> _lostInfo;
   bool _lostSettled = false;
-  std::optional<async::AsyncTaskHandle::ResolveFunction> _lostResolve;
+  // Pending `lost` promises, held WEAKLY. A strong native reference would be
+  // a GC root: the promise's .then reactions (three.js captures its whole
+  // renderer there) could never be collected, pinning every GPU wrapper of
+  // the scene and its reported external memory forever (issue #445). The
+  // resolve function lives as a hidden property on the promise object itself,
+  // so if the promise is still alive when the device is lost we can settle
+  // it; if it was collected, nobody could have observed the resolution.
+  // Entries are only added for the device's own runtime when a CallInvoker is
+  // available (main JS runtime), matching the best-effort contract for
+  // spontaneous events.
+  struct PendingLostPromise {
+    jsi::Runtime *runtime;
+    jsi::WeakObject promise;
+  };
+  std::vector<PendingLostPromise> _lostPromises;
 
   // Event listeners storage - keyed by event type
   // Each entry contains a vector of shared_ptr to functions