react-native-wgpu 0.4.1 → 0.5.0

package/cpp/jsi/RNFHybridObject.cpp

@@ -1,150 +0,0 @@
-//
-// Created by Marc Rousavy on 21.02.24.
-//
-#include "RNFHybridObject.h"
-#include "RNFJSIConverter.h"
-#include "WGPULogger.h"
-
-#include <unordered_map>
-#include <utility>
-#include <string>
-#include <vector>
-
-namespace margelo {
-
-#if DEBUG && RNF_ENABLE_LOGS
-static std::unordered_map<const char*, int> _instanceIds;
-static std::mutex _mutex;
-
-static int getId(const char* name) {
-  std::unique_lock lock(_mutex);
-  if (_instanceIds.find(name) == _instanceIds.end()) {
-    _instanceIds.insert({name, 1});
-  }
-  auto iterator = _instanceIds.find(name);
-  return iterator->second++;
-}
-#endif
-
-HybridObject::HybridObject(const char* name) : _name(name) {
-#if DEBUG && RNF_ENABLE_LOGS
-  _instanceId = getId(name);
-  Logger::logToConsole(TAG, "(MEMORY) Creating %s (#%i)... ✅", _name, _instanceId);
-#endif
-}
-
-HybridObject::~HybridObject() {
-#if DEBUG && RNF_ENABLE_LOGS
-  Logger::log(TAG, "(MEMORY) Deleting %s (#%i)... ❌", _name, _instanceId);
-#endif
-  _functionCache.clear();
-}
-
-std::string HybridObject::toString(jsi::Runtime& runtime) {
-  std::string result = std::string(_name) + " { ";
-  std::vector<jsi::PropNameID> props = getPropertyNames(runtime);
-  for (size_t i = 0; i < props.size(); i++) {
-    auto suffix = i < props.size() - 1 ? ", " : " ";
-    result += "\"" + props[i].utf8(runtime) + "\"" + suffix;
-  }
-  return result + "}";
-}
-
-std::vector<jsi::PropNameID> HybridObject::getPropertyNames(facebook::jsi::Runtime& runtime) {
-  std::unique_lock lock(_mutex);
-  ensureInitialized(runtime);
-
-  std::vector<jsi::PropNameID> result;
-  size_t totalSize = _methods.size() + _getters.size() + _setters.size();
-  result.reserve(totalSize);
-
-  for (const auto& item : _methods) {
-    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
-  }
-  for (const auto& item : _getters) {
-    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
-  }
-  for (const auto& item : _setters) {
-    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
-  }
-  return result;
-}
-
-jsi::Value HybridObject::get(facebook::jsi::Runtime& runtime, const facebook::jsi::PropNameID& propName) {
-  std::unique_lock lock(_mutex);
-  ensureInitialized(runtime);
-
-  std::string name = propName.utf8(runtime);
-  auto& functionCache = _functionCache[&runtime];
-
-  if (_getters.count(name) > 0) {
-    // it's a property getter
-    return _getters[name](runtime, jsi::Value::undefined(), nullptr, 0);
-  }
-
-  if (functionCache.count(name) > 0) {
-    [[likely]];
-    // cache hit
-    return jsi::Value(runtime, *functionCache[name]);
-  }
-
-  if (_methods.count(name) > 0) {
-    // cache miss - create jsi::Function and cache it.
-    HybridFunction& hybridFunction = _methods.at(name);
-    jsi::Function function = jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, name),
-                                                                   hybridFunction.parameterCount, hybridFunction.function);
-
-    functionCache[name] = JSIHelper::createSharedJsiFunction(runtime, std::move(function));
-    return jsi::Value(runtime, *functionCache[name]);
-  }
-
-  if (name == "toString") {
-    return jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "toString"), 0,
-        [=](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* args, size_t count) -> jsi::Value {
-          std::string stringRepresentation = this->toString(runtime);
-          return jsi::String::createFromUtf8(runtime, stringRepresentation);
-        });
-  }
-
-  return jsi::HostObject::get(runtime, propName);
-}
-
-void HybridObject::set(facebook::jsi::Runtime& runtime, const facebook::jsi::PropNameID& propName, const facebook::jsi::Value& value) {
-  std::unique_lock lock(_mutex);
-  ensureInitialized(runtime);
-
-  std::string name = propName.utf8(runtime);
-
-  if (_setters.count(name) > 0) {
-    // Call setter
-    _setters[name](runtime, jsi::Value::undefined(), &value, 1);
-    return;
-  }
-
-  HostObject::set(runtime, propName, value);
-}
-
-void HybridObject::ensureInitialized(facebook::jsi::Runtime& runtime) {
-  if (!_didLoadMethods) {
-    [[unlikely]];
-    _creationRuntime = &runtime;
-    _runtimeState = rnwgpu::RNFRuntimeState::get(runtime);
-    // lazy-load all exposed methods
-    loadHybridMethods();
-    _didLoadMethods = true;
-  }
-}
-
-bool HybridObject::isRuntimeAlive() {
-  return !_runtimeState.expired();
-}
-
-facebook::jsi::Runtime* HybridObject::getCreationRuntime() const {
-  if (_runtimeState.expired()) {
-    return nullptr;
-  }
-  return _creationRuntime;
-}
-
-} // namespace margelo

