react-native-wgpu 0.2.10 → 0.3.1

package/cpp/rnwgpu/api/GPUSampler.h

@@ -6,8 +6,6 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
-
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
@@ -42,4 +40,4 @@ private:
   std::string _label;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -3,36 +3,50 @@
 #include <memory>
 #include <utility>
 
+#include "RNFJSIConverter.h"
+
 namespace rnwgpu {
 
-std::future<std::shared_ptr<GPUCompilationInfo>>
-GPUShaderModule::getCompilationInfo() {
-  return _async->runAsync([=](wgpu::Instance *instance) {
-    wgpu::CompilationInfo compilationInfo;
-    auto result = std::make_shared<GPUCompilationInfo>();
-    auto future = _instance.GetCompilationInfo(
-        wgpu::CallbackMode::WaitAnyOnly,
-        [&result](wgpu::CompilationInfoRequestStatus status,
-                  wgpu::CompilationInfo const *compilationInfo) {
-          if (status == wgpu::CompilationInfoRequestStatus::Success &&
-              compilationInfo) {
-            for (size_t i = 0; i < compilationInfo->messageCount; ++i) {
-              const auto &wgpuMessage = compilationInfo->messages[i];
-              GPUCompilationMessage message;
-              message.message =
-                  wgpuMessage.message.length ? wgpuMessage.message.data : "";
-              message.type = wgpuMessage.type;
-              message.lineNum = wgpuMessage.lineNum;
-              message.linePos = wgpuMessage.linePos;
-              message.offset = wgpuMessage.offset;
-              message.length = wgpuMessage.length;
-              result->_messages.push_back(std::move(message));
-            }
-          }
-        });
-    instance->WaitAny(future, UINT64_MAX);
-    return result;
-  });
+async::AsyncTaskHandle GPUShaderModule::getCompilationInfo() {
+  auto module = _instance;
+
+  return _async->postTask(
+      [module](const async::AsyncTaskHandle::ResolveFunction &resolve,
+               const async::AsyncTaskHandle::RejectFunction &reject) {
+        auto result = std::make_shared<GPUCompilationInfo>();
+        module.GetCompilationInfo(
+            wgpu::CallbackMode::AllowProcessEvents,
+            [result, resolve,
+             reject](wgpu::CompilationInfoRequestStatus status,
+                     const wgpu::CompilationInfo *compilationInfo) mutable {
+              if (status != wgpu::CompilationInfoRequestStatus::Success ||
+                  compilationInfo == nullptr) {
+                reject("Failed to get compilation info");
+                return;
+              }
+
+              result->_messages.reserve(compilationInfo->messageCount);
+              for (size_t i = 0; i < compilationInfo->messageCount; ++i) {
+                const auto &wgpuMessage = compilationInfo->messages[i];
+                GPUCompilationMessage message;
+                message.message =
+                    wgpuMessage.message.length ? wgpuMessage.message.data : "";
+                message.type = wgpuMessage.type;
+                message.lineNum = wgpuMessage.lineNum;
+                message.linePos = wgpuMessage.linePos;
+                message.offset = wgpuMessage.offset;
+                message.length = wgpuMessage.length;
+                result->_messages.push_back(std::move(message));
+              }
+
+              resolve(
+                  [result = std::move(result)](jsi::Runtime &runtime) mutable {
+                    return margelo::JSIConverter<
+                        std::shared_ptr<GPUCompilationInfo>>::toJSI(runtime,
+                                                                    result);
+                  });
+            });
+      });
 }
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUShaderModule.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <future>
 #include <memory>
 #include <string>
 
@@ -8,7 +7,8 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -21,7 +21,7 @@ namespace m = margelo;
 class GPUShaderModule : public m::HybridObject {
 public:
   explicit GPUShaderModule(wgpu::ShaderModule instance,
-                           std::shared_ptr<AsyncRunner> async,
+                           std::shared_ptr<async::AsyncRunner> async,
                            std::string label)
       : HybridObject("GPUShaderModule"), _instance(instance), _async(async),
         _label(label) {}
@@ -29,7 +29,7 @@ public:
 public:
   std::string getBrand() { return _name; }
 
-  std::future<std::shared_ptr<GPUCompilationInfo>> getCompilationInfo();
+  async::AsyncTaskHandle getCompilationInfo();
 
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {
@@ -58,8 +58,8 @@ public:
 
 private:
   wgpu::ShaderModule _instance;
-  std::shared_ptr<AsyncRunner> _async;
+  std::shared_ptr<async::AsyncRunner> _async;
   std::string _label;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSupportedLimits.h

@@ -6,8 +6,6 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
-
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
@@ -150,4 +148,4 @@ private:
   wgpu::Limits _instance;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUTexture.h

@@ -8,8 +8,6 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
-
 #include "webgpu/webgpu_cpp.h"
 
 #include "GPUTextureView.h"
@@ -145,4 +143,4 @@ private:
   std::string _label;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUTextureView.h

@@ -6,8 +6,6 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
-
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {
@@ -42,4 +40,4 @@ private:
   std::string _label;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -30,13 +30,7 @@ public:
 
   std::shared_ptr<GPU> getGPU() { return _gpu; }
 
-  bool getFabric() {
-#ifdef RCT_NEW_ARCH_ENABLED
-    return true;
-#else
-    return false;
-#endif
-  }
+  bool getFabric() { return true; }
 
   std::shared_ptr<GPUCanvasContext>
   MakeWebGPUCanvasContext(int contextId, float width, float height) {

package/cpp/rnwgpu/async/AsyncDispatcher.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+
+#include <jsi/jsi.h>
+
+namespace rnwgpu::async {
+
+namespace jsi = facebook::jsi;
+
+/**
+ * Abstract dispatcher used by the AsyncRunner to enqueue work back onto the
+ * JavaScript thread.
+ */
+class AsyncDispatcher {
+public:
+  using Work = std::function<void(jsi::Runtime &)>;
+
+  virtual ~AsyncDispatcher() = default;
+
+  /**
+   * Enqueue a unit of work that will be executed on the JavaScript thread.
+   */
+  virtual void post(Work work) = 0;
+};
+
+} // namespace rnwgpu::async

package/cpp/rnwgpu/async/AsyncRunner.cpp

@@ -0,0 +1,215 @@
+#include "AsyncRunner.h"
+
+#include <chrono>
+#include <stdexcept>
+#include <utility>
+
+#include "AsyncTaskHandle.h"
+#include "WGPULogger.h"
+
+namespace rnwgpu::async {
+
+namespace {
+struct RuntimeData {
+  std::shared_ptr<AsyncRunner> runner;
+};
+constexpr const char *TAG = "AsyncRunner";
+} // namespace
+
+AsyncRunner::AsyncRunner(wgpu::Instance instance,
+                         std::shared_ptr<AsyncDispatcher> dispatcher)
+    : _instance(std::move(instance)), _dispatcher(std::move(dispatcher)),
+      _pendingTasks(0), _pumpTasks(0), _tickScheduled(false),
+      _lastTickTimeNs(0) {
+  if (!_dispatcher) {
+    throw std::runtime_error("AsyncRunner requires a valid dispatcher.");
+  }
+  Logger::logToConsole("[%s] Created runner (dispatcher=%p)", TAG,
+                       _dispatcher.get());
+}
+
+std::shared_ptr<AsyncRunner> AsyncRunner::get(jsi::Runtime &runtime) {
+  auto data = runtime.getRuntimeData(runtimeDataUUID());
+  if (!data) {
+    return nullptr;
+  }
+  auto stored = std::static_pointer_cast<RuntimeData>(data);
+  return stored->runner;
+}
+
+std::shared_ptr<AsyncRunner>
+AsyncRunner::getOrCreate(jsi::Runtime &runtime, wgpu::Instance instance,
+                         std::shared_ptr<AsyncDispatcher> dispatcher) {
+  auto existing = get(runtime);
+  if (existing) {
+    return existing;
+  }
+
+  auto runner =
+      std::make_shared<AsyncRunner>(std::move(instance), std::move(dispatcher));
+  auto data = std::make_shared<RuntimeData>();
+  data->runner = runner;
+  runtime.setRuntimeData(runtimeDataUUID(), data);
+  return runner;
+}
+
+AsyncTaskHandle AsyncRunner::postTask(const TaskCallback &callback,
+                                      bool keepPumping) {
+  auto handle = AsyncTaskHandle::create(shared_from_this(), keepPumping);
+  if (!handle.valid()) {
+    throw std::runtime_error("Failed to create AsyncTaskHandle.");
+  }
+
+  _pendingTasks.fetch_add(1, std::memory_order_acq_rel);
+  if (keepPumping) {
+    _pumpTasks.fetch_add(1, std::memory_order_acq_rel);
+  }
+  requestTick();
+
+  Logger::logToConsole(
+      "[%s] postTask (keepPumping=%s, pending=%zu, pumping=%zu)", TAG,
+      keepPumping ? "true" : "false",
+      _pendingTasks.load(std::memory_order_acquire),
+      _pumpTasks.load(std::memory_order_acquire));
+
+  auto resolve = handle.createResolveFunction();
+  auto reject = handle.createRejectFunction();
+
+  try {
+    callback(resolve, reject);
+  } catch (const std::exception &exception) {
+    reject(exception.what());
+  } catch (...) {
+    reject("Unknown native error in AsyncRunner::postTask.");
+  }
+
+  return handle;
+}
+
+void AsyncRunner::requestTick() {
+  bool expected = false;
+  if (!_tickScheduled.compare_exchange_strong(expected, true,
+                                              std::memory_order_acq_rel)) {
+    return;
+  }
+
+  auto self = shared_from_this();
+  _dispatcher->post([self](jsi::Runtime &runtime) {
+    auto tickCallback = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forAscii(runtime, "AsyncRunnerTick"), 0,
+        [self](jsi::Runtime &runtime, const jsi::Value & /*thisValue*/,
+               const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
+          self->tick(runtime);
+          return jsi::Value::undefined();
+        });
+
+#if defined(ANDROID) || defined(__ANDROID__)
+    auto global = runtime.global();
+    auto setImmediateValue = global.getProperty(runtime, "setImmediate");
+    constexpr auto kMinTickInterval = std::chrono::milliseconds(4);
+    const int64_t nowNs =
+        std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::steady_clock::now().time_since_epoch())
+            .count();
+    const int64_t lastNs =
+        self->_lastTickTimeNs.load(std::memory_order_acquire);
+    int delayMs = 0;
+    if (lastNs > 0) {
+      const int64_t elapsedNs = nowNs - lastNs;
+      const int64_t minIntervalNs = kMinTickInterval.count() * 1000000LL;
+      if (elapsedNs < minIntervalNs) {
+        const int64_t remainingNs = minIntervalNs - elapsedNs;
+        delayMs = static_cast<int>((remainingNs + 999999) / 1000000);
+      }
+    }
+
+    auto tryScheduleTimeout = [&](int ms) {
+      auto setTimeoutValue = global.getProperty(runtime, "setTimeout");
+      if (!setTimeoutValue.isObject()) {
+        return false;
+      }
+      auto setTimeoutObj = setTimeoutValue.asObject(runtime);
+      if (!setTimeoutObj.isFunction(runtime)) {
+        return false;
+      }
+      Logger::logToConsole("[%s] requestTick scheduled via setTimeout(%d)", TAG,
+                           ms);
+      auto setTimeoutFn = setTimeoutObj.asFunction(runtime);
+      jsi::Value callbackArg(runtime, tickCallback);
+      jsi::Value delayArg(static_cast<double>(ms));
+      setTimeoutFn.call(runtime, callbackArg, delayArg);
+      return true;
+    };
+
+    if (delayMs > 0) {
+      if (tryScheduleTimeout(delayMs)) {
+        return;
+      }
+      // If setTimeout unavailable fall through to immediate scheduling.
+    }
+
+    if (setImmediateValue.isObject()) {
+      auto setImmediateObj = setImmediateValue.asObject(runtime);
+      if (setImmediateObj.isFunction(runtime)) {
+        Logger::logToConsole("[%s] requestTick scheduled via setImmediate",
+                             TAG);
+        auto setImmediateFn = setImmediateObj.asFunction(runtime);
+        jsi::Value callbackArg(runtime, tickCallback);
+        setImmediateFn.call(runtime, callbackArg);
+        return;
+      }
+    }
+
+    int timeoutDelayMs = delayMs > 0 ? delayMs : 0;
+    if (tryScheduleTimeout(timeoutDelayMs)) {
+      return;
+    }
+
+    Logger::logToConsole("[%s] requestTick scheduled via microtask fallback",
+                         TAG);
+    runtime.queueMicrotask(std::move(tickCallback));
+#else
+    Logger::logToConsole("[%s] requestTick scheduled microtask (non-Android)",
+                         TAG);
+    runtime.queueMicrotask(std::move(tickCallback));
+#endif
+  });
+}
+
+void AsyncRunner::tick(jsi::Runtime & /*runtime*/) {
+  _tickScheduled.store(false, std::memory_order_release);
+  _instance.ProcessEvents();
+  const auto nowNs = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                         std::chrono::steady_clock::now().time_since_epoch())
+                         .count();
+  _lastTickTimeNs.store(nowNs, std::memory_order_release);
+  Logger::logToConsole("[%s] tick processed events (pending=%zu, pumping=%zu)",
+                       TAG, _pendingTasks.load(std::memory_order_acquire),
+                       _pumpTasks.load(std::memory_order_acquire));
+  if (_pumpTasks.load(std::memory_order_acquire) > 0) {
+    requestTick();
+  }
+}
+
+void AsyncRunner::onTaskSettled(bool keepPumping) {
+  _pendingTasks.fetch_sub(1, std::memory_order_acq_rel);
+  if (keepPumping) {
+    _pumpTasks.fetch_sub(1, std::memory_order_acq_rel);
+  }
+  Logger::logToConsole(
+      "[%s] onTaskSettled (keepPumping=%s, pending=%zu, pumping=%zu)", TAG,
+      keepPumping ? "true" : "false",
+      _pendingTasks.load(std::memory_order_acquire),
+      _pumpTasks.load(std::memory_order_acquire));
+}
+
+std::shared_ptr<AsyncDispatcher> AsyncRunner::dispatcher() const {
+  return _dispatcher;
+}
+
+jsi::UUID AsyncRunner::runtimeDataUUID() {
+  static const auto uuid = jsi::UUID();
+  return uuid;
+}
+
+} // namespace rnwgpu::async

package/cpp/rnwgpu/async/AsyncRunner.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <atomic>
+#include <cstdint>
+#include <functional>
+#include <memory>
+
+#include <jsi/jsi.h>
+
+#include "AsyncDispatcher.h"
+#include "AsyncTaskHandle.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu::async {
+
+class AsyncRunner : public std::enable_shared_from_this<AsyncRunner> {
+public:
+  using TaskCallback =
+      std::function<void(const AsyncTaskHandle::ResolveFunction &,
+                         const AsyncTaskHandle::RejectFunction &)>;
+
+  AsyncRunner(wgpu::Instance instance,
+              std::shared_ptr<AsyncDispatcher> dispatcher);
+
+  static std::shared_ptr<AsyncRunner> get(jsi::Runtime &runtime);
+  static std::shared_ptr<AsyncRunner>
+  getOrCreate(jsi::Runtime &runtime, wgpu::Instance instance,
+              std::shared_ptr<AsyncDispatcher> dispatcher);
+
+  AsyncTaskHandle postTask(const TaskCallback &callback,
+                           bool keepPumping = true);
+
+  void requestTick();
+  void tick(jsi::Runtime &runtime);
+  void onTaskSettled(bool keepPumping);
+
+  std::shared_ptr<AsyncDispatcher> dispatcher() const;
+
+private:
+  static jsi::UUID runtimeDataUUID();
+
+  wgpu::Instance _instance;
+  std::shared_ptr<AsyncDispatcher> _dispatcher;
+  std::atomic<size_t> _pendingTasks;
+  std::atomic<size_t> _pumpTasks;
+  std::atomic<bool> _tickScheduled;
+  std::atomic<int64_t> _lastTickTimeNs;
+};
+
+} // namespace rnwgpu::async

package/cpp/rnwgpu/async/AsyncTaskHandle.cpp

@@ -0,0 +1,181 @@
+#include "AsyncTaskHandle.h"
+
+#include <string>
+#include <utility>
+
+#include "RNFPromise.h"
+
+#include "AsyncRunner.h"
+
+namespace rnwgpu::async {
+
+using Action = std::function<void(jsi::Runtime &, margelo::Promise &)>;
+
+struct AsyncTaskHandle::State
+    : public std::enable_shared_from_this<AsyncTaskHandle::State> {
+  State(std::shared_ptr<AsyncRunner> runner, bool keepPumping)
+      : runner(std::move(runner)), keepPumping(keepPumping) {}
+
+  void settle(Action action);
+  void attachPromise(const std::shared_ptr<margelo::Promise> &promise);
+  void schedule(Action action);
+
+  ResolveFunction createResolveFunction();
+  RejectFunction createRejectFunction();
+
+  std::shared_ptr<margelo::Promise> currentPromise();
+
+  std::mutex mutex;
+  std::weak_ptr<AsyncRunner> runner;
+  std::shared_ptr<margelo::Promise> promise;
+  std::optional<Action> pendingAction;
+  bool settled = false;
+  std::shared_ptr<State> keepAlive;
+  bool keepPumping;
+};
+
+// MARK: - State helpers
+
+void AsyncTaskHandle::State::settle(Action action) {
+  std::optional<Action> actionToSchedule;
+
+  {
+    std::lock_guard<std::mutex> lock(mutex);
+    if (settled) {
+      return;
+    }
+    settled = true;
+
+    if (promise) {
+      actionToSchedule = std::move(action);
+    } else {
+      pendingAction = std::move(action);
+    }
+  }
+
+  if (actionToSchedule.has_value()) {
+    schedule(std::move(*actionToSchedule));
+  }
+}
+
+void AsyncTaskHandle::State::attachPromise(
+    const std::shared_ptr<margelo::Promise> &newPromise) {
+  std::optional<Action> actionToSchedule;
+  {
+    std::lock_guard<std::mutex> lock(mutex);
+    promise = newPromise;
+    keepAlive = shared_from_this();
+    if (pendingAction.has_value()) {
+      actionToSchedule = std::move(pendingAction);
+      pendingAction.reset();
+    }
+  }
+
+  if (actionToSchedule.has_value()) {
+    schedule(std::move(*actionToSchedule));
+  }
+}
+
+void AsyncTaskHandle::State::schedule(Action action) {
+  auto runnerRef = runner.lock();
+  if (!runnerRef) {
+    return;
+  }
+
+  auto promiseRef = currentPromise();
+  if (!promiseRef) {
+    runnerRef->onTaskSettled(keepPumping);
+    return;
+  }
+
+  auto dispatcherRef = runnerRef->dispatcher();
+  if (!dispatcherRef) {
+    runnerRef->onTaskSettled(keepPumping);
+    return;
+  }
+
+  dispatcherRef->post([self = shared_from_this(), action = std::move(action),
+                       runnerRef, promiseRef](jsi::Runtime &runtime) mutable {
+    runnerRef->onTaskSettled(self->keepPumping);
+    action(runtime, *promiseRef);
+    std::lock_guard<std::mutex> lock(self->mutex);
+    self->keepAlive.reset();
+  });
+}
+
+AsyncTaskHandle::ResolveFunction
+AsyncTaskHandle::State::createResolveFunction() {
+  auto weakSelf = std::weak_ptr<State>(shared_from_this());
+  return [weakSelf](ValueFactory factory) {
+    if (auto self = weakSelf.lock()) {
+      ValueFactory resolvedFactory =
+          factory ? std::move(factory) : [](jsi::Runtime &runtime) {
+            return jsi::Value::undefined();
+          };
+      self->settle(
+          [factory = std::move(resolvedFactory)](
+              jsi::Runtime &runtime, margelo::Promise &promise) mutable {
+            auto value = factory(runtime);
+            promise.resolve(std::move(value));
+          });
+    }
+  };
+}
+
+AsyncTaskHandle::RejectFunction AsyncTaskHandle::State::createRejectFunction() {
+  auto weakSelf = std::weak_ptr<State>(shared_from_this());
+  return [weakSelf](std::string reason) {
+    if (auto self = weakSelf.lock()) {
+      self->settle([reason = std::move(reason)](jsi::Runtime & /*runtime*/,
+                                                margelo::Promise &promise) {
+        promise.reject(reason);
+      });
+    }
+  };
+}
+
+std::shared_ptr<margelo::Promise> AsyncTaskHandle::State::currentPromise() {
+  std::lock_guard<std::mutex> lock(mutex);
+  return promise;
+}
+
+// MARK: - AsyncTaskHandle
+
+AsyncTaskHandle::AsyncTaskHandle() = default;
+
+AsyncTaskHandle::AsyncTaskHandle(std::shared_ptr<State> state)
+    : _state(std::move(state)) {}
+
+bool AsyncTaskHandle::valid() const { return _state != nullptr; }
+
+AsyncTaskHandle
+AsyncTaskHandle::create(const std::shared_ptr<AsyncRunner> &runner,
+                        bool keepPumping) {
+  auto state = std::make_shared<State>(runner, keepPumping);
+  state->keepAlive = state;
+  return AsyncTaskHandle(std::move(state));
+}
+
+AsyncTaskHandle::ResolveFunction
+AsyncTaskHandle::createResolveFunction() const {
+  if (!_state) {
+    return [](ValueFactory) {};
+  }
+  return _state->createResolveFunction();
+}
+
+AsyncTaskHandle::RejectFunction AsyncTaskHandle::createRejectFunction() const {
+  if (!_state) {
+    return [](std::string) {};
+  }
+  return _state->createRejectFunction();
+}
+
+void AsyncTaskHandle::attachPromise(
+    const std::shared_ptr<margelo::Promise> &promise) const {
+  if (_state) {
+    _state->attachPromise(promise);
+  }
+}
+
+} // namespace rnwgpu::async