perf: cover deferred worker promises and native-owned buffers (#1607)

* perf: cover deferred native Promises and native-owned buffer bounce

* fix(ios): expose ThreadPool in the NitroModules framework

Author: mrousavy

apps/benchmark/src/benchmarks/suite.ts

@@ -288,6 +288,20 @@ function createObjectBenchmarks(
       largeBuffer,
       'bounce'
     ),
+    createBufferBenchmark(
+      object,
+      implementation,
+      'bounce-native-4-kib',
+      object.copyBuffer(smallBuffer),
+      'bounce'
+    ),
+    createBufferBenchmark(
+      object,
+      implementation,
+      'bounce-native-1-mib',
+      object.copyBuffer(largeBuffer),
+      'bounce'
+    ),
     createBufferBenchmark(
       object,
       implementation,
@@ -339,6 +353,30 @@ function createObjectBenchmarks(
         return assertNumber(checksum, 'promiseReturnsInstantly')
       },
     },
+    {
+      id: `${prefix}/promise/deferred-worker-with-trigger`,
+      version: 1,
+      family: 'promise',
+      implementation,
+      kind: 'async',
+      maxChunkIterations: 5_000,
+      collectNativeGarbage:
+        implementation === 'nitro-platform' && Platform.OS === 'android'
+          ? collectJavaGarbage
+          : undefined,
+      expectedChecksum: (iterations) => iterations * 55,
+      async run(iterations) {
+        let checksum = 0
+        for (let index = 0; index < iterations; index++) {
+          const promise = object.createPendingPromise()
+          // Includes the trigger call: completion cannot race ahead of the
+          // pending Promise's conversion to JS in createPendingPromise().
+          object.resolvePendingPromiseOnWorker()
+          checksum += await promise
+        }
+        return assertNumber(checksum, 'resolvePendingPromiseOnWorker')
+      },
+    },
   ]
 }
 

packages/react-native-nitro-modules/NitroModules.podspec

@@ -45,6 +45,7 @@ Pod::Spec.new do |s|
     "cpp/jsi/JSIHelpers.hpp",
     "cpp/platform/NitroLogger.hpp",
     "cpp/threading/Dispatcher.hpp",
+    "cpp/threading/ThreadPool.hpp",
     "cpp/utils/JSCallback.hpp",
     "cpp/utils/FastVectorCopy.hpp",
     "cpp/utils/NitroHash.hpp",

packages/react-native-nitro-test/android/src/main/java/com/margelo/nitro/test/HybridTestObjectKotlin.kt

@@ -11,13 +11,22 @@ import com.margelo.nitro.core.NullType
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.resolved
 import com.margelo.nitro.test.external.HybridSomeExternalObjectSpec
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import java.math.BigDecimal
 import java.time.Instant
 
 @Keep
 @DoNotStrip
 class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
+  private var pendingPromise: Promise<Double>? = null
+
+  private companion object {
+    val promiseScope = CoroutineScope(Dispatchers.Default)
+  }
+
   override var numberValue: Double = 0.0
   override var boolValue: Boolean = false
   override var stringValue: String = ""
@@ -316,6 +325,22 @@ class HybridTestObjectKotlin : HybridTestObjectSwiftKotlinSpec() {
     }
   }
 
+  override fun createPendingPromise(): Promise<Double> {
+    check(pendingPromise == null) { "A pending Promise is already waiting for completion." }
+    val promise = Promise<Double>()
+    pendingPromise = promise
+    return promise
+  }
+
+  override fun resolvePendingPromiseOnWorker() {
+    val promise = checkNotNull(pendingPromise) { "No pending Promise is waiting for completion." }
+    // Only JS calls access the slot; the worker owns the extracted Promise.
+    pendingPromise = null
+    promiseScope.launch {
+      promise.resolve(55.0)
+    }
+  }
+
   override fun promiseThatResolvesVoidInstantly(): Promise<Unit> {
     return Promise.resolved()
   }

packages/react-native-nitro-test/cpp/HybridTestObjectCpp.cpp

@@ -8,6 +8,7 @@
 #include "HybridTestObjectCpp.hpp"
 #include <NitroModules/AnyMap.hpp>
 #include <NitroModules/NitroLogger.hpp>
+#include <NitroModules/ThreadPool.hpp>
 #include <chrono>
 #include <sstream>
 #include <thread>
@@ -611,6 +612,23 @@ std::shared_ptr<Promise<double>> HybridTestObjectCpp::promiseReturnsInstantlyAsy
   return Promise<double>::async([=]() { return 55; });
 }
 
+std::shared_ptr<Promise<double>> HybridTestObjectCpp::createPendingPromise() {
+  if (_pendingPromise) {
+    throw std::runtime_error("A pending Promise is already waiting for completion.");
+  }
+  _pendingPromise = Promise<double>::create();
+  return _pendingPromise;
+}
+
+void HybridTestObjectCpp::resolvePendingPromiseOnWorker() {
+  if (!_pendingPromise) {
+    throw std::runtime_error("No pending Promise is waiting for completion.");
+  }
+  // Only JS calls access the slot; the worker owns the extracted Promise.
+  auto promise = std::move(_pendingPromise);
+  ThreadPool::shared().run([promise = std::move(promise)]() { promise->resolve(55); });
+}
+
 std::shared_ptr<Promise<void>> HybridTestObjectCpp::promiseThatResolvesVoidInstantly() {
   return Promise<void>::resolved();
 }

