react-native-nitro-modules 0.16.2 → 0.17.0

package/cpp/threading/ThreadPool.cpp

@@ -11,38 +11,58 @@
 
 namespace margelo::nitro {
 
-ThreadPool::ThreadPool(const char* name, size_t numThreads) : _isAlive(true), _name(name) {
-  Logger::log(LogLevel::Info, TAG, "Creating ThreadPool \"%s\" with %i threads...", name, numThreads);
+ThreadPool::ThreadPool(const char* name, size_t initialThreadsCount, size_t maxThreadsCount)
+    : _isAlive(true), _threadCountLimit(maxThreadsCount), _name(name) {
+  Logger::log(LogLevel::Info, TAG, "Creating ThreadPool \"%s\" with %i initial threads (max: %i)...", name, initialThreadsCount,
+              maxThreadsCount);
 
-  for (size_t i = 0; i < numThreads; ++i) {
-    std::string threadName = std::string(name) + "-" + std::to_string(i + 1);
-    _workers.emplace_back([this, threadName] {
-      // Set the Thread's name
-      ThreadUtils::setThreadName(threadName);
+  for (size_t i = 0; i < initialThreadsCount; i++) {
+    addThread();
+  }
+}
+
+void ThreadPool::addThread() {
+  std::unique_lock<std::mutex> lock(_queueMutex);
+  if (!_isAlive) {
+    return;
+  }
+
+  size_t i = ++_threadCount;
+  Logger::log(LogLevel::Info, TAG, "Adding Thread %i to ThreadPool \"%s\"...", i, _name);
+
+  std::string threadName = std::string(_name) + "-" + std::to_string(i);
+  _workers.emplace_back([this, threadName] {
+    // Set the Thread's name
+    ThreadUtils::setThreadName(threadName);
 
-      // Start the run-loop
-      while (true) {
-        std::function<void()> task;
-        {
-          // Lock on the mutex so only one Worker receives the condition signal at a time
-          std::unique_lock<std::mutex> lock(_queueMutex);
-          this->_condition.wait(lock, [this] { return !_isAlive || !_tasks.empty(); });
-          if (!_isAlive && _tasks.empty()) {
-            // ThreadPool is dead - stop run-loop.
-            return;
-          }
-          // Schedule the oldest task
-          task = std::move(_tasks.front());
-          _tasks.pop();
+    // Start the run-loop
+    while (true) {
+      std::function<void()> task;
+      {
+        // Lock on the mutex so only one Worker receives the condition signal at a time
+        std::unique_lock<std::mutex> lock(_queueMutex);
+        this->_condition.wait(lock, [this] { return !_isAlive || !_tasks.empty(); });
+        if (!_isAlive && _tasks.empty()) {
+          // ThreadPool is dead - stop run-loop.
+          return;
         }
-        // Run it (outside of the mutex so others can run in parallel)
-        task();
+        // Schedule the oldest task
+        task = std::move(_tasks.front());
+        _tasks.pop();
       }
-    });
-  }
+      // Run it (outside of the mutex so others can run in parallel)
+      task();
+    }
+  });
+  _condition.notify_all();
 }
 
 void ThreadPool::run(std::function<void()>&& task) {
+  // If there are tasks still waiting to be finished, just start a new Thread.
+  if (!_tasks.empty() && _threadCount < _threadCountLimit) {
+    addThread();
+  }
+  // New scope because of RAII lock
   {
     // lock on the mutex - we want to emplace the task back in the queue
     std::unique_lock<std::mutex> lock(_queueMutex);
@@ -71,13 +91,8 @@ ThreadPool::~ThreadPool() {
   }
 }
 
-std::shared_ptr<ThreadPool> ThreadPool::getSharedPool() {
-  static std::shared_ptr<ThreadPool> shared;
-  if (shared == nullptr) {
-    int availableThreads = std::thread::hardware_concurrency();
-    auto numThreads = std::min(availableThreads, 3);
-    shared = std::make_shared<ThreadPool>("nitro-thread", numThreads);
-  }
+ThreadPool& ThreadPool::shared() {
+  static ThreadPool shared("nitro-thread", 3, 10);
   return shared;
 }
 

package/cpp/threading/ThreadPool.hpp

@@ -22,10 +22,13 @@ namespace margelo::nitro {
 class ThreadPool final {
 public:
   /**
-   * Create a new ThreadPool with the given number of fixed workers/threads.
+   * Create a new ThreadPool with the given number of minimum workers/threads.
+   * The Thread Pool can expand on the fly if it is busy.
    */
-  explicit ThreadPool(const char* const name, size_t numThreads);
+  explicit ThreadPool(const char* const name, size_t initialThreadsCount, size_t maxThreadsCount);
   ~ThreadPool();
+  ThreadPool(const ThreadPool&) = delete;
+  ThreadPool(ThreadPool&&) = delete;
 
   /**
    * Schedules the given task asynchronously on the ThreadPool.
@@ -33,12 +36,19 @@ public:
    */
   void run(std::function<void()>&& task);
 
+private:
+  /**
+   * Adds a new Thread to the current Thread Pool.
+   * This grows the size by one, and potentially starts work sooner if other Threads are busy.
+   */
+  void addThread();
+
 public:
   /**
    * Get a static singleton instance - a shared ThreadPool.
    * The shared ThreadPool has 3 threads.
    */
-  static std::shared_ptr<ThreadPool> getSharedPool();
+  static ThreadPool& shared();
 
 private:
   std::vector<std::thread> _workers;
@@ -46,6 +56,8 @@ private:
   std::mutex _queueMutex;
   std::condition_variable _condition;
   std::atomic<bool> _isAlive;
+  std::atomic<size_t> _threadCount;
+  size_t _threadCountLimit;
   const char* _name;
   static constexpr auto TAG = "ThreadPool";
 };

package/ios/core/RuntimeError.swift

@@ -14,4 +14,22 @@ import Foundation
  */
 public enum RuntimeError: Error {
   case error(withMessage: String)
+  
+  /**
+   * Creates a new `RuntimeError` from the given C++ `std::exception`.
+   */
+  public static func from(cppError: std.exception) -> RuntimeError {
+    let message = margelo.nitro.get_exception_message(cppError)
+    return .error(withMessage: String(message))
+  }
+}
+
+public extension Error {
+  /**
+   * Converts this `Error` to a C++ `std::exception`.
+   */
+  func toCpp() -> std.exception {
+    let message = String(describing: self)
+    return margelo.nitro.make_exception(std.string(message))
+  }
 }

package/ios/utils/RuntimeError.hpp

@@ -0,0 +1,23 @@
+//
+//  RuntimeError.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 19.11.24.
+//
+
+#pragma once
+
+#include <exception>
+#include <string>
+
+namespace margelo::nitro {
+
+static inline std::exception make_exception(const std::string& message) {
+  return std::runtime_error(message);
+}
+
+static inline std::string get_exception_message(const std::exception& exception) {
+  return exception.what();
+}
+
+} // namespace margelo::nitro

package/ios/utils/SwiftClosure.hpp

@@ -55,7 +55,11 @@ public:
   /**
    * Gets the underlying `std::function`.
    */
-  const std::function<void()>& getFunction() {
+  const std::function<void()>& getFunction() const {
+    return _function;
+  }
+
+  std::function<void()> getFunctionCopy() const {
     return _function;
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.16.2",
+  "version": "0.17.0",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -70,7 +70,7 @@
     "jest": "*",
     "react": "*",
     "react-native": "*",
-    "react-native-builder-bob": "^0.31.0"
+    "react-native-builder-bob": "^0.32.0"
   },
   "peerDependencies": {
     "react": "*",

package/cpp/jsi/JSPromise.cpp

@@ -1,58 +0,0 @@
-#include "JSPromise.hpp"
-#include "JSICache.hpp"
-#include "NitroLogger.hpp"
-#include <jsi/jsi.h>
-
-namespace margelo::nitro {
-
-using namespace facebook;
-
-JSPromise::JSPromise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter) {
-  auto functionCache = JSICache::getOrCreateCache(runtime);
-  _resolver = functionCache.makeShared(std::move(resolver));
-  _rejecter = functionCache.makeShared(std::move(rejecter));
-}
-
-jsi::Value JSPromise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {
-  // Get Promise ctor from global
-  auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
-
-  auto promiseCallback = jsi::Function::createFromHostFunction(
-      runtime, jsi::PropNameID::forUtf8(runtime, "PromiseCallback"), 2,
-      [run = std::move(run)](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments, size_t count) -> jsi::Value {
-        // Get resolver and rejecter
-        auto resolver = arguments[0].getObject(runtime).getFunction(runtime);
-        auto rejecter = arguments[1].getObject(runtime).getFunction(runtime);
-        // Create `Promise` type that wraps the JSI callbacks
-        auto promise = std::make_shared<JSPromise>(runtime, std::move(resolver), std::move(rejecter));
-        // Call `run` callback
-        run(runtime, promise);
-
-        return jsi::Value::undefined();
-      });
-
-  return promiseCtor.callAsConstructor(runtime, promiseCallback);
-}
-
-void JSPromise::resolve(jsi::Runtime& runtime, jsi::Value&& result) {
-  OwningLock<jsi::Function> lock = _resolver.lock();
-
-  if (!_resolver) {
-    Logger::log(LogLevel::Error, TAG, "Promise resolver function has already been deleted! Ignoring call..");
-    return;
-  }
-  _resolver->call(runtime, std::move(result));
-}
-
-void JSPromise::reject(jsi::Runtime& runtime, std::string message) {
-  OwningLock<jsi::Function> lock = _rejecter.lock();
-
-  if (!_rejecter) {
-    Logger::log(LogLevel::Error, TAG, "Promise rejecter function has already been deleted! Ignoring call..");
-    return;
-  }
-  jsi::JSError error(runtime, message);
-  _rejecter->call(runtime, error.value());
-}
-
-} // namespace margelo::nitro

package/cpp/jsi/JSPromise.hpp

@@ -1,54 +0,0 @@
-//
-//  JSPromise.hpp
-//  react-native-filament
-//
-//  Created by Marc Rousavy on 11.03.24.
-//
-
-#pragma once
-
-#include "OwningReference.hpp"
-#include <functional>
-#include <jsi/jsi.h>
-#include <memory>
-
-namespace margelo::nitro {
-
-using namespace facebook;
-
-/**
- * Represents a JS Promise.
- *
- * `JSPromise` is not thread-safe: It has to be resolved/rejected
- * on the same thread and Runtime as it was created on.
- */
-class JSPromise final {
-public:
-  JSPromise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter);
-
-  /**
-   Resolve the Promise with the given `jsi::Value`.
-   If the `jsi::Runtime` has already been deleted, this will do nothing.
-   */
-  void resolve(jsi::Runtime& runtime, jsi::Value&& result);
-  /**
-   Resolve the Promise with the given error message.
-   If the `jsi::Runtime` has already been deleted, this will do nothing.
-   */
-  void reject(jsi::Runtime& runtime, std::string error);
-
-private:
-  OwningReference<jsi::Function> _resolver;
-  OwningReference<jsi::Function> _rejecter;
-  static constexpr auto TAG = "Promise";
-
-public:
-  using RunPromise = std::function<void(jsi::Runtime& runtime, std::shared_ptr<JSPromise> promise)>;
-  /**
-   * Create a new Promise using the JS `Promise` constructor and runs the given `run` function.
-   * The resulting Promise should be returned to JS so it can be awaited.
-   */
-  static jsi::Value createPromise(jsi::Runtime& runtime, RunPromise&& run);
-};
-
-} // namespace margelo::nitro

package/ios/core/PromiseHolder.hpp

@@ -1,86 +0,0 @@
-//
-//  PromiseHolder.hpp
-//  Nitro
-//
-//  Created by Marc Rousavy on 15.08.24.
-//
-
-#pragma once
-
-#include <future>
-#include <string>
-
-namespace margelo::nitro {
-
-/**
- * Holds a `std::promise` that can be accessed from Swift using proper ref management.
- */
-template <typename T>
-class PromiseHolder {
-public:
-  /**
-   * Create a new PromiseHolder (and a new `std::promise<T>`).
-   */
-  explicit PromiseHolder() {
-    _promise = std::make_shared<std::promise<T>>();
-  }
-
-  /**
-   * Resolve the underlying `std::promise<T>` with `T`.
-   */
-  void resolve(const T& result) const {
-    _promise->set_value(result);
-  }
-
-  /**
-   * Reject the underlying `std::promise<T>` with the given message.
-   */
-  void reject(const std::string& message) const {
-    try {
-      throw std::runtime_error(message);
-    } catch (...) {
-      _promise->set_exception(std::current_exception());
-    }
-  }
-
-  /**
-   * Get the `std::future<T>` of the underlying `std::promise<T>`.
-   * This can only be called once.
-   */
-  std::future<T> getFuture() {
-    return _promise->get_future();
-  }
-
-private:
-  std::shared_ptr<std::promise<T>> _promise;
-};
-
-// Specialization for `void` (no args to `resolve()`)
-template <>
-class PromiseHolder<void> {
-public:
-  explicit PromiseHolder() {
-    _promise = std::make_shared<std::promise<void>>();
-  }
-
-  void resolve() const {
-    _promise->set_value();
-  }
-
-  void reject(const std::string& message) const {
-    try {
-      throw std::runtime_error(message);
-    } catch (...) {
-      _promise->set_exception(std::current_exception());
-    }
-  }
-
-  std::future<void> getFuture() {
-    return _promise->get_future();
-  }
-
-private:
-  std::shared_ptr<std::promise<void>> _promise;
-};
-
-} // namespace margelo::nitro