RuntimeExecutor: Fork an ios implementation

Differential Revision: D74901907

Author: RSNara

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Legacy.cpp

@@ -8,6 +8,7 @@
 #include "RuntimeScheduler_Legacy.h"
 #include "SchedulerPriorityUtils.h"
 
+#include <ReactCommon/RuntimeExecutorUtils.h>
 #include <cxxreact/TraceSection.h>
 #include <react/renderer/consistency/ScopedShadowTreeRevisionLock.h>
 #include <utility>

packages/react-native/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Modern.cpp

@@ -8,6 +8,7 @@
 #include "RuntimeScheduler_Modern.h"
 #include "SchedulerPriorityUtils.h"
 
+#include <ReactCommon/RuntimeExecutorUtils.h>
 #include <cxxreact/TraceSection.h>
 #include <jsinspector-modern/tracing/EventLoopReporter.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>

packages/react-native/ReactCommon/react/runtime/BufferedRuntimeExecutor.h

@@ -10,6 +10,7 @@
 #include <ReactCommon/RuntimeExecutor.h>
 #include <jsi/jsi.h>
 #include <atomic>
+#include <mutex>
 #include <queue>
 
 namespace facebook::react {

packages/react-native/ReactCommon/runtimeexecutor/CMakeLists.txt

@@ -8,11 +8,11 @@ set(CMAKE_VERBOSE_MAKEFILE on)
 
 include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
-file(GLOB_RECURSE runtimeexecutor_SRC CONFIGURE_DEPENDS *.cpp *.h)
+file(GLOB_RECURSE runtimeexecutor_SRC CONFIGURE_DEPENDS *.cpp *.h ${CMAKE_CURRENT_SOURCE_DIR}/platform/android/*.cpp)
 
 add_library(runtimeexecutor OBJECT ${runtimeexecutor_SRC})
 
-target_include_directories(runtimeexecutor PUBLIC .)
+target_include_directories(runtimeexecutor PUBLIC . ${CMAKE_CURRENT_SOURCE_DIR}/platform/android/)
 
 target_link_libraries(runtimeexecutor jsi)
 target_compile_reactnative_options(runtimeexecutor PRIVATE)

packages/react-native/ReactCommon/runtimeexecutor/React-runtimeexecutor.podspec

@@ -17,6 +17,8 @@ else
 end
 
 Pod::Spec.new do |s|
+  source_files = "*.{m,mm,cpp,h}", "platform/ios/**/*.{m,mm,cpp,h}"
+
   s.name                   = "React-runtimeexecutor"
   s.version                = version
   s.summary                = "-"  # TODO
@@ -25,8 +27,14 @@ Pod::Spec.new do |s|
   s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = min_supported_versions
   s.source                 = source
-  s.source_files           = "**/*.{cpp,h}"
+  s.source_files           = source_files
   s.header_dir             = "ReactCommon"
 
+  if ENV['USE_FRAMEWORKS']
+    s.module_name            = "React-runtimeexecutor"
+    s.header_mappings_dir  = "."
+    header_search_paths = header_search_paths + ["\"$(PODS_TARGET_SRCROOT)/platform/ios\""]
+  end
+
   s.dependency "React-jsi", version
 end

packages/react-native/ReactCommon/runtimeexecutor/ReactCommon/RuntimeExecutor.h

@@ -7,9 +7,6 @@
 
 #pragma once
 
-#include <mutex>
-#include <thread>
-
 #include <jsi/jsi.h>
 
 namespace facebook::react {
@@ -25,73 +22,4 @@ namespace facebook::react {
 using RuntimeExecutor =
     std::function<void(std::function<void(jsi::Runtime& runtime)>&& callback)>;
 
-/*
- * Executes a `callback` in a *synchronous* manner on the same thread using
- * given `RuntimeExecutor`.
- * Use this method when the caller needs to *be blocked* by executing the
- * `callback` and requires that the callback will be executed on the same
- * thread.
- * Example order of events (when not a sync call in runtimeExecutor callback):
- * - [UI thread] Lock all mutexes at start
- * - [UI thread] runtimeCaptured.lock before callback
- * - [JS thread] Set runtimePtr in runtimeExecutor callback
- * - [JS thread] runtimeCaptured.unlock in runtimeExecutor callback
- * - [UI thread] Call callback
- * - [JS thread] callbackExecuted.lock in runtimeExecutor callback
- * - [UI thread] callbackExecuted.unlock after callback
- * - [UI thread] jsBlockExecuted.lock after callback
- * - [JS thread] jsBlockExecuted.unlock in runtimeExecutor callback
- */
-inline static void executeSynchronouslyOnSameThread_CAN_DEADLOCK(
-    const RuntimeExecutor& runtimeExecutor,
-    std::function<void(jsi::Runtime& runtime)>&& callback) noexcept {
-  // Note: We need the third mutex to get back to the main thread before
-  // the lambda is finished (because all mutexes are allocated on the stack).
-
-  std::mutex runtimeCaptured;
-  std::mutex callbackExecuted;
-  std::mutex jsBlockExecuted;
-
-  runtimeCaptured.lock();
-  callbackExecuted.lock();
-  jsBlockExecuted.lock();
-
-  jsi::Runtime* runtimePtr;
-
-  auto threadId = std::this_thread::get_id();
-
-  runtimeExecutor([&](jsi::Runtime& runtime) {
-    runtimePtr = &runtime;
-
-    if (threadId == std::this_thread::get_id()) {
-      // In case of a synchronous call, we should unlock mutexes and return.
-      runtimeCaptured.unlock();
-      jsBlockExecuted.unlock();
-      return;
-    }
-
-    runtimeCaptured.unlock();
-    // `callback` is called somewhere here.
-    callbackExecuted.lock();
-    jsBlockExecuted.unlock();
-  });
-
-  runtimeCaptured.lock();
-  callback(*runtimePtr);
-  callbackExecuted.unlock();
-  jsBlockExecuted.lock();
-}
-
-template <typename DataT>
-inline static DataT executeSynchronouslyOnSameThread_CAN_DEADLOCK(
-    const RuntimeExecutor& runtimeExecutor,
-    std::function<DataT(jsi::Runtime& runtime)>&& callback) noexcept {
-  DataT data;
-
-  executeSynchronouslyOnSameThread_CAN_DEADLOCK(
-      runtimeExecutor,
-      [&](jsi::Runtime& runtime) { data = callback(runtime); });
-
-  return data;
-}
 } // namespace facebook::react

packages/react-native/ReactCommon/runtimeexecutor/platform/default/ReactCommon/RuntimeExecutorUtils.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <ReactCommon/RuntimeExecutorUtils.h>
+#include <mutex>
+#include <thread>
+
+namespace facebook::react {
+/**
+ * Example order of events (when not a sync call in runtimeExecutor
+ * callback):
+ * - [UI thread] Lock all mutexes at start
+ * - [UI thread] runtimeCaptured.lock before callback
+ * - [JS thread] Set runtimePtr in runtimeExecutor callback
+ * - [JS thread] runtimeCaptured.unlock in runtimeExecutor callback
+ * - [UI thread] Call callback
+ * - [JS thread] callbackExecuted.lock in runtimeExecutor callback
+ * - [UI thread] callbackExecuted.unlock after callback
+ * - [UI thread] jsBlockExecuted.lock after callback
+ * - [JS thread] jsBlockExecuted.unlock in runtimeExecutor callback
+ */
+void executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+    const RuntimeExecutor& runtimeExecutor,
+    std::function<void(jsi::Runtime& runtime)>&& callback) noexcept {
+  // Note: We need the third mutex to get back to the main thread before
+  // the lambda is finished (because all mutexes are allocated on the stack).
+
+  std::mutex runtimeCaptured;
+  std::mutex callbackExecuted;
+  std::mutex jsBlockExecuted;
+
+  runtimeCaptured.lock();
+  callbackExecuted.lock();
+  jsBlockExecuted.lock();
+
+  jsi::Runtime* runtimePtr;
+
+  auto threadId = std::this_thread::get_id();
+
+  runtimeExecutor([&](jsi::Runtime& runtime) {
+    runtimePtr = &runtime;
+
+    if (threadId == std::this_thread::get_id()) {
+      // In case of a synchronous call, we should unlock mutexes and return.
+      runtimeCaptured.unlock();
+      jsBlockExecuted.unlock();
+      return;
+    }
+
+    runtimeCaptured.unlock();
+    // `callback` is called somewhere here.
+    callbackExecuted.lock();
+    jsBlockExecuted.unlock();
+  });
+
+  runtimeCaptured.lock();
+  callback(*runtimePtr);
+  callbackExecuted.unlock();
+  jsBlockExecuted.lock();
+}
+
+} // namespace facebook::react

packages/react-native/ReactCommon/runtimeexecutor/platform/default/ReactCommon/RuntimeExecutorUtils.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <ReactCommon/RuntimeExecutor.h>
+
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+/*
+ * Executes a `callback` in a *synchronous* manner on the same thread using
+ * given `RuntimeExecutor`.
+ * Use this method when the caller needs to *be blocked* by executing the
+ * `callback` and requires that the callback will be executed on the same
+ * thread.
+ */
+void executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+    const RuntimeExecutor& runtimeExecutor,
+    std::function<void(jsi::Runtime& runtime)>&& callback) noexcept;
+
+template <typename DataT>
+DataT executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+    const RuntimeExecutor& runtimeExecutor,
+    std::function<DataT(jsi::Runtime& runtime)>&& callback) noexcept {
+  DataT data;
+
+  executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+      runtimeExecutor,
+      [&](jsi::Runtime& runtime) { data = callback(runtime); });
+
+  return data;
+}
+} // namespace facebook::react