packages/react-native-nitro-test/cpp/HybridTestObjectCpp.hpp

@@ -45,6 +45,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   std::optional<std::function<void(double)>> _optionalCallback;
   bool _hasBooleanWritable;
   bool _isBooleanWritable;
+  std::shared_ptr<Promise<double>> _pendingPromise;
 
 private:
   static inline uint64_t calculateFibonacci(int count) noexcept {
@@ -205,6 +206,8 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   std::shared_ptr<Promise<void>> promiseThrows() override;
   std::shared_ptr<Promise<double>> promiseReturnsInstantly() override;
   std::shared_ptr<Promise<double>> promiseReturnsInstantlyAsync() override;
+  std::shared_ptr<Promise<double>> createPendingPromise() override;
+  void resolvePendingPromiseOnWorker() override;
   std::shared_ptr<Promise<void>> promiseThatResolvesVoidInstantly() override;
   std::shared_ptr<Promise<std::optional<double>>> promiseThatResolvesToUndefined() override;
   std::shared_ptr<Promise<std::optional<double>>> awaitNullablePromise() override;

packages/react-native-nitro-test/ios/HybridTestObjectSwift.swift

@@ -5,10 +5,13 @@
 //  Created by Marc Rousavy on 11.08.24.
 //
 
+import Dispatch
 import NitroModules
 import NitroTestExternal
 
 class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
+  private var pendingPromise: Promise<Double>?
+
   var optionalArray: [String]? = []
 
   var someVariant: Variant_Double_String = .first(55)
@@ -464,6 +467,26 @@ class HybridTestObjectSwift: HybridTestObjectSwiftKotlinSpec {
     }
   }
 
+  func createPendingPromise() throws -> Promise<Double> {
+    guard pendingPromise == nil else {
+      throw RuntimeError.error(withMessage: "A pending Promise is already waiting for completion.")
+    }
+    let promise = Promise<Double>()
+    pendingPromise = promise
+    return promise
+  }
+
+  func resolvePendingPromiseOnWorker() throws {
+    guard let promise = pendingPromise else {
+      throw RuntimeError.error(withMessage: "No pending Promise is waiting for completion.")
+    }
+    // Only JS calls access the slot; the worker owns the extracted Promise.
+    pendingPromise = nil
+    DispatchQueue.global().async {
+      promise.resolve(withResult: 55.0)
+    }
+  }
+
   func promiseThatResolvesVoidInstantly() throws -> Promise<Void> {
     return Promise.resolved()
   }

packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp

@@ -1077,6 +1077,26 @@ namespace margelo::nitro::test {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<double>> JHybridTestObjectSwiftKotlinSpec::createPendingPromise() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("createPendingPromise");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<double>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JDouble>(__boxedResult);
+        __promise->resolve(__result->value());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  void JHybridTestObjectSwiftKotlinSpec::resolvePendingPromiseOnWorker() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("resolvePendingPromiseOnWorker");
+    method(_javaPart);
+  }
   std::shared_ptr<Promise<void>> JHybridTestObjectSwiftKotlinSpec::promiseThatResolvesVoidInstantly() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("promiseThatResolvesVoidInstantly");
     auto __result = method(_javaPart);

packages/react-native-nitro-test/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp

@@ -142,6 +142,8 @@ namespace margelo::nitro::test {
     std::shared_ptr<Promise<void>> promiseThrows() override;
     std::shared_ptr<Promise<double>> promiseReturnsInstantly() override;
     std::shared_ptr<Promise<double>> promiseReturnsInstantlyAsync() override;
+    std::shared_ptr<Promise<double>> createPendingPromise() override;
+    void resolvePendingPromiseOnWorker() override;
     std::shared_ptr<Promise<void>> promiseThatResolvesVoidInstantly() override;
     std::shared_ptr<Promise<std::optional<double>>> promiseThatResolvesToUndefined() override;
     std::shared_ptr<Promise<std::optional<double>>> awaitNullablePromise() override;

packages/react-native-nitro-test/nitrogen/generated/android/kotlin/com/margelo/nitro/test/HybridTestObjectSwiftKotlinSpec.kt

@@ -378,6 +378,14 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
   @Keep
   abstract fun promiseReturnsInstantlyAsync(): Promise<Double>
 
+  @DoNotStrip
+  @Keep
+  abstract fun createPendingPromise(): Promise<Double>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun resolvePendingPromiseOnWorker(): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun promiseThatResolvesVoidInstantly(): Promise<Unit>

packages/react-native-nitro-test/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp

@@ -664,6 +664,20 @@ namespace margelo::nitro::test {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<double>> createPendingPromise() override {
+      auto __result = _swiftPart.createPendingPromise();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void resolvePendingPromiseOnWorker() override {
+      auto __result = _swiftPart.resolvePendingPromiseOnWorker();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline std::shared_ptr<Promise<void>> promiseThatResolvesVoidInstantly() override {
       auto __result = _swiftPart.promiseThatResolvesVoidInstantly();
       if (__result.hasError()) [[unlikely]] {