package/cpp/jsi/RNFHybridObject.h

@@ -1,181 +0,0 @@
-//
-// Created by Marc Rousavy on 21.02.24.
-//
-
-#pragma once
-
-#include "WGPULogger.h"
-#include "RNFRuntimeState.h"
-#include <functional>
-#include <jsi/jsi.h>
-#include <memory>
-#include <mutex>
-#include <type_traits>
-#include <unordered_map>
-#include <vector>
-#include <utility>
-#include <string>
-
-// Forward declare to avoid circular dependency
-namespace margelo {
-template <typename ArgType, typename SFINAE>
-struct JSIConverter;
-}
-
-// Include the converter - this must come after forward declaration
-#include "RNFJSIConverter.h"
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-
-class HybridObject : public jsi::HostObject, public std::enable_shared_from_this<HybridObject> {
-public:
-  struct HybridFunction {
-    jsi::HostFunctionType function;
-    size_t parameterCount;
-  };
-
-public:
-  explicit HybridObject(const char* name);
-  ~HybridObject();
-
-  void set(jsi::Runtime&, const jsi::PropNameID& name, const jsi::Value& value) override;
-  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override;
-
-  /**
-   * Get the `std::shared_ptr` instance of this HybridObject.
-   * The HybridObject must be managed inside a `shared_ptr` already, otherwise this will fail.
-   */
-  template <typename Derived> std::shared_ptr<Derived> shared() {
-    return std::static_pointer_cast<Derived>(shared_from_this());
-  }
-
-  /**
-   * Loads all native methods of this `HybridObject` to be exposed to JavaScript.
-   * Example:
-   *
-   * ```cpp
-   * int User::getAge() {
-   *   return 23;
-   * }
-   *
-   * void User::loadHybridMethods() {
-   *   registerHybridMethod("getAge", &User::getAge, this);
-   * }
-   * ```
-   */
-  virtual void loadHybridMethods() = 0;
-
-  /**
-   * Get a string representation of this HostObject, useful for logging or debugging.
-   */
-  virtual std::string toString(jsi::Runtime& runtime);
-
-  /**
-   * Get the memory pressure of this HostObject in bytes.
-   * This is used to inform the JavaScript runtime about memory usage for garbage collection.
-   */
-  virtual size_t getMemoryPressure() { return 1024; }
-
-private:
-  static constexpr auto TAG = "HybridObject";
-  int _instanceId = 1;
-  bool _didLoadMethods = false;
-  std::mutex _mutex;
-  std::unordered_map<std::string, HybridFunction> _methods;
-  std::unordered_map<std::string, jsi::HostFunctionType> _getters;
-  std::unordered_map<std::string, jsi::HostFunctionType> _setters;
-  std::unordered_map<jsi::Runtime*, std::unordered_map<std::string, std::shared_ptr<jsi::Function>>> _functionCache;
-
-protected:
-  const char* _name = TAG;
-  // Store a pointer to the runtime for convenience; ensure it is only used while the runtime state is alive.
-  jsi::Runtime* _creationRuntime = nullptr;
-  std::weak_ptr<rnwgpu::RNFRuntimeState> _runtimeState;
-
-private:
-  inline void ensureInitialized(facebook::jsi::Runtime& runtime);
-
-private:
-  template <typename Derived, typename ReturnType, typename... Args, size_t... Is>
-  static inline jsi::Value callMethod(Derived* obj, ReturnType (Derived::*method)(Args...), jsi::Runtime& runtime, const jsi::Value* args,
-                                      std::index_sequence<Is...>, size_t count) {
-    if constexpr (std::is_same_v<ReturnType, void>) {
-      // It's a void method.
-      (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is], Is >= count)...);
-      return jsi::Value::undefined();
-    } else {
-      // It's returning some C++ type, we need to convert that to a JSI value now.
-      ReturnType result = (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is], Is >= count)...);
-      return JSIConverter<std::decay_t<ReturnType>>::toJSI(runtime, std::move(result));
-    }
-  }
-
-  template <typename Derived, typename ReturnType, typename... Args>
-  static jsi::HostFunctionType createHybridMethod(ReturnType (Derived::*method)(Args...), Derived* derivedInstance) {
-
-    return [derivedInstance, method](jsi::Runtime& runtime, const jsi::Value& thisVal, const jsi::Value* args, size_t count) -> jsi::Value {
-      if constexpr (std::is_same_v<ReturnType, jsi::Value>) {
-        // If the return type is a jsi::Value, we assume the user wants full JSI code control.
-        // The signature must be identical to jsi::HostFunction (jsi::Runtime&, jsi::Value& this, ...)
-        return (derivedInstance->*method)(runtime, thisVal, args, count);
-      } else {
-        // Call the actual method with JSI values as arguments and return a JSI value again.
-        // Internally, this method converts the JSI values to C++ values.
-        return callMethod(derivedInstance, method, runtime, args, std::index_sequence_for<Args...>{}, count);
-      }
-    };
-  }
-
-protected:
-  facebook::jsi::Runtime* getCreationRuntime() const;
-  std::weak_ptr<rnwgpu::RNFRuntimeState> getRuntimeStateWeak() const { return _runtimeState; }
-
-protected:
-  template <typename Derived, typename ReturnType, typename... Args>
-  void registerHybridMethod(std::string name, ReturnType (Derived::*method)(Args...), Derived* derivedInstance, bool override = false) {
-    if (!override && (_getters.count(name) > 0 || _setters.count(name) > 0)) {
-      [[unlikely]];
-      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
-    }
-    if (!override && (_methods.count(name) > 0)) {
-      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a method with that name already exists!");
-    }
-
-    _methods[name] = HybridFunction{.function = createHybridMethod(method, derivedInstance), .parameterCount = sizeof...(Args)};
-  }
-
-  template <typename Derived, typename ReturnType>
-  void registerHybridGetter(std::string name, ReturnType (Derived::*method)(), Derived* derivedInstance) {
-    if (_getters.count(name) > 0) {
-      [[unlikely]];
-      throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a getter with that name already exists!");
-    }
-    if (_methods.count(name) > 0) {
-      [[unlikely]];
-      throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a method with that name already exists!");
-    }
-
-    _getters[name] = createHybridMethod(method, derivedInstance);
-  }
-
-  template <typename Derived, typename ValueType>
-  void registerHybridSetter(std::string name, void (Derived::*method)(ValueType), Derived* derivedInstance) {
-    if (_setters.count(name) > 0) {
-      [[unlikely]];
-      throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a setter with that name already exists!");
-    }
-    if (_methods.count(name) > 0) {
-      [[unlikely]];
-      throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a method with that name already exists!");
-    }
-
-    _setters[name] = createHybridMethod(method, derivedInstance);
-  }
-
-  bool isRuntimeAlive();
-};
-
-} // namespace margelo

