react-native-wgpu 0.2.10 → 0.3.0

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -10,8 +10,6 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
-
 #include "Canvas.h"
 #include "GPU.h"
 #include "GPUCanvasConfiguration.h"

package/cpp/rnwgpu/api/GPUCommandBuffer.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/GPUCommandEncoder.h

@@ -7,8 +7,6 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
-
 #include "webgpu/webgpu_cpp.h"
 
 #include "GPUBuffer.h"
@@ -107,4 +105,4 @@ private:
   std::string _label;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCompilationInfo.h

@@ -7,8 +7,6 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
-
 #include "webgpu/webgpu_cpp.h"
 
 namespace rnwgpu {

package/cpp/rnwgpu/api/GPUCompilationMessage.h

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

package/cpp/rnwgpu/api/GPUComputePassEncoder.h

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

package/cpp/rnwgpu/api/GPUComputePipeline.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/GPUDevice.cpp

@@ -3,14 +3,43 @@
 #include <memory>
 #include <string>
 #include <unordered_set>
+#include <utility>
 #include <vector>
 
 #include "Convertors.h"
+#include "RNFJSIConverter.h"
 
 #include "GPUFeatures.h"
 
 namespace rnwgpu {
 
+void GPUDevice::notifyDeviceLost(wgpu::DeviceLostReason reason,
+                                 std::string message) {
+  if (_lostSettled) {
+    return;
+  }
+
+  _lostSettled = true;
+  _lostInfo = std::make_shared<GPUDeviceLostInfo>(reason, std::move(message));
+
+  if (_lostResolve.has_value()) {
+    auto resolve = std::move(*_lostResolve);
+    _lostResolve.reset();
+    resolve([info = _lostInfo](jsi::Runtime &runtime) mutable {
+      return margelo::JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
+          runtime, info);
+    });
+  }
+
+  _lostHandle.reset();
+}
+
+void GPUDevice::forceLossForTesting() {
+  // wgpu::StringView view("forceLossForTesting invoked from JS");
+  _instance.ForceLoss(wgpu::DeviceLostReason::Unknown,
+                      "forceLossForTesting invoked from JS");
+}
+
 std::shared_ptr<GPUBuffer>
 GPUDevice::createBuffer(std::shared_ptr<GPUBufferDescriptor> descriptor) {
   wgpu::BufferDescriptor desc;
@@ -52,9 +81,7 @@ std::shared_ptr<GPUCommandEncoder> GPUDevice::createCommandEncoder(
 
 void GPUDevice::destroy() {
   _instance.Destroy();
-  auto lostInfo = std::make_shared<GPUDeviceLostInfo>(
-      wgpu::DeviceLostReason::Destroyed, "device was destroyed");
-  m_lostPromise->set_value(lostInfo);
+  notifyDeviceLost(wgpu::DeviceLostReason::Destroyed, "device was destroyed");
 }
 
 std::shared_ptr<GPUTexture>
@@ -208,139 +235,135 @@ std::shared_ptr<GPUExternalTexture> GPUDevice::importExternalTexture(
       "GPUDevice::importExternalTexture(): Not implemented");
 }
 
-std::future<std::shared_ptr<GPUComputePipeline>>
-GPUDevice::createComputePipelineAsync(
+async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
     std::shared_ptr<GPUComputePipelineDescriptor> descriptor) {
-  return _async->runAsync([=](wgpu::Instance *instance) {
-    wgpu::ComputePipelineDescriptor desc{};
-    Convertor conv;
-    if (!conv(desc, descriptor)) {
-      throw std::runtime_error("GPUDevice::createComputePipeline(): Error with "
-                               "GPUComputePipelineDescriptor");
-    }
-    wgpu::ComputePipeline computePipeline = nullptr;
-    auto label = std::string(
-        descriptor->label.has_value() ? descriptor->label.value() : "");
-    auto result = std::make_shared<GPUComputePipeline>(computePipeline, label);
-    auto future = _instance.CreateComputePipelineAsync(
-        &desc, wgpu::CallbackMode::WaitAnyOnly,
-        [&result](wgpu::CreatePipelineAsyncStatus status,
-                  wgpu::ComputePipeline pipeline, char const *msg) {
-          switch (status) {
-          case wgpu::CreatePipelineAsyncStatus::Success:
-            result->_instance = pipeline;
-            break;
-          default:
-            throw std::runtime_error(msg);
-            break;
-          }
-        });
-    instance->WaitAny(future, UINT64_MAX);
-    return result;
-  });
+  wgpu::ComputePipelineDescriptor desc{};
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error("GPUDevice::createComputePipeline(): Error with "
+                             "GPUComputePipelineDescriptor");
+  }
+
+  auto label = std::string(
+      descriptor->label.has_value() ? descriptor->label.value() : "");
+  auto pipelineHolder = std::make_shared<GPUComputePipeline>(nullptr, label);
+
+  return _async->postTask(
+      [device = _instance, desc, descriptor,
+       pipelineHolder](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                       const async::AsyncTaskHandle::RejectFunction &reject) {
+        (void)descriptor;
+        device.CreateComputePipelineAsync(
+            &desc, wgpu::CallbackMode::AllowProcessEvents,
+            [pipelineHolder, resolve,
+             reject](wgpu::CreatePipelineAsyncStatus status,
+                     wgpu::ComputePipeline pipeline, const char *msg) mutable {
+              if (status == wgpu::CreatePipelineAsyncStatus::Success &&
+                  pipeline) {
+                pipelineHolder->_instance = pipeline;
+                resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
+                  return margelo::
+                      JSIConverter<std::shared_ptr<GPUComputePipeline>>::toJSI(
+                          runtime, pipelineHolder);
+                });
+              } else {
+                std::string error = msg ? std::string(msg)
+                                        : "Failed to create compute pipeline";
+                reject(std::move(error));
+              }
+            });
+      });
 }
 
