react-native-wgpu 0.1.0

package/cpp/jsi/RNFRuntimeCache.cpp

@@ -0,0 +1,57 @@
+//
+// Created by Marc Rousavy on 22.02.24.
+//
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+#include "RNFRuntimeCache.h"
+
+namespace margelo {
+
+static std::unordered_map<jsi::Runtime*, std::unordered_set<RuntimeLifecycleListener*>> listeners;
+
+struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
+  jsi::Runtime* _rt;
+  explicit RuntimeLifecycleMonitorObject(jsi::Runtime* rt) : _rt(rt) {}
+  ~RuntimeLifecycleMonitorObject() {
+    auto listenersSet = listeners.find(_rt);
+    if (listenersSet != listeners.end()) {
+      for (auto listener : listenersSet->second) {
+        listener->onRuntimeDestroyed(_rt);
+      }
+      listeners.erase(listenersSet);
+    }
+  }
+};
+
+void RuntimeLifecycleMonitor::addListener(jsi::Runtime& rt, RuntimeLifecycleListener* listener) {
+  auto listenersSet = listeners.find(&rt);
+  if (listenersSet == listeners.end()) {
+    // We install a global host object in the provided runtime, this way we can
+    // use that host object destructor to get notified when the runtime is being
+    // terminated. We use a unique name for the object as it gets saved with the
+    // runtime's global object.
+    rt.global().setProperty(rt, "__rnfl_rt_lifecycle_monitor",
+                            jsi::Object::createFromHostObject(rt, std::make_shared<RuntimeLifecycleMonitorObject>(&rt)));
+    std::unordered_set<RuntimeLifecycleListener*> newSet;
+    newSet.insert(listener);
+    listeners.emplace(&rt, std::move(newSet));
+  } else {
+    listenersSet->second.insert(listener);
+  }
+}
+
+void RuntimeLifecycleMonitor::removeListener(jsi::Runtime& rt, RuntimeLifecycleListener* listener) {
+  auto listenersSet = listeners.find(&rt);
+  if (listenersSet == listeners.end()) {
+    // nothing to do here
+  } else {
+    listenersSet->second.erase(listener);
+  }
+}
+
+} // namespace margelo

package/cpp/jsi/RNFRuntimeCache.h

@@ -0,0 +1,79 @@
+//
+// Created by Marc Rousavy on 22.02.24.
+//
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+/**
+ * Listener interface that allows for getting notified when a jsi::Runtime
+ * instance is destroyed.
+ */
+struct RuntimeLifecycleListener {
+  virtual ~RuntimeLifecycleListener() {}
+  virtual void onRuntimeDestroyed(jsi::Runtime*) = 0;
+};
+
+/**
+ * This class provides an API via static methods for registering and
+ * unregistering runtime lifecycle listeners. The listeners can be used to
+ * cleanup any data that references a given jsi::Runtime instance before it gets
+ * destroyed.
+ */
+struct RuntimeLifecycleMonitor {
+  static void addListener(jsi::Runtime& rt, RuntimeLifecycleListener* listener);
+  static void removeListener(jsi::Runtime& rt, RuntimeLifecycleListener* listener);
+};
+
+/**
+ * Provides a way to keep data specific to a jsi::Runtime instance that gets
+ * cleaned up when that runtime is destroyed. This is necessary because JSI does
+ * not allow for its associated objects to be retained past the runtime
+ * lifetime. If an object (e.g. jsi::Values or jsi::Function instances) is kept
+ * after the runtime is torn down, its destructor (once it is destroyed
+ * eventually) will result in a crash (JSI objects keep a pointer to memory
+ * managed by the runtime, accessing that portion of the memory after runtime is
+ * deleted is the root cause of that crash).
+ */
+template <typename T> class RuntimeAwareCache : public RuntimeLifecycleListener {
+
+public:
+  void onRuntimeDestroyed(jsi::Runtime* rt) override {
+    // A runtime has been destroyed, so destroy the related cache.
+    _runtimeCaches.erase(rt);
+  }
+
+  ~RuntimeAwareCache() {
+    for (auto& cache : _runtimeCaches) {
+      // remove all `onRuntimeDestroyed` listeners.
+      RuntimeLifecycleMonitor::removeListener(*cache.first, this);
+    }
+  }
+
+  T& get(jsi::Runtime& rt) {
+    if (_runtimeCaches.count(&rt) == 0) {
+      // This is the first time this Runtime has been accessed.
+      // We set up a `onRuntimeDestroyed` listener for it and
+      // initialize the cache map.
+      RuntimeLifecycleMonitor::addListener(rt, this);
+
+      T cache;
+      _runtimeCaches.emplace(&rt, std::move(cache));
+    }
+    return _runtimeCaches.at(&rt);
+  }
+
+private:
+  std::unordered_map<jsi::Runtime*, T> _runtimeCaches;
+};
+
+} // namespace margelo

