react-native-tvos 0.78.0-0rc4 → 0.79.0-0rc2

package/ReactCommon/jsinspector-modern/tracing/PerformanceTracer.cpp

@@ -7,20 +7,21 @@
 
 #include "PerformanceTracer.h"
 
+#include <oscompat/OSCompat.h>
+
 #include <folly/json.h>
 
 #include <mutex>
-#include <unordered_set>
 
 namespace facebook::react::jsinspector_modern {
 
 namespace {
 
-/** Process ID for all emitted events. */
-const uint64_t PID = 1000;
-
-/** Default/starting track ID for the "Timings" track. */
-const uint64_t USER_TIMINGS_DEFAULT_TRACK = 1000;
+uint64_t getUnixTimestampOfNow() {
+  return std::chrono::duration_cast<std::chrono::microseconds>(
+             std::chrono::steady_clock::now().time_since_epoch())
+      .count();
+}
 
 } // namespace
 
@@ -29,91 +30,98 @@ PerformanceTracer& PerformanceTracer::getInstance() {
   return tracer;
 }
 
+PerformanceTracer::PerformanceTracer()
+    : processId_(oscompat::getCurrentProcessId()) {}
+
 bool PerformanceTracer::startTracing() {
-  std::lock_guard lock(mutex_);
-  if (tracing_) {
-    return false;
+  {
+    std::lock_guard lock(mutex_);
+    if (tracing_) {
+      return false;
+    }
+
+    tracing_ = true;
+  }
+
+  reportProcess(processId_, "React Native");
+
+  {
+    std::lock_guard lock(mutex_);
+    buffer_.push_back(TraceEvent{
+        .name = "TracingStartedInPage",
+        .cat = "disabled-by-default-devtools.timeline",
+        .ph = 'I',
+        .ts = getUnixTimestampOfNow(),
+        .pid = processId_,
+        .tid = oscompat::getCurrentThreadId(),
+        .args = folly::dynamic::object("data", folly::dynamic::object()),
+    });
+
+    return true;
   }
-  tracing_ = true;
-  return true;
 }
 
-bool PerformanceTracer::stopTracingAndCollectEvents(
-    const std::function<void(const folly::dynamic& eventsChunk)>&
-        resultCallback) {
+bool PerformanceTracer::stopTracing() {
   std::lock_guard lock(mutex_);
-
   if (!tracing_) {
     return false;
   }
 
-  tracing_ = false;
-  if (buffer_.empty()) {
-    customTrackIdMap_.clear();
-    return true;
-  }
-
-  // Register "Main" process
-  buffer_.push_back(TraceEvent{
-      .name = "process_name",
-      .cat = "__metadata",
-      .ph = 'M',
-      .ts = 0,
-      .pid = PID,
-      .tid = 0,
-      .args = folly::dynamic::object("name", "Main"),
-  });
-  // Register "Timings" track
-  // NOTE: This is a hack to make the Trace Viewer show a "Timings" track
-  // adjacent to custom tracks in our current build of Chrome DevTools.
-  // In future, we should align events exactly.
+  // This is synthetic Trace Event, which should not be represented on a
+  // timeline. CDT is not using Profile or ProfileChunk events for determining
+  // trace timeline window, this is why trace that only contains JavaScript
+  // samples will be displayed as empty. We use this event to avoid that.
+  // This could happen for non-bridgeless apps, where Performance interface is
+  // not supported and no spec-compliant Event Loop implementation.
   buffer_.push_back(TraceEvent{
-      .name = "thread_name",
-      .cat = "__metadata",
-      .ph = 'M',
-      .ts = 0,
-      .pid = PID,
-      .tid = USER_TIMINGS_DEFAULT_TRACK,
-      .args = folly::dynamic::object("name", "Timings"),
+      .name = "ReactNative-TracingStopped",
+      .cat = "disabled-by-default-devtools.timeline",
+      .ph = 'I',
+      .ts = getUnixTimestampOfNow(),
+      .pid = processId_,
+      .tid = oscompat::getCurrentThreadId(),
   });
 
-  for (const auto& [trackName, trackId] : customTrackIdMap_) {
-    // Register custom tracks
-    buffer_.push_back(TraceEvent{
-        .name = "thread_name",
-        .cat = "__metadata",
-        .ph = 'M',
-        .ts = 0,
-        .pid = PID,
-        .tid = trackId,
-        .args = folly::dynamic::object("name", trackName),
-    });
+  performanceMeasureCount_ = 0;
+  profileCount_ = 0;
+  tracing_ = false;
+  return true;
+}
+
+void PerformanceTracer::collectEvents(
+    const std::function<void(const folly::dynamic& eventsChunk)>&
+        resultCallback,
+    uint16_t chunkSize) {
+  std::lock_guard lock(mutex_);
+
+  if (buffer_.empty()) {
+    return;
   }
 
   auto traceEvents = folly::dynamic::array();
-
   for (auto event : buffer_) {
     // Emit trace events
     traceEvents.push_back(serializeTraceEvent(event));
 
-    if (traceEvents.size() >= 1000) {
+    if (traceEvents.size() == chunkSize) {
       resultCallback(traceEvents);
       traceEvents = folly::dynamic::array();
     }
   }
-  customTrackIdMap_.clear();
-  buffer_.clear();
-
-  if (traceEvents.size() >= 1) {
+  if (!traceEvents.empty()) {
     resultCallback(traceEvents);
   }
 
-  return true;
+  buffer_.clear();
 }
 
 void PerformanceTracer::reportMark(
     const std::string_view& name,
     uint64_t start) {
+  if (!tracing_) {
+    return;
+  }
+
   std::lock_guard<std::mutex> lock(mutex_);
   if (!tracing_) {
     return;
@@ -124,9 +132,8 @@ void PerformanceTracer::reportMark(
       .cat = "blink.user_timing",
       .ph = 'I',
       .ts = start,
-      .pid = PID, // FIXME: This should be the real process ID.
-      .tid = USER_TIMINGS_DEFAULT_TRACK, // FIXME: This should be the real
-                                         // thread ID.
+      .pid = processId_,
+      .tid = oscompat::getCurrentThreadId(),
   });
 }
 
@@ -135,41 +142,184 @@ void PerformanceTracer::reportMeasure(
     uint64_t start,
     uint64_t duration,
     const std::optional<DevToolsTrackEntryPayload>& trackMetadata) {
+  if (!tracing_) {
+    return;
+  }
+
   std::lock_guard<std::mutex> lock(mutex_);
   if (!tracing_) {
     return;
   }
 
-  // NOTE: We synthetically create custom tracks as a hack to render them in
-  // our current build of Chrome DevTools frontend.
-  // TODO: Remove and align with web.
-  uint64_t threadId = USER_TIMINGS_DEFAULT_TRACK;
+  folly::dynamic beginEventArgs = folly::dynamic::object();
   if (trackMetadata.has_value()) {
-    std::string trackName = trackMetadata.value().track;
-
-    if (!customTrackIdMap_.contains(trackName)) {
-      uint64_t trackId =
-          USER_TIMINGS_DEFAULT_TRACK + customTrackIdMap_.size() + 1;
-      threadId = trackId;
-
-      customTrackIdMap_.emplace(trackName, trackId);
-    }
+    folly::dynamic devtoolsObject = folly::dynamic::object(
+        "devtools",
+        folly::dynamic::object("track", trackMetadata.value().track));
+    beginEventArgs =
+        folly::dynamic::object("detail", folly::toJson(devtoolsObject));
   }
 
+  ++performanceMeasureCount_;
+  auto currentThreadId = oscompat::getCurrentThreadId();
   buffer_.push_back(TraceEvent{
+      .id = performanceMeasureCount_,
       .name = std::string(name),
       .cat = "blink.user_timing",
+      .ph = 'b',
+      .ts = start,
+      .pid = processId_,
+      .tid = currentThreadId,
+      .args = beginEventArgs,
+  });
+  buffer_.push_back(TraceEvent{
+      .id = performanceMeasureCount_,
+      .name = std::string(name),
+      .cat = "blink.user_timing",
+      .ph = 'e',
+      .ts = start + duration,
+      .pid = processId_,
+      .tid = currentThreadId,
+  });
+}
+
+void PerformanceTracer::reportProcess(uint64_t id, const std::string& name) {
+  if (!tracing_) {
+    return;
+  }
+
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (!tracing_) {
+    return;
+  }
+
+  buffer_.push_back(TraceEvent{
+      .name = "process_name",
+      .cat = "__metadata",
+      .ph = 'M',
+      .ts = 0,
+      .pid = id,
+      .tid = 0,
+      .args = folly::dynamic::object("name", name),
+  });
+}
+
+void PerformanceTracer::reportJavaScriptThread() {
+  reportThread(oscompat::getCurrentThreadId(), "JavaScript");
+}
+
+void PerformanceTracer::reportThread(uint64_t id, const std::string& name) {
+  if (!tracing_) {
+    return;
+  }
+
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (!tracing_) {
+    return;
+  }
+
+  buffer_.push_back(TraceEvent{
+      .name = "thread_name",
+      .cat = "__metadata",
+      .ph = 'M',
+      .ts = 0,
+      .pid = processId_,
+      .tid = id,
+      .args = folly::dynamic::object("name", name),
+  });
+
+  // This is synthetic Trace Event, which should not be represented on a
+  // timeline. CDT will filter out threads that only have JavaScript samples and
+  // no timeline events or user timings. We use this event to avoid that.
+  // This could happen for non-bridgeless apps, where Performance interface is
+  // not supported and no spec-compliant Event Loop implementation.
+  buffer_.push_back(TraceEvent{
+      .name = "ReactNative-ThreadRegistered",
+      .cat = "disabled-by-default-devtools.timeline",
+      .ph = 'I',
+      .ts = 0,
+      .pid = processId_,
+      .tid = id,
+  });
+}
+
+uint16_t PerformanceTracer::reportRuntimeProfile(
+    uint64_t threadId,
+    uint64_t eventUnixTimestamp) {
+  std::lock_guard lock(mutex_);
+  if (!tracing_) {
+    throw std::runtime_error(
+        "Runtime Profile should only be reported when Tracing is enabled");
+  }
+
+  ++profileCount_;
+  // CDT prioritizes event timestamp over startTime metadata field.
+  // https://fburl.com/lo764pf4
+  buffer_.push_back(TraceEvent{
+      .id = profileCount_,
+      .name = "Profile",
+      .cat = "disabled-by-default-v8.cpu_profiler",
+      .ph = 'P',
+      .ts = eventUnixTimestamp,
+      .pid = processId_,
+      .tid = threadId,
+      .args = folly::dynamic::object(
+          "data", folly ::dynamic::object("startTime", eventUnixTimestamp)),
+  });
+
+  return profileCount_;
+}
+
+void PerformanceTracer::reportRuntimeProfileChunk(
+    uint16_t profileId,
+    uint64_t threadId,
+    uint64_t eventUnixTimestamp,
+    const tracing::TraceEventProfileChunk& traceEventProfileChunk) {
+  std::lock_guard lock(mutex_);
+  if (!tracing_) {
+    return;
+  }
+
+  buffer_.push_back(TraceEvent{
+      .id = profileId,
+      .name = "ProfileChunk",
+      .cat = "disabled-by-default-v8.cpu_profiler",
+      .ph = 'P',
+      .ts = eventUnixTimestamp,
+      .pid = processId_,
+      .tid = threadId,
+      .args =
+          folly::dynamic::object("data", traceEventProfileChunk.asDynamic()),
+  });
+}
+
+void PerformanceTracer::reportEventLoopTask(uint64_t start, uint64_t end) {
+  if (!tracing_) {
+    return;
+  }
+
+  std::lock_guard lock(mutex_);
+  if (!tracing_) {
+    return;
+  }
+
+  buffer_.push_back(TraceEvent{
+      .name = "RunTask",
+      .cat = "disabled-by-default-devtools.timeline",
       .ph = 'X',
       .ts = start,
-      .pid = PID, // FIXME: This should be the real process ID.
-      .tid = threadId, // FIXME: This should be the real thread ID.
-      .dur = duration,
+      .pid = oscompat::getCurrentProcessId(),
+      .tid = oscompat::getCurrentThreadId(),
+      .dur = end - start,
   });
 }
 
 folly::dynamic PerformanceTracer::serializeTraceEvent(TraceEvent event) const {
   folly::dynamic result = folly::dynamic::object;
 
+  if (event.id.has_value()) {
+    result["id"] = folly::sformat("0x{:X}", event.id.value());
+  }
   result["name"] = event.name;
   result["cat"] = event.cat;
   result["ph"] = std::string(1, event.ph);

package/ReactCommon/jsinspector-modern/tracing/PerformanceTracer.h

@@ -8,12 +8,14 @@
 #pragma once
 
 #include "CdpTracing.h"
+#include "TraceEvent.h"
+#include "TraceEventProfile.h"
 
 #include <folly/dynamic.h>
 
 #include <functional>
+#include <mutex>
 #include <optional>
-#include <unordered_map>
 #include <vector>
 
 namespace facebook::react::jsinspector_modern {
@@ -21,51 +23,6 @@ namespace facebook::react::jsinspector_modern {
 // TODO: Review how this API is integrated into jsinspector_modern (singleton
 // design is copied from earlier FuseboxTracer prototype).
 
-namespace {
-
-/**
- * A trace event to send to the debugger frontend, as defined by the Trace Event
- * Format.
- * https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview?pli=1&tab=t.0#heading=h.yr4qxyxotyw
- */
-struct TraceEvent {
-  /** The name of the event, as displayed in the Trace Viewer. */
-  std::string name;
-
-  /**
-   * A comma separated list of categories for the event, configuring how
-   * events are shown in the Trace Viewer UI.
-   */
-  std::string cat;
-
-  /**
-   * The event type. This is a single character which changes depending on the
-   * type of event being output. See
-   * https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview?pli=1&tab=t.0#heading=h.puwqg050lyuy
-   */
-  char ph;
-
-  /** The tracing clock timestamp of the event, in microseconds (µs). */
-  uint64_t ts;
-
-  /** The process ID for the process that output this event. */
-  uint64_t pid;
-
-  /** The thread ID for the process that output this event. */
-  uint64_t tid;
-
-  /** Any arguments provided for the event. */
-  folly::dynamic args = folly::dynamic::object();
-
-  /**
-   * The duration of the event, in microseconds (µs). Only applicable to
-   * complete events ("ph": "X").
-   */
-  std::optional<uint64_t> dur;
-};
-
-} // namespace
-
 /**
  * [Experimental] An interface for logging performance trace events to the
  * modern debugger server.
@@ -80,15 +37,28 @@ class PerformanceTracer {
   bool startTracing();
 
   /**
-   * End tracing, and output chunked CDP trace events using the given
-   * callback.
-   *
-   * Returns `false` if tracing was not started.
+   * Mark trace session as stopped. Returns `false` if wasn't tracing.
    */
-  bool stopTracingAndCollectEvents(
-      const std::function<void(const folly::dynamic& eventsChunk)>&
-          resultCallback);
+  bool stopTracing();
 
+  /**
+   * Returns whether the tracer is currently tracing. This can be useful to
+   * avoid doing expensive work (like formatting strings) if tracing is not
+   * enabled.
+   */
+  bool isTracing() const {
+    // This is not thread safe but it's only a performance optimization. The
+    // call to report marks and measures is already thread safe.
+    return tracing_;
+  }
+
+  /**
+   * Flush out buffered CDP Trace Events using the given callback.
+   */
+  void collectEvents(
+      const std::function<void(const folly::dynamic& eventsChunk)>&
+          resultCallback,
+      uint16_t chunkSize);
   /**
    * Record a `Performance.mark()` event - a labelled timestamp. If not
    * currently tracing, this is a no-op.
@@ -109,8 +79,45 @@ class PerformanceTracer {
       uint64_t duration,
       const std::optional<DevToolsTrackEntryPayload>& trackMetadata);
 
+  /**
+   * Record a corresponding Trace Event for OS-level process.
+   */
+  void reportProcess(uint64_t id, const std::string& name);
+
+  /**
+   * Record a corresponding Trace Event for OS-level thread.
+   */
+  void reportThread(uint64_t id, const std::string& name);
+
+  /**
+   * Should only be called from the JavaScript thread, will buffer metadata
+   * Trace Event.
+   */
+  void reportJavaScriptThread();
+
+  /**
+   * Record a corresponding Profile Trace Event.
+   * \return the id of the profile, should be used to linking profile chunks.
+   */
+  uint16_t reportRuntimeProfile(uint64_t threadId, uint64_t eventUnixTimestamp);
+
+  /**
+   * Record a corresponding ProfileChunk Trace Event.
+   */
+  void reportRuntimeProfileChunk(
+      uint16_t profileId,
+      uint64_t threadId,
+      uint64_t eventUnixTimestamp,
+      const tracing::TraceEventProfileChunk& traceEventProfileChunk);
+
+  /**
+   * Record an Event Loop tick, which will be represented as an Event Loop task
+   * on a timeline view and grouped with JavaScript samples.
+   */
+  void reportEventLoopTask(uint64_t start, uint64_t end);
+
  private:
-  PerformanceTracer() = default;
+  PerformanceTracer();
   PerformanceTracer(const PerformanceTracer&) = delete;
   PerformanceTracer& operator=(const PerformanceTracer&) = delete;
   ~PerformanceTracer() = default;
@@ -118,7 +125,9 @@ class PerformanceTracer {
   folly::dynamic serializeTraceEvent(TraceEvent event) const;
 
   bool tracing_{false};
-  std::unordered_map<std::string, uint64_t> customTrackIdMap_;
+  uint64_t processId_;
+  uint32_t performanceMeasureCount_{0};
+  uint16_t profileCount_{0};
   std::vector<TraceEvent> buffer_;
   std::mutex mutex_;
 };

package/ReactCommon/jsinspector-modern/tracing/ProfileTreeNode.h

@@ -0,0 +1,111 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include "RuntimeSamplingProfile.h"
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+/*
+ * Auxiliary data structure used for creating Profile tree and identifying
+ * identical frames.
+ */
+class ProfileTreeNode {
+ public:
+  /*
+   * For Chromium & V8 this could also be WASM, this is not the case for us.
+   */
+  enum class CodeType {
+    JavaScript,
+    Other,
+  };
+
+  ProfileTreeNode(
+      uint32_t id,
+      CodeType codeType,
+      ProfileTreeNode* parent,
+      RuntimeSamplingProfile::SampleCallStackFrame callFrame)
+      : id_(id),
+        codeType_(codeType),
+        parent_(parent),
+        callFrame_(std::move(callFrame)) {}
+
+  uint32_t getId() const {
+    return id_;
+  }
+
+  CodeType getCodeType() const {
+    return codeType_;
+  }
+
+  /**
+   * \return pointer to the parent node, nullptr if this is the root node.
+   */
+  ProfileTreeNode* getParent() const {
+    return parent_;
+  }
+
+  /**
+   * \return call frame information that is represented by this node.
+   */
+  const RuntimeSamplingProfile::SampleCallStackFrame& getCallFrame() const {
+    return callFrame_;
+  }
+
+  /**
+   * Will only add unique child node. Returns pointer to the already existing
+   * child node, nullptr if the added child node is unique.
+   */
+  ProfileTreeNode* addChild(ProfileTreeNode* child) {
+    for (auto existingChild : children_) {
+      if (*existingChild == child) {
+        return existingChild;
+      }
+    }
+
+    children_.push_back(child);
+    return nullptr;
+  }
+
+  bool operator==(const ProfileTreeNode* rhs) const {
+    if (this->parent_ != rhs->parent_) {
+      return false;
+    }
+    if (this->codeType_ != rhs->codeType_) {
+      return false;
+    }
+
+    return this->getCallFrame() == rhs->getCallFrame();
+  }
+
+ private:
+  /**
+   *  Unique id of the node.
+   */
+  uint32_t id_;
+  /**
+   * Type of the code that is represented by this node. Either JavaScript or
+   * Other.
+   */
+  CodeType codeType_;
+  /**
+   * Pointer to the parent node. Should be nullptr only for root node.
+   */
+  ProfileTreeNode* parent_{nullptr};
+  /**
+   * Lst of pointers to children nodes.
+   */
+  std::vector<ProfileTreeNode*> children_{};
+  /**
+   * Information about the corresponding call frame that is represented by this
+   * node.
+   */
+  RuntimeSamplingProfile::SampleCallStackFrame callFrame_;
+};
+
+} // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsinspector-modern/tracing/React-jsinspectortracing.podspec

@@ -53,4 +53,5 @@ Pod::Spec.new do |s|
   end
 
   s.dependency "RCT-Folly"
+  s.dependency "React-oscompat"
 end