react-native-wgpu 0.2.10 → 0.3.1

package/cpp/jsi/RNFHybridObject.cpp

@@ -129,6 +129,7 @@ void HybridObject::ensureInitialized(facebook::jsi::Runtime& runtime) {
   if (!_didLoadMethods) {
     [[unlikely]];
     _creationRuntime = &runtime;
+    _runtimeState = rnwgpu::RNFRuntimeState::get(runtime);
     // lazy-load all exposed methods
     loadHybridMethods();
     _didLoadMethods = true;
@@ -136,11 +137,14 @@ void HybridObject::ensureInitialized(facebook::jsi::Runtime& runtime) {
 }
 
 bool HybridObject::isRuntimeAlive() {
-  if (_creationRuntime == nullptr) {
-    [[unlikely]];
-    return false;
+  return !_runtimeState.expired();
+}
+
+facebook::jsi::Runtime* HybridObject::getCreationRuntime() const {
+  if (_runtimeState.expired()) {
+    return nullptr;
   }
-  return RNFWorkletRuntimeRegistry::isRuntimeAlive(_creationRuntime);
+  return _creationRuntime;
 }
 
 } // namespace margelo

package/cpp/jsi/RNFHybridObject.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include "WGPULogger.h"
-#include "RNFWorkletRuntimeRegistry.h"
+#include "RNFRuntimeState.h"
 #include <functional>
 #include <jsi/jsi.h>
 #include <memory>
@@ -91,8 +91,9 @@ private:
 
 protected:
   const char* _name = TAG;
-  // Store a pointer to the runtime. Needed for checking if the runtime is still active, see WorkletRuntimeRegistry.
+  // Store a pointer to the runtime for convenience; ensure it is only used while the runtime state is alive.
   jsi::Runtime* _creationRuntime = nullptr;
+  std::weak_ptr<rnwgpu::RNFRuntimeState> _runtimeState;
 
 private:
   inline void ensureInitialized(facebook::jsi::Runtime& runtime);
@@ -128,6 +129,10 @@ private:
     };
   }
 
+protected:
+  facebook::jsi::Runtime* getCreationRuntime() const;
+  std::weak_ptr<rnwgpu::RNFRuntimeState> getRuntimeStateWeak() const { return _runtimeState; }
+
 protected:
   template <typename Derived, typename ReturnType, typename... Args>
   void registerHybridMethod(std::string name, ReturnType (Derived::*method)(Args...), Derived* derivedInstance, bool override = false) {

package/cpp/jsi/RNFJSIConverter.h

@@ -22,13 +22,11 @@
 #include "RNFEnumMapper.h"
 #include "RNFJSIHelper.h"
 #include "RNFPromise.h"
-#include "RNFWorkletRuntimeRegistry.h"
-
-#include "Dispatcher.h"
-#include "ThreadPool.h"
 
 #include "Unions.h"
 
+#include "rnwgpu/async/AsyncTaskHandle.h"
+
 // This number is the maximum integer that can be represented exactly as a double
 #define MAX_SAFE_INTEGER static_cast<uint64_t>(9007199254740991)
 
@@ -207,109 +205,22 @@ template <typename TEnum> struct JSIConverter<TEnum, std::enable_if_t<std::is_en
   }
 };
 