-std::future<std::shared_ptr<GPURenderPipeline>>
-GPUDevice::createRenderPipelineAsync(
+async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
     std::shared_ptr<GPURenderPipelineDescriptor> descriptor) {
-  return _async->runAsync([=](wgpu::Instance *instance) {
-    wgpu::RenderPipelineDescriptor desc{};
-    Convertor conv;
-    if (!conv(desc, descriptor)) {
-      throw std::runtime_error(
-          "GPUDevice::createRenderPipelineAsync(): Error with "
-          "GPURenderPipelineDescriptor");
-    }
-    wgpu::RenderPipeline renderPipeline = nullptr;
-    auto label = std::string(
-        descriptor->label.has_value() ? descriptor->label.value() : "");
-    auto result = std::make_shared<GPURenderPipeline>(renderPipeline, label);
-    auto future = _instance.CreateRenderPipelineAsync(
-        &desc, wgpu::CallbackMode::WaitAnyOnly,
-        [&result](wgpu::CreatePipelineAsyncStatus status,
-                  wgpu::RenderPipeline pipeline, char const *msg) {
-          switch (status) {
-          case wgpu::CreatePipelineAsyncStatus::Success:
-            result->_instance = pipeline;
-            break;
-          default:
-            throw std::runtime_error(msg);
-            break;
-          }
-        });
-    instance->WaitAny(future, UINT64_MAX);
-    return result;
-  });
+  wgpu::RenderPipelineDescriptor desc{};
+  Convertor conv;
+  if (!conv(desc, descriptor)) {
+    throw std::runtime_error(
+        "GPUDevice::createRenderPipelineAsync(): Error with "
+        "GPURenderPipelineDescriptor");
+  }
+
+  auto label = std::string(
+      descriptor->label.has_value() ? descriptor->label.value() : "");
+  auto pipelineHolder = std::make_shared<GPURenderPipeline>(nullptr, label);
+
+  return _async->postTask(
+      [device = _instance, desc, descriptor,
+       pipelineHolder](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                       const async::AsyncTaskHandle::RejectFunction &reject) {
+        (void)descriptor;
+        device.CreateRenderPipelineAsync(
+            &desc, wgpu::CallbackMode::AllowProcessEvents,
+            [pipelineHolder, resolve,
+             reject](wgpu::CreatePipelineAsyncStatus status,
+                     wgpu::RenderPipeline pipeline, const char *msg) mutable {
+              if (status == wgpu::CreatePipelineAsyncStatus::Success &&
+                  pipeline) {
+                pipelineHolder->_instance = pipeline;
+                resolve([pipelineHolder](jsi::Runtime &runtime) mutable {
+                  return margelo::
+                      JSIConverter<std::shared_ptr<GPURenderPipeline>>::toJSI(
+                          runtime, pipelineHolder);
+                });
+              } else {
+                std::string error =
+                    msg ? std::string(msg) : "Failed to create render pipeline";
+                reject(std::move(error));
+              }
+            });
+      });
 }
 
 void GPUDevice::pushErrorScope(wgpu::ErrorFilter filter) {
   _instance.PushErrorScope(filter);
 }
 