package/cpp/jsi/RNFWorkletRuntimeCollector.h

@@ -0,0 +1,43 @@
+//
+// Created by Marc Rousavy on 22.02.24.
+//
+#pragma once
+
+#include "RNFWorkletRuntimeRegistry.h"
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace margelo {
+
+// From:
+// https://github.com/software-mansion/react-native-reanimated/blob/6cb1a66f1a68cac8079de2b6b305d22359847e51/Common/cpp/ReanimatedRuntime/WorkletRuntimeCollector.h
+class WorkletRuntimeCollector : public jsi::HostObject {
+  // When worklet runtime is created, we inject an instance of this class as a
+  // `jsi::HostObject` into the global object. When worklet runtime is
+  // terminated, the object is garbage-collected, which runs the C++ destructor.
+  // In the destructor, we unregister the worklet runtime from the registry.
+
+public:
+  explicit WorkletRuntimeCollector(jsi::Runtime& runtime) : _runtime(runtime) {
+    Logger::log("WorkletRuntimeCollector", "Registering WorkletRuntime %p", &runtime);
+    RNFWorkletRuntimeRegistry::registerRuntime(_runtime);
+  }
+
+  ~WorkletRuntimeCollector() {
+    Logger::log("WorkletRuntimeCollector", "Unregistering WorkletRuntime %p", &_runtime);
+    RNFWorkletRuntimeRegistry::unregisterRuntime(_runtime);
+  }
+
+  static void install(jsi::Runtime& rt) {
+    auto collector = std::make_shared<WorkletRuntimeCollector>(rt);
+    auto object = jsi::Object::createFromHostObject(rt, collector);
+    rt.global().setProperty(rt, "__workletRuntimeCollector", object);
+  }
+
+private:
+  jsi::Runtime& _runtime;
+};
+
+} // namespace margelo

package/cpp/jsi/RNFWorkletRuntimeRegistry.cpp

@@ -0,0 +1,11 @@
+//
+// Created by Marc Rousavy on 22.02.24.
+//
+#include "RNFWorkletRuntimeRegistry.h"
+
+namespace margelo {
+
+std::set<jsi::Runtime*> RNFWorkletRuntimeRegistry::registry_{};
+std::mutex RNFWorkletRuntimeRegistry::mutex_{};
+
+} // namespace margelo

package/cpp/jsi/RNFWorkletRuntimeRegistry.h

@@ -0,0 +1,44 @@
+//
+// Created by Marc Rousavy on 22.02.24.
+//
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <mutex>
+#include <set>
+
+namespace jsi = facebook::jsi;
+
+namespace margelo {
+
+// From:
+// https://github.com/software-mansion/react-native-reanimated/blob/6cb1a66f1a68cac8079de2b6b305d22359847e51/Common/cpp/ReanimatedRuntime/WorkletRuntimeRegistry.h
+class RNFWorkletRuntimeRegistry {
+private:
+  static std::set<jsi::Runtime*> registry_;
+  static std::mutex mutex_; // Protects `registry_`.
+
+  RNFWorkletRuntimeRegistry() {} // private ctor
+
+  static void registerRuntime(jsi::Runtime& runtime) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    registry_.insert(&runtime);
+  }
+
+  static void unregisterRuntime(jsi::Runtime& runtime) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    registry_.erase(&runtime);
+  }
+
+  friend class WorkletRuntimeCollector;
+
+public:
+  static bool isRuntimeAlive(jsi::Runtime* runtime) {
+    assert(runtime != nullptr);
+    std::lock_guard<std::mutex> lock(mutex_);
+    return registry_.find(runtime) != registry_.end();
+  }
+};
+
+} // namespace margelo

package/cpp/rnwgpu/MutableBuffer.h