package/cpp/jsi/RNFJSIHelper.h

@@ -1,51 +0,0 @@
-//
-// Created by Hanno Gödecke on 15.05.24.
-//
-
-#pragma once
-
-#include "RNFRuntimeState.h"
-#include <jsi/jsi.h>
-#include <memory>
-#include <utility>
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-
-class JSIHelper {
-public:
-  /**
-   * Takes a jsi::Function and wraps it in a shared_ptr so its shareable.
-   * Every jsi::Function you intend to share or hold should be wrapped using this function.
-   */
-  static std::shared_ptr<jsi::Function> createSharedJsiFunction(jsi::Runtime& runtime, jsi::Function&& function) {
-    auto runtimeState = rnwgpu::RNFRuntimeState::get(runtime);
-    std::weak_ptr<rnwgpu::RNFRuntimeState> runtimeStateWeak = runtimeState;
-    std::shared_ptr<jsi::Function> sharedFunction(new jsi::Function(std::move(function)), [runtimeStateWeak](jsi::Function* ptr) {
-      if (!runtimeStateWeak.expired()) {
-        // Only delete the jsi::Function when the runtime it created is still alive.
-        // Otherwise leak memory. We do this on purpose, as sometimes we would keep
-        // references to JSI objects past the lifetime of its runtime (e.g.,
-        // shared values references from the RN VM holds reference to JSI objects
-        // on the UI runtime). When the runtime is terminated, the orphaned JSI
-        // objects would crash the app when their destructors are called, because
-        // they call into a memory that's managed by the terminated runtime. We
-        // accept the tradeoff of leaking memory here, as it has a limited impact.
-        // This scenario can only occur when the React instance is torn down which
-        // happens in development mode during app reloads, or in production when
-        // the app is being shut down gracefully by the system. An alternative
-        // solution would require us to keep track of all JSI values that are in
-        // use which would require additional data structure and compute spent on
-        // bookkeeping that only for the sake of destroying the values in time
-        // before the runtime is terminated. Note that the underlying memory that
-        // jsi::Value refers to is managed by the VM and gets freed along with the
-        // runtime.
-        delete ptr;
-      }
-    });
-
-    return sharedFunction;
-  }
-};
-} // namespace margelo

