react-native-wgpu 0.5.13 → 0.5.14

package/cpp/rnwgpu/async/AsyncDispatcher.h

@@ -1,28 +0,0 @@
-#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

@@ -1,215 +0,0 @@
-#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

@@ -1,53 +0,0 @@
-#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

@@ -1,181 +0,0 @@
-#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

@@ -1,55 +0,0 @@
-#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

@@ -1,23 +0,0 @@
-#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

@@ -1,22 +0,0 @@
-#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