react-native-wgpu 0.2.10 → 0.3.0

package/cpp/rnwgpu/api/GPUQueue.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <future>
 #include <memory>
 #include <string>
 #include <vector>
@@ -9,7 +8,8 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -25,7 +25,8 @@ namespace m = margelo;
 
 class GPUQueue : public m::HybridObject {
 public:
-  explicit GPUQueue(wgpu::Queue instance, std::shared_ptr<AsyncRunner> async,
+  explicit GPUQueue(wgpu::Queue instance,
+                    std::shared_ptr<async::AsyncRunner> async,
                     std::string label)
       : HybridObject("GPUQueue"), _instance(instance), _async(async),
         _label(label) {}
@@ -34,7 +35,7 @@ public:
   std::string getBrand() { return _name; }
 
   void submit(std::vector<std::shared_ptr<GPUCommandBuffer>> commandBuffers);
-  std::future<void> onSubmittedWorkDone();
+  async::AsyncTaskHandle onSubmittedWorkDone();
   void writeBuffer(std::shared_ptr<GPUBuffer> buffer, uint64_t bufferOffset,
                    std::shared_ptr<ArrayBuffer> data,
                    std::optional<uint64_t> dataOffsetElements,
@@ -72,8 +73,8 @@ public:
 
 private:
   wgpu::Queue _instance;
-  std::shared_ptr<AsyncRunner> _async;
+  std::shared_ptr<async::AsyncRunner> _async;
   std::string _label;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderBundle.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/GPURenderBundleEncoder.h

@@ -10,8 +10,6 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
-
 #include "webgpu/webgpu_cpp.h"
 
 #include "GPUBindGroup.h"
@@ -106,4 +104,4 @@ private:
   std::string _label;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPassEncoder.h

@@ -10,8 +10,6 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
-
 #include "webgpu/webgpu_cpp.h"
 
 #include "GPUBindGroup.h"
@@ -127,4 +125,4 @@ private:
   std::string _label;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPipeline.h

@@ -7,8 +7,6 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
-
 #include "webgpu/webgpu_cpp.h"
 
 #include "GPUBindGroupLayout.h"
@@ -58,4 +56,4 @@ private:
   friend class GPUDevice;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

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