RuntimeExecutor: Fork an ios implementation

Summary:
We want the ios implementation of this api, to be implemented differently. Because, we need to build in deadlock mitigation for sync renders and events, for ios only.

Changelog: [Internal]

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/RuntimeExecutorSyncUIThreadUtils.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/RuntimeExecutorSyncUIThreadUtils.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,72 +22,4 @@ namespace facebook::react {
 using RuntimeExecutor =
     std::function<void(std::function<void(jsi::Runtime& runtime)>&& callback)>;
 
-/**
- * Example order of events (when not a sync call in runtimeExecutor
- * jsWork):
- * - [UI thread] Lock all mutexes at start
- * - [UI thread] Schedule "runtime capture block" on js thread
- * - [UI thread] Wait for runtime capture: runtimeCaptured.lock()
- * - [JS thread] Capture runtime by setting runtimePtr
- * - [JS thread] Signal runtime captured: runtimeCaptured.unlock()
- * - [UI thread] Call jsWork using runtimePtr
- * - [JS thread] Wait until jsWork done: jsWorkDone.lock()
- * - [UI thread] Signal jsWork done: jsWorkDone.unlock()
- * - [UI thread] Wait until runtime capture block finished:
- *               runtimeCaptureBlockDone.lock()
- * - [JS thread] Signal runtime capture block is finished:
- *               runtimeCaptureBlockDone.unlock()
- */
-inline static void executeSynchronouslyOnSameThread_CAN_DEADLOCK(
-    const RuntimeExecutor& runtimeExecutor,
-    std::function<void(jsi::Runtime& runtime)>&& jsWork) 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 jsWorkDone;
-  std::mutex runtimeCaptureBlockDone;
-
-  runtimeCaptured.lock();
-  jsWorkDone.lock();
-  runtimeCaptureBlockDone.lock();
-
-  jsi::Runtime* runtimePtr;
-
-  auto threadId = std::this_thread::get_id();
-  auto runtimeCaptureBlock = [&](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();
-      runtimeCaptureBlockDone.unlock();
-      return;
-    }
-
-    runtimeCaptured.unlock();
-    // `jsWork` is called somewhere here.
-    jsWorkDone.lock();
-    runtimeCaptureBlockDone.unlock();
-  };
-  runtimeExecutor(std::move(runtimeCaptureBlock));
-
-  runtimeCaptured.lock();
-  jsWork(*runtimePtr);
-  jsWorkDone.unlock();
-  runtimeCaptureBlockDone.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/RuntimeExecutorSyncUIThreadUtils.cpp

@@ -0,0 +1,69 @@
+/*
+ * 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/RuntimeExecutorSyncUIThreadUtils.h>
+#include <mutex>
+#include <thread>
+
+namespace facebook::react {
+/**
+ * Example order of events (when not a sync call in runtimeExecutor
+ * jsWork):
+ * - [UI thread] Lock all mutexes at start
+ * - [UI thread] Schedule "runtime capture block" on js thread
+ * - [UI thread] Wait for runtime capture: runtimeCaptured.lock()
+ * - [JS thread] Capture runtime by setting runtimePtr
+ * - [JS thread] Signal runtime captured: runtimeCaptured.unlock()
+ * - [UI thread] Call jsWork using runtimePtr
+ * - [JS thread] Wait until jsWork done: jsWorkDone.lock()
+ * - [UI thread] Signal jsWork done: jsWorkDone.unlock()
+ * - [UI thread] Wait until runtime capture block finished:
+ *               runtimeCaptureBlockDone.lock()
+ * - [JS thread] Signal runtime capture block is finished:
+ *               runtimeCaptureBlockDone.unlock()
+ */
+void executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+    const RuntimeExecutor& runtimeExecutor,
+    std::function<void(jsi::Runtime& runtime)>&& jsWork) 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 jsWorkDone;
+  std::mutex runtimeCaptureBlockDone;
+
+  runtimeCaptured.lock();
+  jsWorkDone.lock();
+  runtimeCaptureBlockDone.lock();
+
+  jsi::Runtime* runtimePtr;
+
+  auto threadId = std::this_thread::get_id();
+  auto runtimeCaptureBlock = [&](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();
+      runtimeCaptureBlockDone.unlock();
+      return;
+    }
+
+    runtimeCaptured.unlock();
+    // `jsWork` is called somewhere here.
+    jsWorkDone.lock();
+    runtimeCaptureBlockDone.unlock();
+  };
+  runtimeExecutor(std::move(runtimeCaptureBlock));
+
+  runtimeCaptured.lock();
+  jsWork(*runtimePtr);
+  jsWorkDone.unlock();
+  runtimeCaptureBlockDone.lock();
+}
+
+} // namespace facebook::react

packages/react-native/ReactCommon/runtimeexecutor/platform/default/ReactCommon/RuntimeExecutorSyncUIThreadUtils.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/RuntimeExecutorSyncUIThreadUtils.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/RuntimeExecutorSyncUIThreadUtils.mm

@@ -0,0 +1,70 @@
+/*
+ * 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/RuntimeExecutorSyncUIThreadUtils.h>
+#include <mutex>
+#include <thread>
+
+namespace facebook::react {
+/**
+ * Example order of events (when not a sync call in runtimeExecutor
+ * jsWork):
+ * - [UI thread] Lock all mutexes at start
+ * - [UI thread] Schedule "runtime capture block" on js thread
+ * - [UI thread] Wait for runtime capture: runtimeCaptured.lock()
+ * - [JS thread] Capture runtime by setting runtimePtr
+ * - [JS thread] Signal runtime captured: runtimeCaptured.unlock()
+ * - [UI thread] Call jsWork using runtimePtr
+ * - [JS thread] Wait until jsWork done: jsWorkDone.lock()
+ * - [UI thread] Signal jsWork done: jsWorkDone.unlock()
+ * - [UI thread] Wait until runtime capture block finished:
+ *               runtimeCaptureBlockDone.lock()
+ * - [JS thread] Signal runtime capture block is finished:
+ *               runtimeCaptureBlockDone.unlock()
+ */
+void executeSynchronouslyOnSameThread_CAN_DEADLOCK(
+    const RuntimeExecutor &runtimeExecutor,
+    std::function<void(jsi::Runtime &runtime)> &&jsWork) 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 jsWorkDone;
+  std::mutex runtimeCaptureBlockDone;
+
+  runtimeCaptured.lock();
+  jsWorkDone.lock();
+  runtimeCaptureBlockDone.lock();
+
+  jsi::Runtime *runtimePtr;
+
+  auto threadId = std::this_thread::get_id();
+  auto runtimeCaptureBlock = [&](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();
+      runtimeCaptureBlockDone.unlock();
+      return;
+    }
+
+    runtimeCaptured.unlock();
+    // `jsWork` is called somewhere here.
+    jsWorkDone.lock();
+    runtimeCaptureBlockDone.unlock();
+  };
+  runtimeExecutor(std::move(runtimeCaptureBlock));
+
+  runtimeCaptured.lock();
+  jsWork(*runtimePtr);
+  jsWorkDone.unlock();
+  runtimeCaptureBlockDone.lock();
+}
+
+} // namespace facebook::react