package/cpp/jsi/RNFPointerHolder.h

@@ -1,95 +0,0 @@
-//
-// Created by Marc Rousavy on 16.04.24.
-//
-
-#pragma once
-
-#include "RNFHybridObject.h"
-#include "RNFLogger.h"
-#include <memory>
-#include <mutex>
-#include <utility>
-#include <string>
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-
-template <typename T> class PointerHolder : public HybridObject {
-protected:
-  // no default constructor
-  PointerHolder() = delete;
-
-  /**
-   * Create a new instance of a pointer holder which holds the given shared_ptr.
-   * @param name The name of the implementing class, for example "ViewWrapper".
-   * @param pointer The pointer this class will hold. It might be released from JS at any point via `release()`.
-   */
-  PointerHolder(const char* name, std::shared_ptr<T> pointer) : HybridObject(name), _name(name), _pointer(pointer) {
-    // eagerly initialize the release() method instead of putting it in `loadHybridMethods`
-    registerHybridMethod("release", &PointerHolder<T>::release, this);
-    registerHybridGetter("isValid", &PointerHolder<T>::getIsValid, this);
-  }
-
-  /**
-   * Create a new instance of a pointer holder which holds a shared_ptr of the given value.
-   * The shared_ptr will be move-constructed.
-   * @param name The name of the implementing class, for example "ViewWrapper".
-   * @param value The value this class will hold as a shared_ptr. It might be destroyed from JS at any point via `release()`.
-   */
-  PointerHolder(const char* name, T&& value) : PointerHolder(name, std::make_shared<T>(std::move(value))) {}
-
-  /**
-   * Called when the PointerHolder gets automatically destroyed (e.g. via GC) and the shared_ptr will be destroyed.
-   */
-  ~PointerHolder() {
-    if (_pointer != nullptr) {
-      Logger::log(TAG, "Automatically releasing %s... (~PointerHolder())", _name.c_str());
-    }
-  }
-
-protected:
-  /**
-   * Manually release this reference to the pointer.
-   * If there are any other references to this pointer, no memory will be force-deleted.
-   */
-  virtual void release() {
-    std::unique_lock lock(_mutex);
-
-    if (_pointer == nullptr) {
-      throw std::runtime_error("Pointer " + _name + " has already been manually released!");
-    }
-    Logger::log(TAG, "Manually releasing %s... (PointerHolder::release())", _name.c_str());
-    _pointer = nullptr;
-  }
-
-  /**
-   * Get the shared_ptr this class is holding.
-   * If it has already been manually released from JS, this method will throw a runtime_error.
-   */
-  std::shared_ptr<T> pointee() {
-    std::unique_lock lock(_mutex);
-
-    if (_pointer == nullptr) {
-      throw std::runtime_error("Pointer " + _name + " has already been manually released!");
-    }
-    return _pointer;
-  }
-
-  /**
-   * Get if the pointer is still valid and strong.
-   */
-  bool getIsValid() {
-    std::unique_lock lock(_mutex);
-
-    return _pointer != nullptr;
-  }
-
-private:
-  std::string _name;
-  std::shared_ptr<T> _pointer;
-  std::mutex _mutex;
-  static constexpr auto TAG = "PointerHolder";
-};
-
-} // namespace margelo