-// std::future<T> <> Promise<T>
-template <typename TResult> struct JSIConverter<std::future<TResult>> {
-  static std::future<TResult> fromJSI(jsi::Runtime&, const jsi::Value&, bool outOfBound) {
-    throw std::runtime_error("Promise cannot be converted to a native type - it needs to be awaited first!");
-  }
-  static jsi::Value toJSI(jsi::Runtime& runtime, std::future<TResult>&& arg) {
-    auto sharedFuture = std::make_shared<std::future<TResult>>(std::move(arg));
-    std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
-    std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
-
-    return Promise::createPromise(runtime, [sharedFuture = std::move(sharedFuture), weakDispatcher](jsi::Runtime& runtime,
-                                                                                           std::shared_ptr<Promise> promise) {
-      // Spawn new async thread to synchronously wait for the `future<T>` to complete
-      std::shared_ptr<ThreadPool> pool = ThreadPool::getSharedPool();
-      pool->run([promise, &runtime, weakDispatcher, sharedFuture]() {
-        // synchronously wait until the `future<T>` completes. we are running on a background task here.
-        sharedFuture->wait();
-
-        std::shared_ptr<Dispatcher> dispatcher = weakDispatcher.lock();
-        if (!dispatcher) {
-          throw std::runtime_error("Tried resolving Promise on JS Thread, but the `Dispatcher` has already been destroyed!");
-          return;
-        }
-
-        dispatcher->runAsync([&runtime, promise, sharedFuture]() mutable {
-          try {
-            if constexpr (std::is_same_v<TResult, void>) {
-                // it's returning void, just return undefined to JS
-              sharedFuture->get();
-              promise->resolve(jsi::Value::undefined());
-            } else {
-              // it's returning a custom type, convert it to a jsi::Value
-              TResult result = sharedFuture->get();
-              jsi::Value jsResult = JSIConverter<TResult>::toJSI(runtime, result);
-              promise->resolve(std::move(jsResult));
-            }
-          } catch (const std::exception& exception) {
-            // the async function threw an error, reject the promise
-            std::string what = exception.what();
-            promise->reject(what);
-          } catch (...) {
-            // the async function threw a non-std error, try getting it
-    #if __has_include(<cxxabi.h>)
-            std::string name = __cxxabiv1::__cxa_current_exception_type()->name();
-    #else
-            std::string name = "<unknown>";
-    #endif
-            promise->reject("Unknown non-std exception: " + name);
-          }
-
-          // This lambda owns the promise shared pointer, and we need to call its
-          // destructor correctly here - otherwise it might be called
-          // from the threadPool thread.
-          promise = nullptr;
-        });
-      });
-    });
+// AsyncTaskHandle <> Promise
+template <> struct JSIConverter<rnwgpu::async::AsyncTaskHandle> {
+  static rnwgpu::async::AsyncTaskHandle fromJSI(jsi::Runtime&, const jsi::Value&, bool) {
+    throw std::runtime_error("Cannot convert a Promise to AsyncTaskHandle on the native side.");
   }
-};
 
-
-// [](Args...) -> T {} <> (Args...) => T
-template <typename ReturnType, typename... Args> struct JSIConverter<std::function<ReturnType(Args...)>> {
-  static std::function<ReturnType(Args...)> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
-    jsi::Function function = arg.asObject(runtime).asFunction(runtime);
-
-    std::shared_ptr<jsi::Function> sharedFunction = JSIHelper::createSharedJsiFunction(runtime, std::move(function));
-    return [&runtime, sharedFunction, outOfBound](Args... args) -> ReturnType {
-      jsi::Value result = sharedFunction->call(runtime, JSIConverter<std::decay_t<Args>>::toJSI(runtime, args)...);
-      if constexpr (std::is_same_v<ReturnType, void>) {
-        // it is a void function (returns undefined)
+  static jsi::Value toJSI(jsi::Runtime& runtime, rnwgpu::async::AsyncTaskHandle&& handle) {
+    return Promise::createPromise(runtime, [handle = std::move(handle)](jsi::Runtime& runtime,
+                                                                        std::shared_ptr<Promise> promise) mutable {
+      if (!handle.valid()) {
+        promise->resolve(jsi::Value::undefined());
         return;
-      } else {
-        // it returns a custom type, parse it from the JSI value.
-        return JSIConverter<ReturnType>::fromJSI(runtime, std::move(result), outOfBound);
       }
-    };
-  }
 
-  template <size_t... Is>
-  static jsi::Value callHybridFunction(const std::function<ReturnType(Args...)>& function, jsi::Runtime& runtime, const jsi::Value* args,
-                                       std::index_sequence<Is...>, size_t count) {
-    if constexpr (std::is_same_v<ReturnType, void>) {
-      // it is a void function (will return undefined in JS)
-      function(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is], Is >= count)...);
-      return jsi::Value::undefined();
-    } else {
-      // it is a custom type, parse it to a JS value
-      ReturnType result = function(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is], Is >= count)...);
-      return JSIConverter<ReturnType>::toJSI(runtime, result);
-    }
-  }
-  static jsi::Value toJSI(jsi::Runtime& runtime, const std::function<ReturnType(Args...)>& function) {
-    jsi::HostFunctionType jsFunction = [function = std::move(function)](jsi::Runtime& runtime, const jsi::Value& thisValue,
-                                                                        const jsi::Value* args, size_t count) -> jsi::Value {
-      if (count != sizeof...(Args)) {
-        [[unlikely]];
-        throw jsi::JSError(runtime, "Function expected " + std::to_string(sizeof...(Args)) + " arguments, but received " +
-                                        std::to_string(count) + "!");
-      }
-      return callHybridFunction(function, runtime, args, std::index_sequence_for<Args...>{}, count);
-    };
-    return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "hostFunction"), sizeof...(Args), jsFunction);
+      handle.attachPromise(promise);
+    });
   }
 };
 