packages/react-native/ReactCommon/runtimeexecutor/platform/ios/ReactCommon/RuntimeExecutorUtils.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <ReactCommon/RuntimeExecutor.h>
+
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+/*
+ * Executes a `callback` in a *synchronous* manner on the same thread using
+ * given `RuntimeExecutor`.
+ * Use this method when the caller needs to *be blocked* by executing the
+ * `callback` and requires that the callback will be executed on the same
+ * thread.
+ */
+void executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+    const RuntimeExecutor& runtimeExecutor,
+    std::function<void(jsi::Runtime& runtime)>&& callback) noexcept;
+
+template <typename DataT>
+DataT executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+    const RuntimeExecutor& runtimeExecutor,
+    std::function<DataT(jsi::Runtime& runtime)>&& callback) noexcept {
+  DataT data;
+
+  executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+      runtimeExecutor,
+      [&](jsi::Runtime& runtime) { data = callback(runtime); });
+
+  return data;
+}
+} // namespace facebook::react

packages/react-native/ReactCommon/runtimeexecutor/platform/ios/ReactCommon/RuntimeExecutorUtils.mm

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <ReactCommon/RuntimeExecutorUtils.h>
+#include <mutex>
+#include <thread>
+
+namespace facebook::react {
+/**
+ * Example order of events (when not a sync call in runtimeExecutor
+ * callback):
+ * - [UI thread] Lock all mutexes at start
+ * - [UI thread] runtimeCaptured.lock before callback
+ * - [JS thread] Set runtimePtr in runtimeExecutor callback
+ * - [JS thread] runtimeCaptured.unlock in runtimeExecutor callback
+ * - [UI thread] Call callback
+ * - [JS thread] callbackExecuted.lock in runtimeExecutor callback
+ * - [UI thread] callbackExecuted.unlock after callback
+ * - [UI thread] jsBlockExecuted.lock after callback
+ * - [JS thread] jsBlockExecuted.unlock in runtimeExecutor callback
+ */
+void executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+    const RuntimeExecutor &runtimeExecutor,
+    std::function<void(jsi::Runtime &runtime)> &&callback) noexcept
+{
+  // Note: We need the third mutex to get back to the main thread before
+  // the lambda is finished (because all mutexes are allocated on the stack).
+
+  std::mutex runtimeCaptured;
+  std::mutex callbackExecuted;
+  std::mutex jsBlockExecuted;
+
+  runtimeCaptured.lock();
+  callbackExecuted.lock();
+  jsBlockExecuted.lock();
+
+  jsi::Runtime *runtimePtr;
+
+  auto threadId = std::this_thread::get_id();
+
+  runtimeExecutor([&](jsi::Runtime &runtime) {
+    runtimePtr = &runtime;
+
+    if (threadId == std::this_thread::get_id()) {
+      // In case of a synchronous call, we should unlock mutexes and return.
+      runtimeCaptured.unlock();
+      jsBlockExecuted.unlock();
+      return;
+    }
+
+    runtimeCaptured.unlock();
+    // `callback` is called somewhere here.
+    callbackExecuted.lock();
+    jsBlockExecuted.unlock();
+  });
+
+  runtimeCaptured.lock();
+  callback(*runtimePtr);
+  callbackExecuted.unlock();
+  jsBlockExecuted.lock();
+}
+
+} // namespace facebook::react