@@ -0,0 +1,48 @@
+#pragma once
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#include "RNFJSIConverter.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+struct MutableJSIBuffer : jsi::MutableBuffer {
+  MutableJSIBuffer(void *data, size_t size) : _data(data), _size(size) {}
+
+  size_t size() const override { return _size; }
+
+  uint8_t *data() override { return reinterpret_cast<uint8_t *>(_data); }
+
+  void *_data;
+  size_t _size;
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::MutableJSIBuffer>> {
+  static std::shared_ptr<rnwgpu::MutableJSIBuffer>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBound) {
+    if (!arg.getObject(runtime).isArrayBuffer(runtime)) {
+      throw std::runtime_error(
+          "Buffer::fromJSI: argument is not an ArrayBuffer");
+    }
+    auto data = arg.getObject(runtime).getArrayBuffer(runtime);
+    auto result = std::make_unique<rnwgpu::MutableJSIBuffer>(
+        data.data(runtime), data.size(runtime));
+    return result;
+  }
+
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::MutableJSIBuffer> arg) {
+    auto val = jsi::ArrayBuffer(runtime, arg);
+    auto d = val.data(runtime);
+    return val;
+  }
+};
+
+} // namespace margelo

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -0,0 +1,60 @@
+#include "RNWebGPUManager.h"
+
+#include "GPU.h"
+// Enums
+#include "GPUBufferUsage.h"
+#include "GPUColorWrite.h"
+#include "GPUMapMode.h"
+#include "GPUShaderStage.h"
+#include "GPUTextureUsage.h"
+
+#include <memory>
+#include <utility>
+
+namespace rnwgpu {
+RNWebGPUManager::RNWebGPUManager(
+    jsi::Runtime *jsRuntime,
+    std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker)
+    : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker) {
+
+  wgpu::InstanceDescriptor instanceDesc;
+  instanceDesc.features.timedWaitAnyEnable = true;
+  instanceDesc.features.timedWaitAnyMaxCount = 64;
+  auto gpu =
+      std::make_shared<GPU>(std::move(wgpu::CreateInstance(&instanceDesc)));
+
+  auto bufferUsage = std::make_shared<GPUBufferUsage>();
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "GPUBufferUsage",
+      jsi::Object::createFromHostObject(*_jsRuntime, std::move(bufferUsage)));
+
+  auto colorWrite = std::make_shared<GPUColorWrite>();
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "GPUColorWrite",
+      jsi::Object::createFromHostObject(*_jsRuntime, std::move(colorWrite)));
+
+  auto mapMode = std::make_shared<GPUMapMode>();
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "GPUMapMode",
+      jsi::Object::createFromHostObject(*_jsRuntime, std::move(mapMode)));
+
+  auto shaderStage = std::make_shared<GPUShaderStage>();
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "GPUShaderStage",
+      jsi::Object::createFromHostObject(*_jsRuntime, std::move(shaderStage)));
+
+  auto textureUsage = std::make_shared<GPUTextureUsage>();
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "GPUTextureUsage",
+      jsi::Object::createFromHostObject(*_jsRuntime, std::move(textureUsage)));
+
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "gpu",
+      jsi::Object::createFromHostObject(*_jsRuntime, std::move(gpu)));
+}
+
+RNWebGPUManager::~RNWebGPUManager() {
+  _jsRuntime = nullptr;
+  _jsCallInvoker = nullptr;
+}
+} // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+
+namespace facebook {
+namespace jsi {
+class Runtime;
+} // namespace jsi
+namespace react {
+class CallInvoker;
+}
+} // namespace facebook
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+class RNWebGPUManager {
+public:
+  RNWebGPUManager(jsi::Runtime *jsRuntime,
+                  std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker);
+  ~RNWebGPUManager();
+
+private:
+  jsi::Runtime *_jsRuntime;
+  std::shared_ptr<facebook::react::CallInvoker> _jsCallInvoker;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPU.cpp

@@ -0,0 +1,40 @@
+#include "GPU.h"
+#include <utility>
+
+namespace rnwgpu {
+
+std::future<std::shared_ptr<GPUAdapter>>
+GPU::requestAdapter(std::shared_ptr<GPURequestAdapterOptions> options) {
+  return std::async(std::launch::async, [this, options]() {
+    auto aOptions = options->getInstance();
+    wgpu::Adapter adapter = nullptr;
+    _instance.RequestAdapter(
+        aOptions,
+        [](WGPURequestAdapterStatus, WGPUAdapter cAdapter, const char *message,
+           void *userdata) {
+          if (message != nullptr) {
+            fprintf(stderr, "%s", message);
+            return;
+          }
+          *static_cast<wgpu::Adapter *>(userdata) =
+              wgpu::Adapter::Acquire(cAdapter);
+        },
+        &adapter);
+    // TODO: implement returning null jsi value
+    if (!adapter) {
+      throw std::runtime_error("Failed to request adapter");
+    }
+
+    return std::make_shared<GPUAdapter>(std::move(adapter));
+  });
+}
+
+wgpu::TextureFormat GPU::getPreferredCanvasFormat() {
+#if defined(__ANDROID__)
+  return wgpu::TextureFormat::RGBA8Unorm;
+#else
+  return wgpu::TextureFormat::BGRA8Unorm;
+#endif // defined(__ANDROID__)
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPU.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUAdapter.h"
+#include "GPURequestAdapterOptions.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPU : public m::HybridObject {
+public:
+  explicit GPU(wgpu::Instance instance)
+      : HybridObject("GPU"), _instance(instance) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::future<std::shared_ptr<GPUAdapter>>
+  requestAdapter(std::shared_ptr<GPURequestAdapterOptions> options);
+  wgpu::TextureFormat getPreferredCanvasFormat();
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPU::getBrand, this);
+    registerHybridMethod("requestAdapter", &GPU::requestAdapter, this);
+    registerHybridMethod("getPreferredCanvasFormat",
+                         &GPU::getPreferredCanvasFormat, this);
+  }
+
+private:
+  wgpu::Instance _instance;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -0,0 +1,33 @@
+// GPUAdapter.cpp
+
+#include "GPUAdapter.h"
+#include <utility>
+
+namespace rnwgpu {
+
+std::future<std::shared_ptr<GPUDevice>>
+GPUAdapter::requestDevice(std::shared_ptr<GPUDeviceDescriptor> descriptor) {
+  return std::async(std::launch::async, [this, descriptor]() {
+    wgpu::Device device = nullptr;
+    auto aDescriptor = descriptor->getInstance();
+    _instance.RequestDevice(
+        aDescriptor,
+        [](WGPURequestDeviceStatus status, WGPUDevice cDevice,
+           const char *message, void *userdata) {
+          if (message != nullptr) {
+            fprintf(stderr, "%s", message);
+            return;
+          }
+          *static_cast<wgpu::Device *>(userdata) =
+              wgpu::Device::Acquire(cDevice);
+        },
+        &device);
+
+    if (!device) {
+      throw std::runtime_error("Failed to request device");
+    }
+    return std::make_shared<GPUDevice>(std::move(device), descriptor->label);
+  });
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUDevice.h"
+#include "GPUDeviceDescriptor.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUAdapter : public m::HybridObject {
+public:
+  explicit GPUAdapter(wgpu::Adapter instance)
+      : HybridObject("GPUAdapter"), _instance(instance) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::future<std::shared_ptr<GPUDevice>>
+  requestDevice(std::shared_ptr<GPUDeviceDescriptor> options);
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUAdapter::getBrand, this);
+    registerHybridMethod("requestDevice", &GPUAdapter::requestDevice, this);
+  }
+
+private:
+  wgpu::Adapter _instance;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapterInfo.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUAdapterInfo : public m::HybridObject {
+public:
+  explicit GPUAdapterInfo(wgpu::AdapterInfo instance)
+      : HybridObject("GPUAdapterInfo"), _instance(instance) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUAdapterInfo::getBrand, this);
+  }
+
+private:
+  wgpu::AdapterInfo _instance;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBindGroup.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUBindGroup : public m::HybridObject {
+public:
+  explicit GPUBindGroup(wgpu::BindGroup instance, std::string label)
+      : HybridObject("GPUBindGroup"), _instance(instance), _label(label) {}
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUBindGroup::getBrand, this);
+
+    registerHybridGetter("label", &GPUBindGroup::getLabel, this);
+  }
+
+private:
+  wgpu::BindGroup _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBindGroupLayout.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+#include "Unions.h"
+#include <RNFHybridObject.h>
+
+#include "MutableBuffer.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace m = margelo;
+
+class GPUBindGroupLayout : public m::HybridObject {
+public:
+  explicit GPUBindGroupLayout(wgpu::BindGroupLayout instance, std::string label)
+      : HybridObject("GPUBindGroupLayout"), _instance(instance), _label(label) {
+  }
+
+public:
+  std::string getBrand() { return _name; }
+
+  std::string getLabel() { return _label; }
+
+  void loadHybridMethods() override {
+    registerHybridGetter("__brand", &GPUBindGroupLayout::getBrand, this);
+
+    registerHybridGetter("label", &GPUBindGroupLayout::getLabel, this);
+  }
+
+private:
+  wgpu::BindGroupLayout _instance;
+  std::string _label;
+};
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -0,0 +1,16 @@
+#include "GPUBuffer.h"
+
+namespace rnwgpu {
+
+std::shared_ptr<MutableJSIBuffer>
+GPUBuffer::getMappedRange(std::optional<size_t> offset,
+                          std::optional<size_t> size) {
+  auto aOffset = offset.value_or(0);
+  auto aSize = size.value_or(WGPU_WHOLE_MAP_SIZE);
+  auto result = _instance.GetMappedRange(aOffset, aSize);
+  return std::make_shared<MutableJSIBuffer>(result, _instance.GetSize());
+}
+
+void GPUBuffer::unmap() { _instance.Unmap(); }
+
+} // namespace rnwgpu