react-native-tvos 0.75.2-0rc0 → 0.76.0-0rc0

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Modern.cpp

@@ -8,10 +8,10 @@
 #include "RuntimeScheduler_Modern.h"
 #include "SchedulerPriorityUtils.h"
 
-#include <cxxreact/ErrorUtils.h>
 #include <cxxreact/SystraceSection.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/consistency/ScopedShadowTreeRevisionLock.h>
+#include <react/timing/primitives.h>
 #include <react/utils/OnScopeExit.h>
 #include <utility>
 
@@ -32,8 +32,11 @@ std::chrono::milliseconds getResolvedTimeoutForIdleTask(
 
 RuntimeScheduler_Modern::RuntimeScheduler_Modern(
     RuntimeExecutor runtimeExecutor,
-    std::function<RuntimeSchedulerTimePoint()> now)
-    : runtimeExecutor_(std::move(runtimeExecutor)), now_(std::move(now)) {}
+    std::function<RuntimeSchedulerTimePoint()> now,
+    RuntimeSchedulerTaskErrorHandler onTaskError)
+    : runtimeExecutor_(std::move(runtimeExecutor)),
+      now_(std::move(now)),
+      onTaskError_(std::move(onTaskError)) {}
 
 void RuntimeScheduler_Modern::scheduleWork(RawCallback&& callback) noexcept {
   SystraceSection s("RuntimeScheduler::scheduleWork");
@@ -117,9 +120,13 @@ std::shared_ptr<Task> RuntimeScheduler_Modern::scheduleIdleTask(
   return task;
 }
 
-bool RuntimeScheduler_Modern::getShouldYield() const noexcept {
+bool RuntimeScheduler_Modern::getShouldYield() noexcept {
   std::shared_lock lock(schedulingMutex_);
 
+  if (ReactNativeFeatureFlags::enableLongTaskAPI()) {
+    markYieldingOpportunity(now_());
+  }
+
   return syncTaskRequests_ > 0 ||
       (!taskQueue_.empty() && taskQueue_.top().get() != currentTask_);
 }
@@ -158,7 +165,7 @@ void RuntimeScheduler_Modern::executeNowOnTheSameThread(
 
           syncTaskRequests_--;
           runtimePtr = &runtime;
-          executeTask(runtime, task, currentTime);
+          runEventLoopTick(runtime, task, currentTime);
           runtimePtr = nullptr;
         });
 
@@ -166,25 +173,25 @@ void RuntimeScheduler_Modern::executeNowOnTheSameThread(
     // Protecting against re-entry into `executeNowOnTheSameThread` from within
     // `executeNowOnTheSameThread`. Without accounting for re-rentry, a deadlock
     // will occur when trying to gain access to the runtime.
-    return executeTask(*runtimePtr, task, currentTime);
+    return runEventLoopTick(*runtimePtr, task, currentTime);
   }
 
-  bool shouldScheduleWorkLoop = false;
+  bool shouldScheduleEventLoop = false;
 
   {
-    // Unique access because we might write to `isWorkLoopScheduled_`.
+    // Unique access because we might write to `isEventLoopScheduled_`.
     std::unique_lock lock(schedulingMutex_);
 
-    // We only need to schedule the work loop if there any remaining tasks
+    // We only need to schedule the event loop if there any remaining tasks
     // in the queue.
-    if (!taskQueue_.empty() && !isWorkLoopScheduled_) {
-      isWorkLoopScheduled_ = true;
-      shouldScheduleWorkLoop = true;
+    if (!taskQueue_.empty() && !isEventLoopScheduled_) {
+      isEventLoopScheduled_ = true;
+      shouldScheduleEventLoop = true;
     }
   }
 
-  if (shouldScheduleWorkLoop) {
-    scheduleWorkLoop();
+  if (shouldScheduleEventLoop) {
+    scheduleEventLoop();
   }
 }
 
@@ -195,14 +202,16 @@ void RuntimeScheduler_Modern::callExpiredTasks(jsi::Runtime& runtime) {
   }
 
   SystraceSection s("RuntimeScheduler::callExpiredTasks");
-  startWorkLoop(runtime, true);
+  runEventLoop(runtime, true);
 }
 
 void RuntimeScheduler_Modern::scheduleRenderingUpdate(
+    SurfaceId surfaceId,
     RuntimeSchedulerRenderingUpdate&& renderingUpdate) {
   SystraceSection s("RuntimeScheduler::scheduleRenderingUpdate");
 
   if (ReactNativeFeatureFlags::batchRenderingUpdatesInEventLoop()) {
+    surfaceIdsWithPendingRenderingUpdates_.insert(surfaceId);
     pendingRenderingUpdates_.push(renderingUpdate);
   } else {
     if (renderingUpdate != nullptr) {
@@ -217,40 +226,50 @@ void RuntimeScheduler_Modern::setShadowTreeRevisionConsistencyManager(
   shadowTreeRevisionConsistencyManager_ = shadowTreeRevisionConsistencyManager;
 }
 
+void RuntimeScheduler_Modern::setPerformanceEntryReporter(
+    PerformanceEntryReporter* performanceEntryReporter) {
+  performanceEntryReporter_ = performanceEntryReporter;
+}
+
+void RuntimeScheduler_Modern::setEventTimingDelegate(
+    RuntimeSchedulerEventTimingDelegate* eventTimingDelegate) {
+  eventTimingDelegate_ = eventTimingDelegate;
+}
+
 #pragma mark - Private
 
 void RuntimeScheduler_Modern::scheduleTask(std::shared_ptr<Task> task) {
-  bool shouldScheduleWorkLoop = false;
+  bool shouldScheduleEventLoop = false;
 
   {
     std::unique_lock lock(schedulingMutex_);
 
-    // We only need to schedule the work loop if the task we're about to
+    // We only need to schedule the event loop if the task we're about to
     // schedule is the only one in the queue.
     // Otherwise, we don't need to schedule it because there's another one
     // running already that will pick up the new task.
-    if (taskQueue_.empty() && !isWorkLoopScheduled_) {
-      isWorkLoopScheduled_ = true;
-      shouldScheduleWorkLoop = true;
+    if (taskQueue_.empty() && !isEventLoopScheduled_) {
+      isEventLoopScheduled_ = true;
+      shouldScheduleEventLoop = true;
     }
 
     taskQueue_.push(task);
   }
 
-  if (shouldScheduleWorkLoop) {
-    scheduleWorkLoop();
+  if (shouldScheduleEventLoop) {
+    scheduleEventLoop();
   }
 }
 
-void RuntimeScheduler_Modern::scheduleWorkLoop() {
+void RuntimeScheduler_Modern::scheduleEventLoop() {
   runtimeExecutor_(
-      [this](jsi::Runtime& runtime) { startWorkLoop(runtime, false); });
+      [this](jsi::Runtime& runtime) { runEventLoop(runtime, false); });
 }
 
-void RuntimeScheduler_Modern::startWorkLoop(
+void RuntimeScheduler_Modern::runEventLoop(
     jsi::Runtime& runtime,
     bool onlyExpired) {
-  SystraceSection s("RuntimeScheduler::startWorkLoop");
+  SystraceSection s("RuntimeScheduler::runEventLoop");
 
   auto previousPriority = currentPriority_;
 
@@ -264,7 +283,7 @@ void RuntimeScheduler_Modern::startWorkLoop(
       break;
     }
 
-    executeTask(runtime, *topPriorityTask, currentTime);
+    runEventLoopTick(runtime, *topPriorityTask, currentTime);
   }
 
   currentPriority_ = previousPriority;
@@ -279,7 +298,7 @@ std::shared_ptr<Task> RuntimeScheduler_Modern::selectTask(
 
   // It's safe to reset the flag here, as its access is also synchronized with
   // the access to the task queue.
-  isWorkLoopScheduled_ = false;
+  isEventLoopScheduled_ = false;
 
   // Skip executed tasks
   while (!taskQueue_.empty() && !taskQueue_.top()->callback) {
@@ -297,37 +316,41 @@ std::shared_ptr<Task> RuntimeScheduler_Modern::selectTask(
   return nullptr;
 }
 
-void RuntimeScheduler_Modern::executeTask(
+void RuntimeScheduler_Modern::runEventLoopTick(
     jsi::Runtime& runtime,
     Task& task,
-    RuntimeSchedulerTimePoint currentTime) {
-  auto didUserCallbackTimeout = task.expirationTime <= currentTime;
+    RuntimeSchedulerTimePoint taskStartTime) {
+  SystraceSection s("RuntimeScheduler::runEventLoopTick");
 
-  SystraceSection s(
-      "RuntimeScheduler::executeTask",
-      "priority",
-      serialize(task.priority),
-      "didUserCallbackTimeout",
-      didUserCallbackTimeout);
+  ScopedShadowTreeRevisionLock revisionLock(
+      shadowTreeRevisionConsistencyManager_);
 
   currentTask_ = &task;
   currentPriority_ = task.priority;
 
-  {
-    ScopedShadowTreeRevisionLock revisionLock(
-        shadowTreeRevisionConsistencyManager_);
+  if (ReactNativeFeatureFlags::enableLongTaskAPI()) {
+    lastYieldingOpportunity_ = taskStartTime;
+    longestPeriodWithoutYieldingOpportunity_ =
+        std::chrono::milliseconds::zero();
+  }
 
-    executeMacrotask(runtime, task, didUserCallbackTimeout);
+  auto didUserCallbackTimeout = task.expirationTime <= taskStartTime;
+  executeTask(runtime, task, didUserCallbackTimeout);
 
-    if (ReactNativeFeatureFlags::enableMicrotasks()) {
-      // "Perform a microtask checkpoint" step.
-      performMicrotaskCheckpoint(runtime);
-    }
+  if (ReactNativeFeatureFlags::enableMicrotasks()) {
+    // "Perform a microtask checkpoint" step.
+    performMicrotaskCheckpoint(runtime);
+  }
 
-    if (ReactNativeFeatureFlags::batchRenderingUpdatesInEventLoop()) {
-      // "Update the rendering" step.
-      updateRendering();
-    }
+  if (ReactNativeFeatureFlags::enableLongTaskAPI()) {
+    auto taskEndTime = now_();
+    markYieldingOpportunity(taskEndTime);
+    reportLongTasks(task, taskStartTime, taskEndTime);
+  }
+
+  if (ReactNativeFeatureFlags::batchRenderingUpdatesInEventLoop()) {
+    // "Update the rendering" step.
+    updateRendering();
   }
 
   currentTask_ = nullptr;
@@ -341,6 +364,14 @@ void RuntimeScheduler_Modern::executeTask(
 void RuntimeScheduler_Modern::updateRendering() {
   SystraceSection s("RuntimeScheduler::updateRendering");
 
+  if (eventTimingDelegate_ != nullptr &&
+      ReactNativeFeatureFlags::enableReportEventPaintTime()) {
+    eventTimingDelegate_->dispatchPendingEventTimingEntries(
+        surfaceIdsWithPendingRenderingUpdates_);
+  }
+
+  surfaceIdsWithPendingRenderingUpdates_.clear();
+
   while (!pendingRenderingUpdates_.empty()) {
     auto& pendingRenderingUpdate = pendingRenderingUpdates_.front();
     if (pendingRenderingUpdate != nullptr) {
@@ -350,11 +381,16 @@ void RuntimeScheduler_Modern::updateRendering() {
   }
 }
 
-void RuntimeScheduler_Modern::executeMacrotask(
+void RuntimeScheduler_Modern::executeTask(
     jsi::Runtime& runtime,
     Task& task,
     bool didUserCallbackTimeout) const {
-  SystraceSection s("RuntimeScheduler::executeMacrotask");
+  SystraceSection s(
+      "RuntimeScheduler::executeTask",
+      "priority",
+      serialize(task.priority),
+      "didUserCallbackTimeout",
+      didUserCallbackTimeout);
 
   try {
     auto result = task.execute(runtime, didUserCallbackTimeout);
@@ -365,7 +401,7 @@ void RuntimeScheduler_Modern::executeMacrotask(
       task.callback = result.getObject(runtime).getFunction(runtime);
     }
   } catch (jsi::JSError& error) {
-    handleJSError(runtime, error, true);
+    onTaskError_(runtime, error);
   }
 }
 
@@ -399,7 +435,7 @@ void RuntimeScheduler_Modern::performMicrotaskCheckpoint(
         break;
       }
     } catch (jsi::JSError& error) {
-      handleJSError(runtime, error, true);
+      onTaskError_(runtime, error);
     }
     retries++;
   }
@@ -409,4 +445,31 @@ void RuntimeScheduler_Modern::performMicrotaskCheckpoint(
   }
 }
 
+void RuntimeScheduler_Modern::reportLongTasks(
+    const Task& /*task*/,
+    RuntimeSchedulerTimePoint startTime,
+    RuntimeSchedulerTimePoint endTime) {
+  auto reporter = performanceEntryReporter_;
+  if (reporter == nullptr) {
+    return;
+  }
+
+  auto checkedDurationMs =
+      chronoToDOMHighResTimeStamp(longestPeriodWithoutYieldingOpportunity_);
+  if (checkedDurationMs >= LONG_TASK_DURATION_THRESHOLD_MS) {
+    auto durationMs = chronoToDOMHighResTimeStamp(endTime - startTime);
+    auto startTimeMs = chronoToDOMHighResTimeStamp(startTime);
+    reporter->logLongTaskEntry(startTimeMs, durationMs);
+  }
+}
+
+void RuntimeScheduler_Modern::markYieldingOpportunity(
+    RuntimeSchedulerTimePoint currentTime) {
+  auto currentPeriod = currentTime - lastYieldingOpportunity_;
+  if (currentPeriod > longestPeriodWithoutYieldingOpportunity_) {
+    longestPeriodWithoutYieldingOpportunity_ = currentPeriod;
+  }
+  lastYieldingOpportunity_ = currentTime;
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Modern.h

@@ -23,7 +23,8 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
  public:
   explicit RuntimeScheduler_Modern(
       RuntimeExecutor runtimeExecutor,
-      std::function<RuntimeSchedulerTimePoint()> now);
+      std::function<RuntimeSchedulerTimePoint()> now,
+      RuntimeSchedulerTaskErrorHandler onTaskError);
 
   /*
    * Not copyable.
@@ -56,7 +57,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
 
   /*
    * Adds a JavaScript callback to the priority queue with the given priority.
-   * Triggers workloop if needed.
+   * Triggers event loop if needed.
    */
   std::shared_ptr<Task> scheduleTask(
       SchedulerPriority priority,
@@ -64,7 +65,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
 
   /*
    * Adds a custom callback to the priority queue with the given priority.
-   * Triggers workloop if needed.
+   * Triggers event loop if needed.
    */
   std::shared_ptr<Task> scheduleTask(
       SchedulerPriority priority,
@@ -72,7 +73,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
 
   /*
    * Adds a JavaScript callback to the idle queue with the given timeout.
-   * Triggers workloop if needed.
+   * Triggers event loop if needed.
    */
   std::shared_ptr<Task> scheduleIdleTask(
       jsi::Function&& callback,
@@ -81,7 +82,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
 
   /*
    * Adds a custom callback to the idle queue with the given timeout.
-   * Triggers workloop if needed.
+   * Triggers event loop if needed.
    */
   std::shared_ptr<Task> scheduleIdleTask(
       RawCallback&& callback,
@@ -102,7 +103,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    *
    * Can be called from any thread.
    */
-  bool getShouldYield() const noexcept override;
+  bool getShouldYield() noexcept override;
 
   /*
    * Returns value of currently executed task. Designed to be called from React.
@@ -138,12 +139,19 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    * immediately.
    */
   void scheduleRenderingUpdate(
+      SurfaceId surfaceId,
       RuntimeSchedulerRenderingUpdate&& renderingUpdate) override;
 
   void setShadowTreeRevisionConsistencyManager(
       ShadowTreeRevisionConsistencyManager*
           shadowTreeRevisionConsistencyManager) override;
 
+  void setPerformanceEntryReporter(
+      PerformanceEntryReporter* performanceEntryReporter) override;
+
+  void setEventTimingDelegate(
+      RuntimeSchedulerEventTimingDelegate* eventTimingDelegate) override;
+
  private:
   std::atomic<uint_fast8_t> syncTaskRequests_{0};
 
@@ -154,17 +162,21 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
       taskQueue_;
 
   Task* currentTask_{};
+  RuntimeSchedulerTimePoint lastYieldingOpportunity_;
+  RuntimeSchedulerDuration longestPeriodWithoutYieldingOpportunity_{};
+
+  void markYieldingOpportunity(RuntimeSchedulerTimePoint currentTime);
 
   /**
-   * This protects the access to `taskQueue_` and `isWorkLoopScheduled_`.
+   * This protects the access to `taskQueue_` and `isevent loopScheduled_`.
    */
   mutable std::shared_mutex schedulingMutex_;
 
   const RuntimeExecutor runtimeExecutor_;
   SchedulerPriority currentPriority_{SchedulerPriority::NormalPriority};
 
-  void scheduleWorkLoop();
-  void startWorkLoop(jsi::Runtime& runtime, bool onlyExpired);
+  void scheduleEventLoop();
+  void runEventLoop(jsi::Runtime& runtime, bool onlyExpired);
 
   std::shared_ptr<Task> selectTask(
       RuntimeSchedulerTimePoint currentTime,
@@ -178,12 +190,12 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    * In the future, this will include other steps in the Web event loop, like
    * updating the UI in native, executing resize observer callbacks, etc.
    */
-  void executeTask(
+  void runEventLoopTick(
       jsi::Runtime& runtime,
       Task& task,
       RuntimeSchedulerTimePoint currentTime);
 
-  void executeMacrotask(
+  void executeTask(
       jsi::Runtime& runtime,
       Task& task,
       bool didUserCallbackTimeout) const;
@@ -193,6 +205,11 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
   bool performingMicrotaskCheckpoint_{false};
   void performMicrotaskCheckpoint(jsi::Runtime& runtime);
 
+  void reportLongTasks(
+      const Task& task,
+      RuntimeSchedulerTimePoint startTime,
+      RuntimeSchedulerTimePoint endTime);
+
   /*
    * Returns a time point representing the current point in time. May be called
    * from multiple threads.
@@ -203,11 +220,18 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    * Flag indicating if callback on JavaScript queue has been
    * scheduled.
    */
-  bool isWorkLoopScheduled_{false};
+  bool isEventLoopScheduled_{false};
 
   std::queue<RuntimeSchedulerRenderingUpdate> pendingRenderingUpdates_;
+  std::unordered_set<SurfaceId> surfaceIdsWithPendingRenderingUpdates_;
+
   ShadowTreeRevisionConsistencyManager* shadowTreeRevisionConsistencyManager_{
       nullptr};
+
+  PerformanceEntryReporter* performanceEntryReporter_{nullptr};
+  RuntimeSchedulerEventTimingDelegate* eventTimingDelegate_{nullptr};
+
+  RuntimeSchedulerTaskErrorHandler onTaskError_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/tests/RuntimeSchedulerTest.cpp

@@ -10,6 +10,7 @@
 #include <jsi/jsi.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
+#include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #include <memory>
 #include <semaphore>
@@ -42,6 +43,10 @@ class RuntimeSchedulerTestFeatureFlags
     return forcedBatchRenderingUpdatesInEventLoop;
   }
 
+  bool enableLongTaskAPI() override {
+    return true;
+  }
+
  private:
   bool useModernRuntimeScheduler_;
 };
@@ -77,12 +82,19 @@ class RuntimeSchedulerTest : public testing::TestWithParam<bool> {
       return stubClock_->getNow();
     };
 
+    performanceEntryReporter_ = PerformanceEntryReporter::getInstance().get();
+
+    performanceEntryReporter_->startReporting(PerformanceEntryType::LONGTASK);
+
     runtimeScheduler_ =
         std::make_unique<RuntimeScheduler>(runtimeExecutor, stubNow);
+
+    runtimeScheduler_->setPerformanceEntryReporter(performanceEntryReporter_);
   }
 
   void TearDown() override {
     ReactNativeFeatureFlags::dangerouslyReset();
+    performanceEntryReporter_->popPendingEntries();
   }
 
   jsi::Function createHostFunctionFromLambda(
@@ -109,6 +121,7 @@ class RuntimeSchedulerTest : public testing::TestWithParam<bool> {
   std::unique_ptr<StubQueue> stubQueue_;
   std::unique_ptr<RuntimeScheduler> runtimeScheduler_;
   std::shared_ptr<StubErrorUtils> stubErrorUtils_;
+  PerformanceEntryReporter* performanceEntryReporter_{};
 };
 
 TEST_P(RuntimeSchedulerTest, now) {
@@ -157,7 +170,7 @@ TEST_P(RuntimeSchedulerTest, scheduleNonBatchedRenderingUpdate) {
   bool didRunRenderingUpdate = false;
 
   runtimeScheduler_->scheduleRenderingUpdate(
-      [&]() { didRunRenderingUpdate = true; });
+      0, [&]() { didRunRenderingUpdate = true; });
 
   EXPECT_TRUE(didRunRenderingUpdate);
 }
@@ -182,7 +195,7 @@ TEST_P(
     taskPosition = nextOperationPosition;
     nextOperationPosition++;
 
-    runtimeScheduler_->scheduleRenderingUpdate([&]() {
+    runtimeScheduler_->scheduleRenderingUpdate(0, [&]() {
       updateRenderingPosition = nextOperationPosition;
       nextOperationPosition++;
     });
@@ -1166,6 +1179,140 @@ TEST_P(RuntimeSchedulerTest, errorInTaskShouldNotStopMicrotasks) {
   EXPECT_EQ(stubErrorUtils_->getReportFatalCallCount(), 1);
 }
 
+TEST_P(RuntimeSchedulerTest, reportsLongTasks) {
+  // Only for modern runtime scheduler
+  if (!GetParam()) {
+    return;
+  }
+
+  bool didRunTask1 = false;
+  stubClock_->setTimePoint(10ms);
+
+  auto callback1 = createHostFunctionFromLambda([&](bool /* unused */) {
+    didRunTask1 = true;
+
+    stubClock_->advanceTimeBy(10ms);
+
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(callback1));
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(didRunTask1, 1);
+  EXPECT_EQ(stubQueue_->size(), 0);
+  auto pendingEntries = performanceEntryReporter_->popPendingEntries();
+  EXPECT_EQ(pendingEntries.entries.size(), 0);
+
+  bool didRunTask2 = false;
+  stubClock_->setTimePoint(100ms);
+
+  auto callback2 = createHostFunctionFromLambda([&](bool /* unused */) {
+    didRunTask2 = true;
+
+    stubClock_->advanceTimeBy(50ms);
+
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(callback2));
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(didRunTask2, 1);
+  EXPECT_EQ(stubQueue_->size(), 0);
+  pendingEntries = performanceEntryReporter_->popPendingEntries();
+  EXPECT_EQ(pendingEntries.entries.size(), 1);
+  EXPECT_EQ(
+      pendingEntries.entries[0].entryType, PerformanceEntryType::LONGTASK);
+  EXPECT_EQ(pendingEntries.entries[0].startTime, 100);
+  EXPECT_EQ(pendingEntries.entries[0].duration, 50);
+}
+
+TEST_P(RuntimeSchedulerTest, reportsLongTasksWithYielding) {
+  // Only for modern runtime scheduler
+  if (!GetParam()) {
+    return;
+  }
+
+  bool didRunTask1 = false;
+  stubClock_->setTimePoint(10ms);
+
+  auto callback1 = createHostFunctionFromLambda([&](bool /* unused */) {
+    // The task executes for 80ms, but all the interval between getShouldYield
+    // are shorter than 50ms
+    didRunTask1 = true;
+
+    stubClock_->advanceTimeBy(20ms);
+
+    runtimeScheduler_->getShouldYield();
+
+    stubClock_->advanceTimeBy(20ms);
+
+    runtimeScheduler_->getShouldYield();
+
+    stubClock_->advanceTimeBy(20ms);
+
+    runtimeScheduler_->getShouldYield();
+
+    stubClock_->advanceTimeBy(20ms);
+
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(callback1));
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(didRunTask1, 1);
+  EXPECT_EQ(stubQueue_->size(), 0);
+  auto pendingEntries = performanceEntryReporter_->popPendingEntries();
+  EXPECT_EQ(pendingEntries.entries.size(), 0);
+
+  bool didRunTask2 = false;
+  stubClock_->setTimePoint(100ms);
+
+  auto callback2 = createHostFunctionFromLambda([&](bool /* unused */) {
+    // The task executes for 100ms, and one of the intervals is longer than 50.
+    didRunTask2 = true;
+
+    stubClock_->advanceTimeBy(20ms);
+
+    runtimeScheduler_->getShouldYield();
+
+    // Long period!
+    stubClock_->advanceTimeBy(60ms);
+
+    runtimeScheduler_->getShouldYield();
+
+    stubClock_->advanceTimeBy(20ms);
+
+    runtimeScheduler_->getShouldYield();
+
+    stubClock_->advanceTimeBy(20ms);
+
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(callback2));
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(didRunTask2, 1);
+  EXPECT_EQ(stubQueue_->size(), 0);
+  pendingEntries = performanceEntryReporter_->popPendingEntries();
+  EXPECT_EQ(pendingEntries.entries.size(), 1);
+  EXPECT_EQ(
+      pendingEntries.entries[0].entryType, PerformanceEntryType::LONGTASK);
+  EXPECT_EQ(pendingEntries.entries[0].startTime, 100);
+  EXPECT_EQ(pendingEntries.entries[0].duration, 120);
+}
+
 INSTANTIATE_TEST_SUITE_P(
     UseModernRuntimeScheduler,
     RuntimeSchedulerTest,