Implement maxDuration option for PerformanceTracer (#52935)

Summary:
Pull Request resolved: #52935

Changelog: [internal]

This implements a new option for `PerformanceTracer::startTracing` to specify a maximum duration for the recording, keeping only the last record events.

This will allow us to implement an "always-on" profiling mode for RN with a low overhead. In the future, we can extend this with a `maxBufferSize` option.

See the comment in `PerformanceTracer.cpp` for implementation details.

Reviewed By: hoxyq

Differential Revision: D79340014

fbshipit-source-id: 3260724a775a574fe5e52d47358a3a5abd0d2ee7

Author: rubennorte

packages/react-native/ReactCommon/jsinspector-modern/tracing/PerformanceTracer.cpp

@@ -18,6 +18,15 @@
 
 namespace facebook::react::jsinspector_modern::tracing {
 
+namespace {
+/**
+ * Instead of validating that the indicated duration is positive, we can ensure
+ * the value is sensible (less than 1 seccond doesn't make much sense).
+ */
+const HighResDuration MIN_VALUE_FOR_MAX_TRACE_DURATION_OPTION =
+    HighResDuration::fromMilliseconds(1000); // 1 second
+} // namespace
+
 PerformanceTracer& PerformanceTracer::getInstance() {
   static PerformanceTracer tracer;
   return tracer;
@@ -27,20 +36,38 @@ PerformanceTracer::PerformanceTracer()
     : processId_(oscompat::getCurrentProcessId()) {}
 
 bool PerformanceTracer::startTracing() {
+  return startTracingImpl();
+}
+
+bool PerformanceTracer::startTracing(HighResDuration maxDuration) {
+  return startTracingImpl(maxDuration);
+}
+
+bool PerformanceTracer::startTracingImpl(
+    std::optional<HighResDuration> maxDuration) {
   std::lock_guard lock(mutex_);
 
   if (tracingAtomic_) {
     return false;
   }
 
   tracingAtomic_ = true;
+
+  if (maxDuration && *maxDuration < MIN_VALUE_FOR_MAX_TRACE_DURATION_OPTION) {
+    throw std::invalid_argument("maxDuration should be at least 1 second");
+  }
+
   currentTraceStartTime_ = HighResTimeStamp::now();
+  currentTraceMaxDuration_ = maxDuration;
+
   return true;
 }
 
 std::optional<std::vector<TraceEvent>> PerformanceTracer::stopTracing() {
   std::vector<TraceEvent> events;
 
+  auto currentTraceEndTime = HighResTimeStamp::now();
+
   {
     std::lock_guard lock(mutex_);
 
@@ -50,8 +77,15 @@ std::optional<std::vector<TraceEvent>> PerformanceTracer::stopTracing() {
 
     tracingAtomic_ = false;
     performanceMeasureCount_ = 0;
+    currentTraceMaxDuration_ = std::nullopt;
 
-    buffer_.swap(events);
+    events = collectEventsAndClearBuffers(currentTraceEndTime);
+  }
+
+  auto currentTraceStartTime = currentTraceStartTime_;
+  if (currentTraceMaxDuration_ &&
+      currentTraceEndTime - *currentTraceMaxDuration_ > currentTraceStartTime) {
+    currentTraceStartTime = currentTraceEndTime - *currentTraceMaxDuration_;
   }
 
   // This is synthetic Trace Event, which should not be represented on a
@@ -65,7 +99,7 @@ std::optional<std::vector<TraceEvent>> PerformanceTracer::stopTracing() {
       .name = "TracingStartedInPage",
       .cat = "disabled-by-default-devtools.timeline",
       .ph = 'I',
-      .ts = currentTraceStartTime_,
+      .ts = currentTraceStartTime,
       .pid = processId_,
       .tid = oscompat::getCurrentThreadId(),
       .args = folly::dynamic::object("data", folly::dynamic::object()),
@@ -75,7 +109,7 @@ std::optional<std::vector<TraceEvent>> PerformanceTracer::stopTracing() {
       .name = "ReactNative-TracingStopped",
       .cat = "disabled-by-default-devtools.timeline",
       .ph = 'I',
-      .ts = HighResTimeStamp::now(),
+      .ts = currentTraceEndTime,
       .pid = processId_,
       .tid = oscompat::getCurrentThreadId(),
   });
@@ -302,8 +336,96 @@ PerformanceTracer::constructRuntimeProfileChunkTraceEvent(
   };
 }
 
+#pragma mark - Tracing window methods
+
+/**
+ * If a `maxDuration` value is set when starting a trace, we use 2 buffers
+ * for events. Each buffer can contain entries for a range up to `maxDuration`.
+ * When the current buffer is full, we clear the previous one and we start
+ * collecting events in a new buffer, which becomes current.
+ *
+ * Example:
+ *   - Start:
+ *     previousBuffer: null, currentBuffer: []
+ *   - As entries are added:
+ *     previousBuffer: null, currentBuffer: [a, b, c...]
+ *   - When now - currentBuffer start time > maxDuration:
+ *     previousBuffer: [a, b, c...], currentBuffer: []
+ *   - As entries are added:
+ *     previousbuffer: [a, b, c...], currentBuffer: [x, y, z...]
+ *   - When now - currentBuffer start time > maxDuration:
+ *     previousBuffer: [x, y, z...], currentBuffer: []
+ *   - When the trace finishes:
+ *     We collect all events in both buffers that are still within
+ *     `maxDuration`.
+ *
+ * This way, we ensure we keep all events in the `maxDuration` window, and
+ * clearing expired events is trivial (just clearing a vector).
+ */
+
+std::vector<TraceEvent> PerformanceTracer::collectEventsAndClearBuffers(
+    HighResTimeStamp currentTraceEndTime) {
+  std::vector<TraceEvent> events;
+
+  if (currentTraceMaxDuration_) {
+    // Collect non-expired entries from the previous buffer
+    if (previousBuffer_ != nullptr) {
+      collectEventsAndClearBuffer(
+          events, *previousBuffer_, currentTraceEndTime);
+    }
+
+    collectEventsAndClearBuffer(events, *currentBuffer_, currentTraceEndTime);
+
+    // Reset state.
+    currentBuffer_ = &buffer_;
+    previousBuffer_ = nullptr;
+  } else {
+    // Trivial case.
+    currentBuffer_->swap(events);
+  }
+
+  return events;
+}
+
+void PerformanceTracer::collectEventsAndClearBuffer(
+    std::vector<TraceEvent>& events,
+    std::vector<TraceEvent>& buffer,
+    HighResTimeStamp currentTraceEndTime) {
+  for (auto&& event : buffer) {
+    if (isInTracingWindow(currentTraceEndTime, event.createdAt_)) {
+      events.emplace_back(std::move(event));
+    }
+  }
+
+  buffer.clear();
+  buffer.shrink_to_fit();
+}
+
+bool PerformanceTracer::isInTracingWindow(
+    HighResTimeStamp now,
+    HighResTimeStamp timeStampToCheck) const {
+  if (!currentTraceMaxDuration_) {
+    return true;
+  }
+
+  return timeStampToCheck > now - *currentTraceMaxDuration_;
+}
+
 void PerformanceTracer::enqueueEvent(TraceEvent&& traceEvent) {
-  buffer_.emplace_back(std::move(traceEvent));
+  if (currentTraceMaxDuration_) {
+    // Check if the current buffer is "full"
+    if (traceEvent.createdAt_ >
+        currentBufferStartTime_ + *currentTraceMaxDuration_) {
+      // We moved past the current buffer. We need to switch the other buffer as
+      // current.
+      previousBuffer_ = currentBuffer_;
+      currentBuffer_ = currentBuffer_ == &buffer_ ? &altBuffer_ : &buffer_;
+      currentBuffer_->clear();
+      currentBufferStartTime_ = traceEvent.createdAt_;
+    }
+  }
+
+  currentBuffer_->emplace_back(std::move(traceEvent));
 }
 
 } // namespace facebook::react::jsinspector_modern::tracing

packages/react-native/ReactCommon/jsinspector-modern/tracing/PerformanceTracer.h

@@ -37,6 +37,12 @@ class PerformanceTracer {
    */
   bool startTracing();
 
+  /**
+   * Starts a tracing session with a maximum duration (events older than this
+   * duration are dropped). Returns `false` if already tracing.
+   */
+  bool startTracing(HighResDuration maxDuration);
+
   /**
    * If there is a current tracing session, it stops tracing and returns all
    * collected events. Otherwise, it returns empty.
@@ -151,14 +157,34 @@ class PerformanceTracer {
 
   HighResTimeStamp currentTraceStartTime_;
 
+  std::optional<HighResDuration> currentTraceMaxDuration_;
+
   std::vector<TraceEvent> buffer_;
 
+  // These fields are only used when setting a max duration on the trace.
+  std::vector<TraceEvent> altBuffer_;
+  std::vector<TraceEvent>* currentBuffer_ = &buffer_;
+  std::vector<TraceEvent>* previousBuffer_{};
+  HighResTimeStamp currentBufferStartTime_;
+
   /**
    * Protects data members of this class for concurrent access, including
    * the tracingAtomic_, in order to eliminate potential "logic" races.
    */
   std::mutex mutex_;
 
+  bool startTracingImpl(
+      std::optional<HighResDuration> maxDuration = std::nullopt);
+
+  std::vector<TraceEvent> collectEventsAndClearBuffers(
+      HighResTimeStamp currentTraceEndTime);
+  void collectEventsAndClearBuffer(
+      std::vector<TraceEvent>& events,
+      std::vector<TraceEvent>& buffer,
+      HighResTimeStamp currentTraceEndTime);
+  bool isInTracingWindow(
+      HighResTimeStamp now,
+      HighResTimeStamp timeStampToCheck) const;
   void enqueueEvent(TraceEvent&& event);
 };
 

packages/react-native/ReactCommon/jsinspector-modern/tracing/TraceEvent.h

@@ -66,6 +66,11 @@ struct TraceEvent {
    * complete events ("ph": "X").
    */
   std::optional<HighResDuration> dur;
+
+  /**
+   * This is not part of the Trace Event Format.
+   */
+  HighResTimeStamp createdAt_ = HighResTimeStamp::now();
 };
 
 } // namespace facebook::react::jsinspector_modern::tracing