package/cpp/jsi/RNFJSIHelper.h

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "RNFWorkletRuntimeRegistry.h"
+#include "RNFRuntimeState.h"
 #include <jsi/jsi.h>
 #include <memory>
 #include <utility>
@@ -20,8 +20,10 @@ public:
    * Every jsi::Function you intend to share or hold should be wrapped using this function.
    */
   static std::shared_ptr<jsi::Function> createSharedJsiFunction(jsi::Runtime& runtime, jsi::Function&& function) {
-    std::shared_ptr<jsi::Function> sharedFunction(new jsi::Function(std::move(function)), [&runtime](jsi::Function* ptr) {
-      if (RNFWorkletRuntimeRegistry::isRuntimeAlive(&runtime)) {
+    auto runtimeState = rnwgpu::RNFRuntimeState::get(runtime);
+    std::weak_ptr<rnwgpu::RNFRuntimeState> runtimeStateWeak = runtimeState;
+    std::shared_ptr<jsi::Function> sharedFunction(new jsi::Function(std::move(function)), [runtimeStateWeak](jsi::Function* ptr) {
+      if (!runtimeStateWeak.expired()) {
         // Only delete the jsi::Function when the runtime it created is still alive.
         // Otherwise leak memory. We do this on purpose, as sometimes we would keep
         // references to JSI objects past the lifetime of its runtime (e.g.,

package/cpp/jsi/RNFRuntimeState.cpp

@@ -0,0 +1,18 @@
+#include "RNFRuntimeState.h"
+
+namespace rnwgpu {
+
+const facebook::jsi::UUID RNFRuntimeState::kRuntimeStateKey = facebook::jsi::UUID();
+
+std::shared_ptr<RNFRuntimeState> RNFRuntimeState::get(facebook::jsi::Runtime& runtime) {
+  auto existing = runtime.getRuntimeData(kRuntimeStateKey);
+  if (existing) {
+    return std::static_pointer_cast<RNFRuntimeState>(existing);
+  }
+
+  auto state = std::shared_ptr<RNFRuntimeState>(new RNFRuntimeState());
+  runtime.setRuntimeData(kRuntimeStateKey, state);
+  return state;
+}
+
+} // namespace rnwgpu

package/cpp/jsi/RNFRuntimeState.h

@@ -0,0 +1,106 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+/**
+ * Runtime state management using Hermes' runtime.setRuntimeData API.
+ * This replaces the old RuntimeLifecycleMonitor/RuntimeAwareCache system.
+ */
+class RNFRuntimeState {
+public:
+  // UUID key for storing our runtime state
+  static const jsi::UUID kRuntimeStateKey;
+
+  /**
+   * Get or create the runtime state for the given runtime
+   */
+  static std::shared_ptr<RNFRuntimeState> get(jsi::Runtime& runtime);
+
+  /**
+   * Template cache that can store any type T per object pointer
+   */
+  template <typename T>
+  class ObjectCache {
+  public:
+    std::shared_ptr<T> getOrCreate(void* object) {
+      std::lock_guard<std::mutex> lock(mutex_);
+      auto it = cache_.find(object);
+      if (it != cache_.end()) {
+        return it->second;
+      }
+
+      auto value = std::make_shared<T>();
+      cache_[object] = value;
+      return value;
+    }
+
+    void remove(void* object) {
+      std::lock_guard<std::mutex> lock(mutex_);
+      cache_.erase(object);
+    }
+
+    void clear() {
+      std::lock_guard<std::mutex> lock(mutex_);
+      cache_.clear();
+    }
+
+  private:
+    std::mutex mutex_;
+    std::unordered_map<void*, std::shared_ptr<T>> cache_;
+  };
+
+  /**
+   * Get or create a cache for a specific type T
+   */
+  template <typename T>
+  std::shared_ptr<ObjectCache<T>> getCache() {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    // Use type_info as key for the cache type
+    const std::type_info& typeId = typeid(T);
+    auto it = typeCaches_.find(&typeId);
+
+    if (it != typeCaches_.end()) {
+      return std::static_pointer_cast<ObjectCache<T>>(it->second);
+    }
+
+    auto cache = std::make_shared<ObjectCache<T>>();
+    typeCaches_[&typeId] = cache;
+    return cache;
+  }
+
+private:
+  RNFRuntimeState() = default;
+
+  std::mutex mutex_;
+  // Map from type_info to cache instance
+  std::unordered_map<const std::type_info*, std::shared_ptr<void>> typeCaches_;
+};
+
+/**
+ * Template helper for runtime-aware caching compatible with the old API
+ * This provides a migration path from RuntimeAwareCache
+ */
+template <typename T>
+class RuntimeAwareCache {
+public:
+  T& get(jsi::Runtime& rt) {
+    auto state = RNFRuntimeState::get(rt);
+    auto cache = state->getCache<T>();
+
+    // For compatibility, we use the runtime pointer as the object key
+    auto ptr = cache->getOrCreate(&rt);
+    return *ptr;
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -1,7 +1,5 @@
 #include "RNWebGPUManager.h"
 
-#include "CallInvokerDispatcher.h"
-#include "Dispatcher.h"
 #include "GPU.h"
 #include "RNWebGPU.h"
 
@@ -24,13 +22,7 @@ RNWebGPUManager::RNWebGPUManager(
     : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker),
       _platformContext(platformContext) {
 
-  // Installs the global Dispatcher mechanism into this Runtime.
-  // This allows creating Promises and calling back to JS.
-  auto dispatcher =
-      std::make_shared<margelo::CallInvokerDispatcher>(_jsCallInvoker);
-  margelo::Dispatcher::installRuntimeGlobalDispatcher(*_jsRuntime, dispatcher);
-
-  auto gpu = std::make_shared<GPU>();
+  auto gpu = std::make_shared<GPU>(*_jsRuntime);
   auto rnWebGPU = std::make_shared<RNWebGPU>(gpu, _platformContext);
   _gpu = gpu->get();
   _jsRuntime->global().setProperty(

package/cpp/rnwgpu/api/GPU.cpp

@@ -8,16 +8,26 @@
 #include <vector>
 
 #include "Convertors.h"
+#include "RNFJSIConverter.h"
+#include "rnwgpu/async/JSIMicrotaskDispatcher.h"
 
 namespace rnwgpu {
 
-std::future<std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>>
-GPU::requestAdapter(
-    std::optional<std::shared_ptr<GPURequestAdapterOptions>> options) {
-  std::promise<std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>>
-      promise;
-  auto future = promise.get_future();
+GPU::GPU(jsi::Runtime &runtime) : HybridObject("GPU") {
+  static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
+  wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
+                                        .requiredFeatures = &kTimedWaitAny};
+
+  wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
+  instanceDesc.requiredLimits = &limits;
+  _instance = wgpu::CreateInstance(&instanceDesc);
+
+  auto dispatcher = std::make_shared<async::JSIMicrotaskDispatcher>(runtime);
+  _async = async::AsyncRunner::getOrCreate(runtime, _instance, dispatcher);
+}
 
+async::AsyncTaskHandle GPU::requestAdapter(
+    std::optional<std::shared_ptr<GPURequestAdapterOptions>> options) {
   wgpu::RequestAdapterOptions aOptions;
   Convertor conv;
   if (!conv(aOptions, options)) {
@@ -29,26 +39,41 @@ GPU::requestAdapter(
   constexpr auto kDefaultBackendType = wgpu::BackendType::Vulkan;
 #endif
   aOptions.backendType = kDefaultBackendType;
-  wgpu::Adapter adapter = nullptr;
-  _instance.RequestAdapter(
-      &aOptions, wgpu::CallbackMode::AllowSpontaneous,
-      [](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
-         wgpu::StringView message, wgpu::Adapter *userdata) {
-        if (message.length) {
-          fprintf(stderr, "%s", message.data);
-          return;
-        }
-        if (status == wgpu::RequestAdapterStatus::Success) {
-          *userdata = std::move(adapter);
-        }
-      },
-      &adapter);
-  if (!adapter) {
-    promise.set_value(nullptr);
-  } else {
-    promise.set_value(std::make_shared<GPUAdapter>(std::move(adapter), _async));
-  }
-  return future;
+  return _async->postTask(
+      [this, aOptions](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                       const async::AsyncTaskHandle::RejectFunction &reject) {
+        _instance.RequestAdapter(
+            &aOptions, wgpu::CallbackMode::AllowProcessEvents,
+            [asyncRunner = _async, resolve,
+             reject](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
+                     wgpu::StringView message) {
+              if (message.length) {
+                fprintf(stderr, "%s", message.data);
+              }
+
+              if (status == wgpu::RequestAdapterStatus::Success && adapter) {
+                auto adapterHost = std::make_shared<GPUAdapter>(
+                    std::move(adapter), asyncRunner);
+                auto result =
+                    std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>(
+                        adapterHost);
+                resolve([result =
+                             std::move(result)](jsi::Runtime &runtime) mutable {
+                  return margelo::JSIConverter<decltype(result)>::toJSI(runtime,
+                                                                        result);
+                });
+              } else {
+                auto result =
+                    std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>(
+                        nullptr);
+                resolve([result =
+                             std::move(result)](jsi::Runtime &runtime) mutable {
+                  return margelo::JSIConverter<decltype(result)>::toJSI(runtime,
+                                                                        result);
+                });
+              }
+            });
+      });
 }
 
 std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {

package/cpp/rnwgpu/api/GPU.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <future>
 #include <memory>
 #include <string>
 #include <unordered_set>
@@ -10,9 +9,9 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
 
-#include "dawn/dawn_proc.h"
 #include "dawn/native/DawnNative.h"
 #include "webgpu/webgpu_cpp.h"
 
@@ -27,24 +26,12 @@ namespace m = margelo;
 
 class GPU : public m::HybridObject {
 public:
-  GPU() : HybridObject("GPU") {
-    static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
-    wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
-                                          .requiredFeatures = &kTimedWaitAny};
-
-    // For limits:
-    wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
-    instanceDesc.requiredLimits = &limits;
-    _instance = wgpu::CreateInstance(&instanceDesc);
-    auto instance = &_instance;
-    _async = std::make_shared<AsyncRunner>(instance);
-  }
+  explicit GPU(jsi::Runtime &runtime);
 
 public:
   std::string getBrand() { return _name; }
 
-  std::future<std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>>
-  requestAdapter(
+  async::AsyncTaskHandle requestAdapter(
       std::optional<std::shared_ptr<GPURequestAdapterOptions>> options);
   wgpu::TextureFormat getPreferredCanvasFormat();
 
@@ -63,7 +50,7 @@ public:
 
 private:
   wgpu::Instance _instance;
-  std::shared_ptr<AsyncRunner> _async;
+  std::shared_ptr<async::AsyncRunner> _async;
 };
 
 } // namespace rnwgpu