react-native-wgpu 0.2.10 → 0.3.0

package/cpp/jsi/RNFJSIConverter.h

@@ -24,11 +24,10 @@
 #include "RNFPromise.h"
 #include "RNFWorkletRuntimeRegistry.h"
 
-#include "Dispatcher.h"
-#include "ThreadPool.h"
-
 #include "Unions.h"
 
+#include "rnwgpu/async/AsyncTaskHandle.h"
+
 // This number is the maximum integer that can be represented exactly as a double
 #define MAX_SAFE_INTEGER static_cast<uint64_t>(9007199254740991)
 
@@ -207,62 +206,21 @@ template <typename TEnum> struct JSIConverter<TEnum, std::enable_if_t<std::is_en
   }
 };
 
-// std::future<T> <> Promise<T>
-template <typename TResult> struct JSIConverter<std::future<TResult>> {
-  static std::future<TResult> fromJSI(jsi::Runtime&, const jsi::Value&, bool outOfBound) {
-    throw std::runtime_error("Promise cannot be converted to a native type - it needs to be awaited first!");
-  }
-  static jsi::Value toJSI(jsi::Runtime& runtime, std::future<TResult>&& arg) {
-    auto sharedFuture = std::make_shared<std::future<TResult>>(std::move(arg));
-    std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
-    std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
-
-    return Promise::createPromise(runtime, [sharedFuture = std::move(sharedFuture), weakDispatcher](jsi::Runtime& runtime,
-                                                                                           std::shared_ptr<Promise> promise) {
-      // Spawn new async thread to synchronously wait for the `future<T>` to complete
-      std::shared_ptr<ThreadPool> pool = ThreadPool::getSharedPool();
-      pool->run([promise, &runtime, weakDispatcher, sharedFuture]() {
-        // synchronously wait until the `future<T>` completes. we are running on a background task here.
-        sharedFuture->wait();
-
-        std::shared_ptr<Dispatcher> dispatcher = weakDispatcher.lock();
-        if (!dispatcher) {
-          throw std::runtime_error("Tried resolving Promise on JS Thread, but the `Dispatcher` has already been destroyed!");
-          return;
-        }
-
-        dispatcher->runAsync([&runtime, promise, sharedFuture]() mutable {
-          try {
-            if constexpr (std::is_same_v<TResult, void>) {
-                // it's returning void, just return undefined to JS
-              sharedFuture->get();
-              promise->resolve(jsi::Value::undefined());
-            } else {
-              // it's returning a custom type, convert it to a jsi::Value
-              TResult result = sharedFuture->get();
-              jsi::Value jsResult = JSIConverter<TResult>::toJSI(runtime, result);
-              promise->resolve(std::move(jsResult));
-            }
-          } catch (const std::exception& exception) {
-            // the async function threw an error, reject the promise
-            std::string what = exception.what();
-            promise->reject(what);
-          } catch (...) {
-            // the async function threw a non-std error, try getting it
-    #if __has_include(<cxxabi.h>)
-            std::string name = __cxxabiv1::__cxa_current_exception_type()->name();
-    #else
-            std::string name = "<unknown>";
-    #endif
-            promise->reject("Unknown non-std exception: " + name);
-          }
-
-          // This lambda owns the promise shared pointer, and we need to call its
-          // destructor correctly here - otherwise it might be called
-          // from the threadPool thread.
-          promise = nullptr;
-        });
-      });
+// AsyncTaskHandle <> Promise
+template <> struct JSIConverter<rnwgpu::async::AsyncTaskHandle> {
+  static rnwgpu::async::AsyncTaskHandle fromJSI(jsi::Runtime&, const jsi::Value&, bool) {
+    throw std::runtime_error("Cannot convert a Promise to AsyncTaskHandle on the native side.");
+  }
+
+  static jsi::Value toJSI(jsi::Runtime& runtime, rnwgpu::async::AsyncTaskHandle&& handle) {
+    return Promise::createPromise(runtime, [handle = std::move(handle)](jsi::Runtime& runtime,
+                                                                        std::shared_ptr<Promise> promise) mutable {
+      if (!handle.valid()) {
+        promise->resolve(jsi::Value::undefined());
+        return;
+      }
+
+      handle.attachPromise(promise);
     });
   }
 };

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -1,7 +1,5 @@
 #include "RNWebGPUManager.h"
 
-#include "CallInvokerDispatcher.h"
-#include "Dispatcher.h"
 #include "GPU.h"
 #include "RNWebGPU.h"
 
@@ -24,13 +22,7 @@ RNWebGPUManager::RNWebGPUManager(
     : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker),
       _platformContext(platformContext) {
 
-  // Installs the global Dispatcher mechanism into this Runtime.
-  // This allows creating Promises and calling back to JS.
-  auto dispatcher =
-      std::make_shared<margelo::CallInvokerDispatcher>(_jsCallInvoker);
-  margelo::Dispatcher::installRuntimeGlobalDispatcher(*_jsRuntime, dispatcher);
-
-  auto gpu = std::make_shared<GPU>();
+  auto gpu = std::make_shared<GPU>(*_jsRuntime);
   auto rnWebGPU = std::make_shared<RNWebGPU>(gpu, _platformContext);
   _gpu = gpu->get();
   _jsRuntime->global().setProperty(

package/cpp/rnwgpu/api/GPU.cpp

@@ -8,16 +8,26 @@
 #include <vector>
 
 #include "Convertors.h"
+#include "RNFJSIConverter.h"
+#include "rnwgpu/async/JSIMicrotaskDispatcher.h"
 
 namespace rnwgpu {
 
-std::future<std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>>
-GPU::requestAdapter(
-    std::optional<std::shared_ptr<GPURequestAdapterOptions>> options) {
-  std::promise<std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>>
-      promise;
-  auto future = promise.get_future();
+GPU::GPU(jsi::Runtime &runtime) : HybridObject("GPU") {
+  static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
+  wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
+                                        .requiredFeatures = &kTimedWaitAny};
+
+  wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
+  instanceDesc.requiredLimits = &limits;
+  _instance = wgpu::CreateInstance(&instanceDesc);
+
+  auto dispatcher = std::make_shared<async::JSIMicrotaskDispatcher>(runtime);
+  _async = async::AsyncRunner::getOrCreate(runtime, _instance, dispatcher);
+}
 
+async::AsyncTaskHandle GPU::requestAdapter(
+    std::optional<std::shared_ptr<GPURequestAdapterOptions>> options) {
   wgpu::RequestAdapterOptions aOptions;
   Convertor conv;
   if (!conv(aOptions, options)) {
@@ -29,26 +39,41 @@ GPU::requestAdapter(
   constexpr auto kDefaultBackendType = wgpu::BackendType::Vulkan;
 #endif
   aOptions.backendType = kDefaultBackendType;
-  wgpu::Adapter adapter = nullptr;
-  _instance.RequestAdapter(
-      &aOptions, wgpu::CallbackMode::AllowSpontaneous,
-      [](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
-         wgpu::StringView message, wgpu::Adapter *userdata) {
-        if (message.length) {
-          fprintf(stderr, "%s", message.data);
-          return;
-        }
-        if (status == wgpu::RequestAdapterStatus::Success) {
-          *userdata = std::move(adapter);
-        }
-      },
-      &adapter);
-  if (!adapter) {
-    promise.set_value(nullptr);
-  } else {
-    promise.set_value(std::make_shared<GPUAdapter>(std::move(adapter), _async));
-  }
-  return future;
+  return _async->postTask(
+      [this, aOptions](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                       const async::AsyncTaskHandle::RejectFunction &reject) {
+        _instance.RequestAdapter(
+            &aOptions, wgpu::CallbackMode::AllowProcessEvents,
+            [asyncRunner = _async, resolve,
+             reject](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
+                     wgpu::StringView message) {
+              if (message.length) {
+                fprintf(stderr, "%s", message.data);
+              }
+
+              if (status == wgpu::RequestAdapterStatus::Success && adapter) {
+                auto adapterHost = std::make_shared<GPUAdapter>(
+                    std::move(adapter), asyncRunner);
+                auto result =
+                    std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>(
+                        adapterHost);
+                resolve([result =
+                             std::move(result)](jsi::Runtime &runtime) mutable {
+                  return margelo::JSIConverter<decltype(result)>::toJSI(runtime,
+                                                                        result);
+                });
+              } else {
+                auto result =
+                    std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>(
+                        nullptr);
+                resolve([result =
+                             std::move(result)](jsi::Runtime &runtime) mutable {
+                  return margelo::JSIConverter<decltype(result)>::toJSI(runtime,
+                                                                        result);
+                });
+              }
+            });
+      });
 }
 
 std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {

package/cpp/rnwgpu/api/GPU.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <future>
 #include <memory>
 #include <string>
 #include <unordered_set>
@@ -10,9 +9,9 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
 
-#include "dawn/dawn_proc.h"
 #include "dawn/native/DawnNative.h"
 #include "webgpu/webgpu_cpp.h"
 
@@ -27,24 +26,12 @@ namespace m = margelo;
 
 class GPU : public m::HybridObject {
 public:
-  GPU() : HybridObject("GPU") {
-    static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
-    wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
-                                          .requiredFeatures = &kTimedWaitAny};
-
-    // For limits:
-    wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
-    instanceDesc.requiredLimits = &limits;
-    _instance = wgpu::CreateInstance(&instanceDesc);
-    auto instance = &_instance;
-    _async = std::make_shared<AsyncRunner>(instance);
-  }
+  explicit GPU(jsi::Runtime &runtime);
 
 public:
   std::string getBrand() { return _name; }
 
-  std::future<std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>>
-  requestAdapter(
+  async::AsyncTaskHandle requestAdapter(
       std::optional<std::shared_ptr<GPURequestAdapterOptions>> options);
   wgpu::TextureFormat getPreferredCanvasFormat();
 
@@ -63,7 +50,7 @@ public:
 
 private:
   wgpu::Instance _instance;
-  std::shared_ptr<AsyncRunner> _async;
+  std::shared_ptr<async::AsyncRunner> _async;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -10,25 +10,25 @@
 #include "Convertors.h"
 
 #include "GPUFeatures.h"
+#include "RNFJSIConverter.h"
 #include "WGPULogger.h"
 
 namespace rnwgpu {
 
-std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
+async::AsyncTaskHandle GPUAdapter::requestDevice(
     std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor) {
-  std::promise<std::shared_ptr<GPUDevice>> promise;
-  auto future = promise.get_future();
-  wgpu::Device device = nullptr;
   wgpu::DeviceDescriptor aDescriptor;
   Convertor conv;
   if (!conv(aDescriptor, descriptor)) {
     throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
   }
+  auto deviceLostBinding = std::make_shared<std::weak_ptr<GPUDevice>>();
   // Set device lost callback using new template API
   aDescriptor.SetDeviceLostCallback(
       wgpu::CallbackMode::AllowSpontaneous,
-      [](const wgpu::Device &device, wgpu::DeviceLostReason reason,
-         wgpu::StringView message) {
+      [deviceLostBinding](const wgpu::Device & /*device*/,
+                          wgpu::DeviceLostReason reason,
+                          wgpu::StringView message) {
         const char *lostReason = "";
         switch (reason) {
         case wgpu::DeviceLostReason::Destroyed:
@@ -40,8 +40,13 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
         default:
           lostReason = "Unknown";
         }
+        std::string msg =
+            message.length ? std::string(message.data, message.length) : "";
         Logger::logToConsole("GPU Device Lost (%s): %s", lostReason,
-                             message.data);
+                             msg.c_str());
+        if (auto deviceHost = deviceLostBinding->lock()) {
+          deviceHost->notifyDeviceLost(reason, std::move(msg));
+        }
       });
 
   // Set uncaptured error callback using new template API
@@ -71,55 +76,71 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
                            : "no message";
     fprintf(stderr, "%s", fullMessage.c_str());
   });
-  _instance.RequestDevice(
-      &aDescriptor, wgpu::CallbackMode::AllowSpontaneous,
-      [](wgpu::RequestDeviceStatus status, wgpu::Device device,
-         wgpu::StringView message, wgpu::Device *userdata) {
-        if (message.length) {
-          fprintf(stderr, "%s", message.data);
-          return;
-        }
-        if (status == wgpu::RequestDeviceStatus::Success) {
-          *userdata = std::move(device);
-        }
-      },
-      &device);
-
-  if (!device) {
-    throw std::runtime_error("Failed to request device");
-  }
-  device.SetLoggingCallback(
-      [creationRuntime = _creationRuntime](wgpu::LoggingType type,
-                                           wgpu::StringView message) {
-        const char *logLevel = "";
-        switch (type) {
-        case wgpu::LoggingType::Warning:
-          logLevel = "Warning";
-          Logger::warnToJavascriptConsole(
-              *creationRuntime, std::string(message.data, message.length));
-          break;
-        case wgpu::LoggingType::Error:
-          logLevel = "Error";
-          Logger::errorToJavascriptConsole(
-              *creationRuntime, std::string(message.data, message.length));
-          break;
-        case wgpu::LoggingType::Verbose:
-          logLevel = "Verbose";
-          break;
-        case wgpu::LoggingType::Info:
-          logLevel = "Info";
-          break;
-        default:
-          logLevel = "Unknown";
-          Logger::logToConsole("%s: %.*s", logLevel,
-                               static_cast<int>(message.length), message.data);
-        }
-      });
   std::string label =
       descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
-  promise.set_value(
-      std::make_shared<GPUDevice>(std::move(device), _async, label));
-  return future;
+
+  return _async->postTask(
+      [this, aDescriptor, descriptor, label = std::move(label),
+       deviceLostBinding](
+          const async::AsyncTaskHandle::ResolveFunction &resolve,
+          const async::AsyncTaskHandle::RejectFunction &reject) {
+        (void)descriptor;
+        _instance.RequestDevice(
+            &aDescriptor, wgpu::CallbackMode::AllowProcessEvents,
+            [asyncRunner = _async, resolve, reject, label,
+             creationRuntime = _creationRuntime, deviceLostBinding](
+                wgpu::RequestDeviceStatus status, wgpu::Device device,
+                wgpu::StringView message) mutable {
+              if (message.length) {
+                fprintf(stderr, "%s", message.data);
+              }
+
+              if (status != wgpu::RequestDeviceStatus::Success || !device) {
+                std::string error =
+                    message.length ? std::string(message.data, message.length)
+                                   : "Failed to request device";
+                reject(std::move(error));
+                return;
+              }
+
+              device.SetLoggingCallback([creationRuntime](
+                                            wgpu::LoggingType type,
+                                            wgpu::StringView msg) {
+                const char *logLevel = "";
+                switch (type) {
+                case wgpu::LoggingType::Warning:
+                  logLevel = "Warning";
+                  Logger::warnToJavascriptConsole(
+                      *creationRuntime, std::string(msg.data, msg.length));
+                  break;
+                case wgpu::LoggingType::Error:
+                  logLevel = "Error";
+                  Logger::errorToJavascriptConsole(
+                      *creationRuntime, std::string(msg.data, msg.length));
+                  break;
+                case wgpu::LoggingType::Verbose:
+                  logLevel = "Verbose";
+                  break;
+                case wgpu::LoggingType::Info:
+                  logLevel = "Info";
+                  break;
+                default:
+                  logLevel = "Unknown";
+                  Logger::logToConsole("%s: %.*s", logLevel,
+                                       static_cast<int>(msg.length), msg.data);
+                }
+              });
+
+              auto deviceHost = std::make_shared<GPUDevice>(std::move(device),
+                                                            asyncRunner, label);
+              *deviceLostBinding = deviceHost;
+              resolve([deviceHost = std::move(deviceHost)](
+                          jsi::Runtime &runtime) mutable {
+                return margelo::JSIConverter<std::shared_ptr<GPUDevice>>::toJSI(
+                    runtime, deviceHost);
+              });
+            });
+      });
 }
 
 std::unordered_set<std::string> GPUAdapter::getFeatures() {

package/cpp/rnwgpu/api/GPUAdapter.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <future>
 #include <memory>
 #include <string>
 #include <unordered_set>
@@ -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,13 +25,13 @@ namespace m = margelo;
 class GPUAdapter : public m::HybridObject {
 public:
   explicit GPUAdapter(wgpu::Adapter instance,
-                      std::shared_ptr<AsyncRunner> async)
+                      std::shared_ptr<async::AsyncRunner> async)
       : HybridObject("GPUAdapter"), _instance(instance), _async(async) {}
 
 public:
   std::string getBrand() { return _name; }
 
-  std::future<std::shared_ptr<GPUDevice>>
+  async::AsyncTaskHandle
   requestDevice(std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor);
 
   std::unordered_set<std::string> getFeatures();
@@ -50,7 +50,7 @@ public:
 
 private:
   wgpu::Adapter _instance;
-  std::shared_ptr<AsyncRunner> _async;
+  std::shared_ptr<async::AsyncRunner> _async;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapterInfo.h

@@ -7,7 +7,6 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
 #include "Convertors.h"
 
 #include "webgpu/webgpu_cpp.h"

package/cpp/rnwgpu/api/GPUBindGroup.h

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

package/cpp/rnwgpu/api/GPUBindGroupLayout.h

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

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -37,9 +37,9 @@ GPUBuffer::getMappedRange(std::optional<size_t> o, std::optional<size_t> size) {
 
 void GPUBuffer::destroy() { _instance.Destroy(); }
 
-std::future<void> GPUBuffer::mapAsync(uint64_t modeIn,
-                                      std::optional<uint64_t> offset,
-                                      std::optional<uint64_t> size) {
+async::AsyncTaskHandle GPUBuffer::mapAsync(uint64_t modeIn,
+                                           std::optional<uint64_t> offset,
+                                           std::optional<uint64_t> size) {
   Convertor conv;
   wgpu::MapMode mode;
   if (!conv(mode, modeIn)) {
@@ -48,35 +48,38 @@ std::future<void> GPUBuffer::mapAsync(uint64_t modeIn,
   uint64_t rangeSize = size.has_value()
                            ? size.value()
                            : (_instance.GetSize() - offset.value_or(0));
-  return _async->runAsync([=] {
-    // for (auto& mapping : mappings) {
-    //   if (mapping.Intersects(start, end)) {
-    //     promise.set_exception(std::make_exception_ptr(std::runtime_error("Buffer
-    //     is already mapped"))); return future;
-    //   }
-    // }
-    return _instance.MapAsync(
-        mode, offset.value_or(0), rangeSize, wgpu::CallbackMode::WaitAnyOnly,
-        [](wgpu::MapAsyncStatus status, wgpu::StringView message) {
-          switch (status) {
-          case wgpu::MapAsyncStatus::Success:
-            break;
-          case wgpu::MapAsyncStatus::CallbackCancelled:
-            throw std::runtime_error("MapAsyncStatus::CallbackCancelled");
-            break;
-          case wgpu::MapAsyncStatus::Error:
-            throw std::runtime_error("MapAsyncStatus::Error");
-            break;
-          case wgpu::MapAsyncStatus::Aborted:
-            throw std::runtime_error("MapAsyncStatus::Aborted");
-            break;
-          default:
-            throw std::runtime_error("MapAsyncStatus: " +
-                                     std::to_string(static_cast<int>(status)));
-            break;
-          }
-        });
-  });
+  auto bufferHandle = _instance;
+  uint64_t resolvedOffset = offset.value_or(0);
+
+  return _async->postTask(
+      [bufferHandle, mode, resolvedOffset,
+       rangeSize](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                  const async::AsyncTaskHandle::RejectFunction &reject) {
+        bufferHandle.MapAsync(mode, resolvedOffset, rangeSize,
+                              wgpu::CallbackMode::AllowProcessEvents,
+                              [resolve, reject](wgpu::MapAsyncStatus status,
+                                                wgpu::StringView message) {
+                                switch (status) {
+                                case wgpu::MapAsyncStatus::Success:
+                                  resolve(nullptr);
+                                  break;
+                                case wgpu::MapAsyncStatus::CallbackCancelled:
+                                  reject("MapAsyncStatus::CallbackCancelled");
+                                  break;
+                                case wgpu::MapAsyncStatus::Error:
+                                  reject("MapAsyncStatus::Error");
+                                  break;
+                                case wgpu::MapAsyncStatus::Aborted:
+                                  reject("MapAsyncStatus::Aborted");
+                                  break;
+                                default:
+                                  reject(
+                                      "MapAsyncStatus: " +
+                                      std::to_string(static_cast<int>(status)));
+                                  break;
+                                }
+                              });
+      });
 }
 
 void GPUBuffer::unmap() { _instance.Unmap(); }

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <future>
 #include <memory>
 #include <optional>
 #include <string>
@@ -10,7 +9,8 @@
 
 #include "RNFHybridObject.h"
 
-#include "AsyncRunner.h"
+#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/AsyncTaskHandle.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -22,7 +22,8 @@ namespace m = margelo;
 
 class GPUBuffer : public m::HybridObject {
 public:
-  explicit GPUBuffer(wgpu::Buffer instance, std::shared_ptr<AsyncRunner> async,
+  explicit GPUBuffer(wgpu::Buffer instance,
+                     std::shared_ptr<async::AsyncRunner> async,
                      std::string label)
       : HybridObject("GPUBuffer"), _instance(instance), _async(async),
         _label(label) {}
@@ -30,8 +31,9 @@ public:
 public:
   std::string getBrand() { return _name; }
 
-  std::future<void> mapAsync(uint64_t modeIn, std::optional<uint64_t> offset,
-                             std::optional<uint64_t> size);
+  async::AsyncTaskHandle mapAsync(uint64_t modeIn,
+                                  std::optional<uint64_t> offset,
+                                  std::optional<uint64_t> size);
   std::shared_ptr<ArrayBuffer> getMappedRange(std::optional<size_t> offset,
                                               std::optional<size_t> size);
   void unmap();
@@ -66,7 +68,7 @@ public:
 
 private:
   wgpu::Buffer _instance;
-  std::shared_ptr<AsyncRunner> _async;
+  std::shared_ptr<async::AsyncRunner> _async;
   std::string _label;
   struct Mapping {
     uint64_t start;
@@ -79,4 +81,4 @@ private:
   std::vector<Mapping> mappings;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -4,7 +4,11 @@
 #include <memory>
 
 #ifdef __APPLE__
-#include "dawn/native/MetalBackend.h"
+namespace dawn::native::metal {
+
+void WaitForCommandsToBeScheduled(WGPUDevice device);
+
+}
 #endif
 
 namespace rnwgpu {