package/cpp/jsi/RNFRuntimeState.cpp

@@ -1,18 +0,0 @@
-#include "RNFRuntimeState.h"
-
-namespace rnwgpu {
-
-const facebook::jsi::UUID RNFRuntimeState::kRuntimeStateKey = facebook::jsi::UUID();
-
-std::shared_ptr<RNFRuntimeState> RNFRuntimeState::get(facebook::jsi::Runtime& runtime) {
-  auto existing = runtime.getRuntimeData(kRuntimeStateKey);
-  if (existing) {
-    return std::static_pointer_cast<RNFRuntimeState>(existing);
-  }
-
-  auto state = std::shared_ptr<RNFRuntimeState>(new RNFRuntimeState());
-  runtime.setRuntimeData(kRuntimeStateKey, state);
-  return state;
-}
-
-} // namespace rnwgpu

package/cpp/jsi/RNFRuntimeState.h

@@ -1,106 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <memory>
-#include <mutex>
-#include <unordered_map>
-#include <unordered_set>
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-/**
- * Runtime state management using Hermes' runtime.setRuntimeData API.
- * This replaces the old RuntimeLifecycleMonitor/RuntimeAwareCache system.
- */
-class RNFRuntimeState {
-public:
-  // UUID key for storing our runtime state
-  static const jsi::UUID kRuntimeStateKey;
-
-  /**
-   * Get or create the runtime state for the given runtime
-   */
-  static std::shared_ptr<RNFRuntimeState> get(jsi::Runtime& runtime);
-
-  /**
-   * Template cache that can store any type T per object pointer
-   */
-  template <typename T>
-  class ObjectCache {
-  public:
-    std::shared_ptr<T> getOrCreate(void* object) {
-      std::lock_guard<std::mutex> lock(mutex_);
-      auto it = cache_.find(object);
-      if (it != cache_.end()) {
-        return it->second;
-      }
-
-      auto value = std::make_shared<T>();
-      cache_[object] = value;
-      return value;
-    }
-
-    void remove(void* object) {
-      std::lock_guard<std::mutex> lock(mutex_);
-      cache_.erase(object);
-    }
-
-    void clear() {
-      std::lock_guard<std::mutex> lock(mutex_);
-      cache_.clear();
-    }
-
-  private:
-    std::mutex mutex_;
-    std::unordered_map<void*, std::shared_ptr<T>> cache_;
-  };
-
-  /**
-   * Get or create a cache for a specific type T
-   */
-  template <typename T>
-  std::shared_ptr<ObjectCache<T>> getCache() {
-    std::lock_guard<std::mutex> lock(mutex_);
-
-    // Use type_info as key for the cache type
-    const std::type_info& typeId = typeid(T);
-    auto it = typeCaches_.find(&typeId);
-
-    if (it != typeCaches_.end()) {
-      return std::static_pointer_cast<ObjectCache<T>>(it->second);
-    }
-
-    auto cache = std::make_shared<ObjectCache<T>>();
-    typeCaches_[&typeId] = cache;
-    return cache;
-  }
-
-private:
-  RNFRuntimeState() = default;
-
-  std::mutex mutex_;
-  // Map from type_info to cache instance
-  std::unordered_map<const std::type_info*, std::shared_ptr<void>> typeCaches_;
-};
-
-/**
- * Template helper for runtime-aware caching compatible with the old API
- * This provides a migration path from RuntimeAwareCache
- */
-template <typename T>
-class RuntimeAwareCache {
-public:
-  T& get(jsi::Runtime& rt) {
-    auto state = RNFRuntimeState::get(rt);
-    auto cache = state->getCache<T>();
-
-    // For compatibility, we use the runtime pointer as the object key
-    auto ptr = cache->getOrCreate(&rt);
-    return *ptr;
-  }
-};
-
-} // namespace rnwgpu