react-native-webgpu 0.5.11

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 "Promise.h"
+
+#include "AsyncRunner.h"
+
+namespace rnwgpu::async {
+
+using Action = std::function<void(jsi::Runtime &, rnwgpu::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<rnwgpu::Promise> &promise);
+  void schedule(Action action);
+
+  ResolveFunction createResolveFunction();
+  RejectFunction createRejectFunction();
+
+  std::shared_ptr<rnwgpu::Promise> currentPromise();
+
+  std::mutex mutex;
+  std::weak_ptr<AsyncRunner> runner;
+  std::shared_ptr<rnwgpu::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<rnwgpu::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, rnwgpu::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*/,
+                                                rnwgpu::Promise &promise) {
+        promise.reject(reason);
+      });
+    }
+  };
+}
+
+std::shared_ptr<rnwgpu::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<rnwgpu::Promise> &promise) const {
+  if (_state) {
+    _state->attachPromise(promise);
+  }
+}
+
+} // namespace rnwgpu::async

package/cpp/rnwgpu/async/AsyncTaskHandle.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+
+#include <jsi/jsi.h>
+
+#include "AsyncDispatcher.h"
+
+namespace rnwgpu {
+class Promise;
+}
+
+namespace rnwgpu::async {
+
+class AsyncRunner;
+
+/**
+ * Represents a pending asynchronous WebGPU operation that can be converted into
+ * a JavaScript Promise.
+ */
+class AsyncTaskHandle {
+public:
+  struct State;
+
+  using ValueFactory =
+      std::function<facebook::jsi::Value(facebook::jsi::Runtime &)>;
+  using ResolveFunction = std::function<void(ValueFactory)>;
+  using RejectFunction = std::function<void(std::string)>;
+
+  AsyncTaskHandle();
+
+  /**
+   * Internal constructor used by AsyncRunner.
+   */
+  explicit AsyncTaskHandle(std::shared_ptr<State> state);
+
+  bool valid() const;
+
+  ResolveFunction createResolveFunction() const;
+  RejectFunction createRejectFunction() const;
+
+  void attachPromise(const std::shared_ptr<rnwgpu::Promise> &promise) const;
+
+  static AsyncTaskHandle create(const std::shared_ptr<AsyncRunner> &runner,
+                                bool keepPumping);
+
+private:
+  std::shared_ptr<State> _state;
+};
+
+} // namespace rnwgpu::async

package/cpp/rnwgpu/async/JSIMicrotaskDispatcher.cpp

@@ -0,0 +1,23 @@
+#include "JSIMicrotaskDispatcher.h"
+
+#include <utility>
+
+namespace rnwgpu::async {
+
+JSIMicrotaskDispatcher::JSIMicrotaskDispatcher(jsi::Runtime &runtime)
+    : _runtime(runtime) {}
+
+void JSIMicrotaskDispatcher::post(Work work) {
+  auto microtask = jsi::Function::createFromHostFunction(
+      _runtime, jsi::PropNameID::forAscii(_runtime, "AsyncMicrotask"), 0,
+      [work = std::move(work)](
+          jsi::Runtime &runtime, const jsi::Value & /*thisValue*/,
+          const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
+        work(runtime);
+        return jsi::Value::undefined();
+      });
+
+  _runtime.queueMicrotask(std::move(microtask));
+}
+
+} // namespace rnwgpu::async

package/cpp/rnwgpu/async/JSIMicrotaskDispatcher.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "AsyncDispatcher.h"
+
+namespace rnwgpu::async {
+
+/**
+ * Dispatcher implementation backed by `jsi::Runtime::queueMicrotask`.
+ */
+class JSIMicrotaskDispatcher final
+    : public AsyncDispatcher,
+      public std::enable_shared_from_this<JSIMicrotaskDispatcher> {
+public:
+  explicit JSIMicrotaskDispatcher(jsi::Runtime &runtime);
+
+  void post(Work work) override;
+
+private:
+  jsi::Runtime &_runtime;
+};
+
+} // namespace rnwgpu::async