-std::future<std::variant<std::nullptr_t, std::shared_ptr<GPUError>>>
-GPUDevice::popErrorScope() {
-  // Create a promise to return a future, but do the work synchronously on main
-  // thread
-  auto promise = std::make_shared<
-      std::promise<std::variant<std::nullptr_t, std::shared_ptr<GPUError>>>>();
-  auto future = promise->get_future();
-
-  std::variant<std::nullptr_t, std::shared_ptr<GPUError>> result = nullptr;
-
-  auto wgpu_future = _instance.PopErrorScope(
-      wgpu::CallbackMode::WaitAnyOnly,
-      [&result](wgpu::PopErrorScopeStatus status, wgpu::ErrorType type,
-                wgpu::StringView message) {
-        switch (status) {
-        case wgpu::PopErrorScopeStatus::Error:
-          // PopErrorScope itself failed, e.g. the error scope stack was empty.
-          return;
-        case wgpu::PopErrorScopeStatus::CallbackCancelled:
-          // The instance has been dropped. Shouldn't happen except maybe during
-          // shutdown.
-          return;
-        case wgpu::PopErrorScopeStatus::Success:
-          // This is the only case where `type` is set to a meaningful value.
-          break;
-        }
-        switch (type) {
-        case wgpu::ErrorType::NoError:
-          break;
-        case wgpu::ErrorType::OutOfMemory: {
-          result = std::make_shared<GPUError>(wgpu::ErrorType::OutOfMemory,
-                                              std::string(message));
-          break;
-        }
-        case wgpu::ErrorType::Validation: {
-          result = std::make_shared<GPUError>(wgpu::ErrorType::Validation,
-                                              std::string(message));
-          break;
-        }
-        case wgpu::ErrorType::Internal: {
-          result = std::make_shared<GPUError>(wgpu::ErrorType::Internal,
-                                              std::string(message));
-          break;
-        }
-        case wgpu::ErrorType::Unknown:
-          result = std::make_shared<GPUError>(wgpu::ErrorType::Unknown,
-                                              std::string(message));
-          break;
-        default:
-          throw std::runtime_error(
-              "unhandled error type (" +
-              std::to_string(
-                  static_cast<std::underlying_type<wgpu::ErrorType>::type>(
-                      type)) +
-              ")");
-          break;
-        }
+async::AsyncTaskHandle GPUDevice::popErrorScope() {
+  auto device = _instance;
+
+  return _async->postTask(
+      [device](const async::AsyncTaskHandle::ResolveFunction &resolve,
+               const async::AsyncTaskHandle::RejectFunction &reject) {
+        device.PopErrorScope(
+            wgpu::CallbackMode::AllowProcessEvents,
+            [resolve, reject](wgpu::PopErrorScopeStatus status,
+                              wgpu::ErrorType type, wgpu::StringView message) {
+              if (status == wgpu::PopErrorScopeStatus::Error ||
+                  status == wgpu::PopErrorScopeStatus::CallbackCancelled) {
+                reject("PopErrorScope failed");
+                return;
+              }
+
+              std::variant<std::nullptr_t, std::shared_ptr<GPUError>> result =
+                  nullptr;
+
+              switch (type) {
+              case wgpu::ErrorType::NoError:
+                break;
+              case wgpu::ErrorType::OutOfMemory:
+              case wgpu::ErrorType::Validation:
+              case wgpu::ErrorType::Internal:
+              case wgpu::ErrorType::Unknown: {
+                std::string messageString =
+                    message.length ? std::string(message.data, message.length)
+                                   : "";
+                result = std::make_shared<GPUError>(type, messageString);
+                break;
+              }
+              default:
+                reject("Unhandled GPU error type");
+                return;
+              }
+
+              resolve([result =
+                           std::move(result)](jsi::Runtime &runtime) mutable {
+                return margelo::JSIConverter<decltype(result)>::toJSI(runtime,
+                                                                      result);
+              });
+            });
       });
-
-  // Wait synchronously on main thread - both push and pop now on same thread
-  _async->instance->WaitAny(wgpu_future, UINT64_MAX);
-
-  promise->set_value(result);
-  return future;
 }
 
 std::unordered_set<std::string> GPUDevice::getFeatures() {
@@ -356,8 +379,40 @@ std::unordered_set<std::string> GPUDevice::getFeatures() {
   return result;
 }
 
-std::future<std::shared_ptr<GPUDeviceLostInfo>> GPUDevice::getLost() {
-  return std::async(std::launch::async,
-                    [=]() { return m_lostSharedFuture->get(); });
+async::AsyncTaskHandle GPUDevice::getLost() {
+  if (_lostHandle.has_value()) {
+    return *_lostHandle;
+  }
+
+  if (_lostSettled && _lostInfo) {
+    return _async->postTask(
+        [info = _lostInfo](
+            const async::AsyncTaskHandle::ResolveFunction &resolve,
+            const async::AsyncTaskHandle::RejectFunction & /*reject*/) {
+          resolve([info](jsi::Runtime &runtime) mutable {
+            return margelo::JSIConverter<
+                std::shared_ptr<GPUDeviceLostInfo>>::toJSI(runtime, info);
+          });
+        },
+        false);
+  }
+
+  auto handle = _async->postTask(
+      [this](const async::AsyncTaskHandle::ResolveFunction &resolve,
+             const async::AsyncTaskHandle::RejectFunction & /*reject*/) {
+        if (_lostSettled && _lostInfo) {
+          resolve([info = _lostInfo](jsi::Runtime &runtime) mutable {
+            return margelo::JSIConverter<
+                std::shared_ptr<GPUDeviceLostInfo>>::toJSI(runtime, info);
+          });
+          return;
+        }
+
+        _lostResolve = resolve;
+      },
+      false);
+
+  _lostHandle = handle;
+  return handle;
 }
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDevice.h

@@ -1,16 +1,18 @@
 #pragma once
 
-#include <future>
 #include <memory>
+#include <optional>
 #include <string>
 #include <unordered_set>
+#include <utility>
 #include <variant>
 
 #include "Unions.h"
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -51,17 +53,11 @@ namespace m = margelo;
 
 class GPUDevice : public m::HybridObject {
 public:
-  explicit GPUDevice(wgpu::Device instance, std::shared_ptr<AsyncRunner> async,
+  explicit GPUDevice(wgpu::Device instance,
+                     std::shared_ptr<async::AsyncRunner> async,
                      std::string label)
       : HybridObject("GPUDevice"), _instance(instance), _async(async),
-        _label(label) {
-    m_lostPromise =
-        std::make_shared<std::promise<std::shared_ptr<GPUDeviceLostInfo>>>();
-
-    auto sharedFuture = m_lostPromise->get_future().share();
-    m_lostSharedFuture = std::make_shared<
-        std::shared_future<std::shared_ptr<GPUDeviceLostInfo>>>(sharedFuture);
-  }
+        _label(label) {}
 
 public:
   std::string getBrand() { return _name; }
@@ -87,9 +83,9 @@ public:
       std::shared_ptr<GPUComputePipelineDescriptor> descriptor);
   std::shared_ptr<GPURenderPipeline>
   createRenderPipeline(std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
-  std::future<std::shared_ptr<GPUComputePipeline>> createComputePipelineAsync(
+  async::AsyncTaskHandle createComputePipelineAsync(
       std::shared_ptr<GPUComputePipelineDescriptor> descriptor);
-  std::future<std::shared_ptr<GPURenderPipeline>> createRenderPipelineAsync(
+  async::AsyncTaskHandle createRenderPipelineAsync(
       std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
   std::shared_ptr<GPUCommandEncoder> createCommandEncoder(
       std::optional<std::shared_ptr<GPUCommandEncoderDescriptor>> descriptor);
@@ -98,13 +94,14 @@ public:
   std::shared_ptr<GPUQuerySet>
   createQuerySet(std::shared_ptr<GPUQuerySetDescriptor> descriptor);
   void pushErrorScope(wgpu::ErrorFilter filter);
-  std::future<std::variant<std::nullptr_t, std::shared_ptr<GPUError>>>
-  popErrorScope();
+  async::AsyncTaskHandle popErrorScope();
 
   std::unordered_set<std::string> getFeatures();
   std::shared_ptr<GPUSupportedLimits> getLimits();
   std::shared_ptr<GPUQueue> getQueue();
-  std::future<std::shared_ptr<GPUDeviceLostInfo>> getLost();
+  async::AsyncTaskHandle getLost();
+  void notifyDeviceLost(wgpu::DeviceLostReason reason, std::string message);
+  void forceLossForTesting();
 
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {
@@ -148,18 +145,22 @@ public:
     registerHybridGetter("lost", &GPUDevice::getLost, this);
     registerHybridGetter("label", &GPUDevice::getLabel, this);
     registerHybridSetter("label", &GPUDevice::setLabel, this);
+    registerHybridMethod("forceLossForTesting", &GPUDevice::forceLossForTesting,
+                         this);
   }
 
   inline const wgpu::Device get() { return _instance; }
 
 private:
+  friend class GPUAdapter;
+
   wgpu::Device _instance;
-  std::shared_ptr<AsyncRunner> _async;
+  std::shared_ptr<async::AsyncRunner> _async;
   std::string _label;
-  std::shared_ptr<std::promise<std::shared_ptr<GPUDeviceLostInfo>>>
-      m_lostPromise;
-  std::shared_ptr<std::shared_future<std::shared_ptr<GPUDeviceLostInfo>>>
-      m_lostSharedFuture;
+  std::optional<async::AsyncTaskHandle> _lostHandle;
+  std::shared_ptr<GPUDeviceLostInfo> _lostInfo;
+  bool _lostSettled = false;
+  std::optional<async::AsyncTaskHandle::ResolveFunction> _lostResolve;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDeviceLostInfo.h

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

package/cpp/rnwgpu/api/GPUExternalTexture.h

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

package/cpp/rnwgpu/api/GPUPipelineLayout.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/GPUQuerySet.h

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

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -78,14 +78,25 @@ void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
                         static_cast<size_t>(size64));
 }
 
-std::future<void> GPUQueue::onSubmittedWorkDone() {
-  return _async->runAsync([&] {
-    return _instance.OnSubmittedWorkDone(
-        wgpu::CallbackMode::WaitAnyOnly,
-        [](wgpu::QueueWorkDoneStatus status, wgpu::StringView message) {
-          // Handle the callback if needed
-        });
-  });
+async::AsyncTaskHandle GPUQueue::onSubmittedWorkDone() {
+  auto queue = _instance;
+  return _async->postTask(
+      [queue](const async::AsyncTaskHandle::ResolveFunction &resolve,
+              const async::AsyncTaskHandle::RejectFunction &reject) {
+        queue.OnSubmittedWorkDone(
+            wgpu::CallbackMode::AllowProcessEvents,
+            [resolve, reject](wgpu::QueueWorkDoneStatus status,
+                              wgpu::StringView message) {
+              if (status == wgpu::QueueWorkDoneStatus::Success) {
+                resolve(nullptr);
+              } else {
+                std::string error =
+                    message.length ? std::string(message.data, message.length)
+                                   : "Queue work did not complete successfully";
+                reject(std::move(error));
+              }
+            });
+      });
 }
 
 void GPUQueue::copyExternalImageToTexture(