react-native-tvos 0.76.5-0 → 0.77.0-0

package/ReactCommon/react/nativemodule/webperformance/NativePerformance.cpp

@@ -15,9 +15,14 @@
 #include <cxxreact/ReactMarker.h>
 #include <jsi/instrumentation.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
-#include <reactperflogger/fusebox/FuseboxTracer.h>
+#include <react/performance/timeline/PerformanceObserver.h>
+#include <reactperflogger/ReactPerfLogger.h>
+
 #include "NativePerformance.h"
+
+#ifdef RN_DISABLE_OSS_PLUGIN_HEADER
 #include "Plugins.h"
+#endif
 
 #ifdef WITH_PERFETTO
 #include <reactperflogger/ReactPerfetto.h>
@@ -65,6 +70,40 @@ std::tuple<std::string, std::string_view> parseTrackName(
   return std::make_tuple(trackNameRef, eventName);
 }
 
+class PerformanceObserverWrapper : public jsi::NativeState {
+ public:
+  explicit PerformanceObserverWrapper(
+      const std::shared_ptr<PerformanceObserver> observer)
+      : observer(observer) {}
+
+  const std::shared_ptr<PerformanceObserver> observer;
+};
+
+void sortEntries(std::vector<PerformanceEntry>& entries) {
+  return std::stable_sort(
+      entries.begin(), entries.end(), PerformanceEntrySorter{});
+}
+
+const std::array<PerformanceEntryType, 2> ENTRY_TYPES_AVAILABLE_FROM_TIMELINE{
+    {PerformanceEntryType::MARK, PerformanceEntryType::MEASURE}};
+
+bool isAvailableFromTimeline(PerformanceEntryType entryType) {
+  return entryType == PerformanceEntryType::MARK ||
+      entryType == PerformanceEntryType::MEASURE;
+}
+
+std::shared_ptr<PerformanceObserver> tryGetObserver(
+    jsi::Runtime& rt,
+    jsi::Object& observerObj) {
+  if (!observerObj.hasNativeState(rt)) {
+    return nullptr;
+  }
+
+  auto observerWrapper = std::dynamic_pointer_cast<PerformanceObserverWrapper>(
+      observerObj.getNativeState(rt));
+  return observerWrapper ? observerWrapper->observer : nullptr;
+}
+
 } // namespace
 
 NativePerformance::NativePerformance(std::shared_ptr<CallInvoker> jsInvoker)
@@ -78,22 +117,46 @@ double NativePerformance::now(jsi::Runtime& /*rt*/) {
   return JSExecutor::performanceNow();
 }
 
+double NativePerformance::markWithResult(
+    jsi::Runtime& rt,
+    std::string name,
+    std::optional<double> startTime) {
+  auto [trackName, eventName] = parseTrackName(name);
+  auto entry =
+      PerformanceEntryReporter::getInstance()->reportMark(name, startTime);
+
+  ReactPerfLogger::mark(eventName, entry.startTime, trackName);
+
+  return entry.startTime;
+}
+
+std::tuple<double, double> NativePerformance::measureWithResult(
+    jsi::Runtime& rt,
+    std::string name,
+    double startTime,
+    double endTime,
+    std::optional<double> duration,
+    std::optional<std::string> startMark,
+    std::optional<std::string> endMark) {
+  auto [trackName, eventName] = parseTrackName(name);
+
+  auto entry = PerformanceEntryReporter::getInstance()->reportMeasure(
+      eventName, startTime, endTime, duration, startMark, endMark);
+
+  ReactPerfLogger::measure(
+      eventName, entry.startTime, entry.startTime + entry.duration, trackName);
+
+  return std::tuple{entry.startTime, entry.duration};
+}
+
 void NativePerformance::mark(
     jsi::Runtime& rt,
     std::string name,
     double startTime) {
-  PerformanceEntryReporter::getInstance()->mark(name, startTime);
+  auto [trackName, eventName] = parseTrackName(name);
+  ReactPerfLogger::mark(eventName, startTime, trackName);
 
-#ifdef WITH_PERFETTO
-  if (TRACE_EVENT_CATEGORY_ENABLED("react-native")) {
-    auto [trackName, eventName] = parseTrackName(name);
-    TRACE_EVENT_INSTANT(
-        "react-native",
-        perfetto::DynamicString(eventName.data(), eventName.size()),
-        getPerfettoWebPerfTrackSync(trackName),
-        performanceNowToPerfettoTraceTime(startTime));
-  }
-#endif
+  PerformanceEntryReporter::getInstance()->reportMark(name, startTime);
 }
 
 void NativePerformance::measure(
@@ -106,26 +169,94 @@ void NativePerformance::measure(
     std::optional<std::string> endMark) {
   auto [trackName, eventName] = parseTrackName(name);
 
-  FuseboxTracer::getFuseboxTracer().addEvent(
-      eventName, (uint64_t)startTime, (uint64_t)endTime, trackName);
-  PerformanceEntryReporter::getInstance()->measure(
+  // TODO T190600850 support startMark/endMark
+  if (!startMark && !endMark) {
+    ReactPerfLogger::measure(eventName, startTime, endTime, trackName);
+  }
+
+  PerformanceEntryReporter::getInstance()->reportMeasure(
       eventName, startTime, endTime, duration, startMark, endMark);
+}
 
-#ifdef WITH_PERFETTO
-  if (TRACE_EVENT_CATEGORY_ENABLED("react-native")) {
-    // TODO T190600850 support startMark/endMark
-    if (!startMark && !endMark) {
-      auto track = getPerfettoWebPerfTrackAsync(trackName);
-      TRACE_EVENT_BEGIN(
-          "react-native",
-          perfetto::DynamicString(eventName.data(), eventName.size()),
-          track,
-          performanceNowToPerfettoTraceTime(startTime));
-      TRACE_EVENT_END(
-          "react-native", track, performanceNowToPerfettoTraceTime(endTime));
+void NativePerformance::clearMarks(
+    jsi::Runtime& /*rt*/,
+    std::optional<std::string> entryName) {
+  if (entryName) {
+    PerformanceEntryReporter::getInstance()->clearEntries(
+        PerformanceEntryType::MARK, *entryName);
+  } else {
+    PerformanceEntryReporter::getInstance()->clearEntries(
+        PerformanceEntryType::MARK);
+  }
+}
+
+void NativePerformance::clearMeasures(
+    jsi::Runtime& /*rt*/,
+    std::optional<std::string> entryName) {
+  if (entryName) {
+    PerformanceEntryReporter::getInstance()->clearEntries(
+        PerformanceEntryType::MEASURE, *entryName);
+  } else {
+    PerformanceEntryReporter::getInstance()->clearEntries(
+        PerformanceEntryType::MEASURE);
+  }
+}
+
+std::vector<PerformanceEntry> NativePerformance::getEntries(
+    jsi::Runtime& /*rt*/) {
+  std::vector<PerformanceEntry> entries;
+
+  for (auto entryType : ENTRY_TYPES_AVAILABLE_FROM_TIMELINE) {
+    PerformanceEntryReporter::getInstance()->getEntries(entries, entryType);
+  }
+
+  sortEntries(entries);
+
+  return entries;
+}
+
+std::vector<PerformanceEntry> NativePerformance::getEntriesByName(
+    jsi::Runtime& /*rt*/,
+    std::string entryName,
+    std::optional<PerformanceEntryType> entryType) {
+  std::vector<PerformanceEntry> entries;
+
+  if (entryType) {
+    if (isAvailableFromTimeline(*entryType)) {
+      PerformanceEntryReporter::getInstance()->getEntries(
+          entries, *entryType, entryName);
+    }
+  } else {
+    for (auto type : ENTRY_TYPES_AVAILABLE_FROM_TIMELINE) {
+      PerformanceEntryReporter::getInstance()->getEntries(
+          entries, type, entryName);
     }
   }
-#endif
+
+  sortEntries(entries);
+
+  return entries;
+}
+
+std::vector<PerformanceEntry> NativePerformance::getEntriesByType(
+    jsi::Runtime& /*rt*/,
+    PerformanceEntryType entryType) {
+  std::vector<PerformanceEntry> entries;
+
+  if (isAvailableFromTimeline(entryType)) {
+    PerformanceEntryReporter::getInstance()->getEntries(entries, entryType);
+  }
+
+  sortEntries(entries);
+
+  return entries;
+}
+
+std::vector<std::pair<std::string, uint32_t>> NativePerformance::getEventCounts(
+    jsi::Runtime& /*rt*/) {
+  const auto& eventCounts =
+      PerformanceEntryReporter::getInstance()->getEventCounts();
+  return {eventCounts.begin(), eventCounts.end()};
 }
 
 std::unordered_map<std::string, double> NativePerformance::getSimpleMemoryInfo(
@@ -176,4 +307,106 @@ NativePerformance::getReactNativeStartupTiming(jsi::Runtime& rt) {
   return result;
 }
 
+jsi::Object NativePerformance::createObserver(
+    jsi::Runtime& rt,
+    NativePerformancePerformanceObserverCallback callback) {
+  // The way we dispatch performance observer callbacks is a bit different from
+  // the spec. The specification requires us to queue a single task that
+  // dispatches observer callbacks. Instead, we are queuing all callbacks as
+  // separate tasks in the scheduler.
+  PerformanceObserverCallback cb = [callback = std::move(callback)]() {
+    callback.callWithPriority(SchedulerPriority::IdlePriority);
+  };
+
+  auto& registry =
+      PerformanceEntryReporter::getInstance()->getObserverRegistry();
+
+  auto observer = PerformanceObserver::create(registry, std::move(cb));
+  auto observerWrapper = std::make_shared<PerformanceObserverWrapper>(observer);
+  jsi::Object observerObj{rt};
+  observerObj.setNativeState(rt, observerWrapper);
+  return observerObj;
+}
+
+double NativePerformance::getDroppedEntriesCount(
+    jsi::Runtime& rt,
+    jsi::Object observerObj) {
+  auto observer = tryGetObserver(rt, observerObj);
+
+  if (!observer) {
+    return 0;
+  }
+
+  return observer->getDroppedEntriesCount();
+}
+
+void NativePerformance::observe(
+    jsi::Runtime& rt,
+    jsi::Object observerObj,
+    NativePerformancePerformanceObserverObserveOptions options) {
+  auto observer = tryGetObserver(rt, observerObj);
+
+  if (!observer) {
+    return;
+  }
+
+  auto durationThreshold = options.durationThreshold.value_or(0.0);
+
+  // observer of type multiple
+  if (options.entryTypes.has_value()) {
+    std::unordered_set<PerformanceEntryType> entryTypes;
+    auto rawTypes = options.entryTypes.value();
+
+    for (auto rawType : rawTypes) {
+      entryTypes.insert(Bridging<PerformanceEntryType>::fromJs(rt, rawType));
+    }
+
+    observer->observe(entryTypes);
+  } else { // single
+    auto buffered = options.buffered.value_or(false);
+    if (options.type.has_value()) {
+      observer->observe(
+          static_cast<PerformanceEntryType>(options.type.value()),
+          {.buffered = buffered, .durationThreshold = durationThreshold});
+    }
+  }
+}
+
+void NativePerformance::disconnect(jsi::Runtime& rt, jsi::Object observerObj) {
+  auto observerWrapper = std::dynamic_pointer_cast<PerformanceObserverWrapper>(
+      observerObj.getNativeState(rt));
+
+  if (!observerWrapper) {
+    return;
+  }
+
+  auto observer = observerWrapper->observer;
+  observer->disconnect();
+}
+
+std::vector<PerformanceEntry> NativePerformance::takeRecords(
+    jsi::Runtime& rt,
+    jsi::Object observerObj,
+    bool sort) {
+  auto observerWrapper = std::dynamic_pointer_cast<PerformanceObserverWrapper>(
+      observerObj.getNativeState(rt));
+
+  if (!observerWrapper) {
+    return {};
+  }
+
+  auto observer = observerWrapper->observer;
+  auto records = observer->takeRecords();
+  if (sort) {
+    sortEntries(records);
+  }
+  return records;
+}
+
+std::vector<PerformanceEntryType>
+NativePerformance::getSupportedPerformanceEntryTypes(jsi::Runtime& /*rt*/) {
+  auto supportedEntryTypes = PerformanceEntryReporter::getSupportedEntryTypes();
+  return {supportedEntryTypes.begin(), supportedEntryTypes.end()};
+}
+
 } // namespace facebook::react

package/ReactCommon/react/nativemodule/webperformance/NativePerformance.h

@@ -7,20 +7,74 @@
 
 #pragma once
 
+#if __has_include("rncoreJSI.h") // Cmake headers on Android
+#include "rncoreJSI.h"
+#elif __has_include("FBReactNativeSpecJSI.h") // CocoaPod headers on Apple
+#include "FBReactNativeSpecJSI.h"
+#else
 #include <FBReactNativeSpec/FBReactNativeSpecJSI.h>
+#endif
+
+#include <react/performance/timeline/PerformanceEntry.h>
 #include <memory>
+#include <optional>
 #include <string>
 
 namespace facebook::react {
 
+using NativePerformancePerformanceObserverCallback = AsyncCallback<>;
+using NativePerformancePerformanceObserverObserveOptions =
+    NativePerformancePerformanceObserverInit<
+        // entryTypes
+        std::optional<std::vector<int>>,
+        // type
+        std::optional<int>,
+        // buffered
+        std::optional<bool>,
+        // durationThreshold
+        std::optional<double>>;
+
+template <>
+struct Bridging<PerformanceEntryType> {
+  static PerformanceEntryType fromJs(
+      jsi::Runtime& /*rt*/,
+      const jsi::Value& value) {
+    return static_cast<PerformanceEntryType>(value.asNumber());
+  }
+
+  static jsi::Value toJs(
+      jsi::Runtime& /*rt*/,
+      const PerformanceEntryType& value) {
+    return {static_cast<int>(value)};
+  }
+};
+
+template <>
+struct Bridging<PerformanceEntry>
+    : NativePerformanceRawPerformanceEntryBridging<PerformanceEntry> {};
+
+template <>
+struct Bridging<NativePerformancePerformanceObserverObserveOptions>
+    : NativePerformancePerformanceObserverInitBridging<
+          NativePerformancePerformanceObserverObserveOptions> {};
+
 class NativePerformance : public NativePerformanceCxxSpec<NativePerformance> {
  public:
   NativePerformance(std::shared_ptr<CallInvoker> jsInvoker);
 
+#pragma mark - DOM Performance (High Resolution Time) (https://www.w3.org/TR/hr-time-3/#dom-performance)
+
+  // https://www.w3.org/TR/hr-time-3/#now-method
   double now(jsi::Runtime& rt);
 
+#pragma mark - User Timing Level 3 functions (https://w3c.github.io/user-timing/)
+
+  // https://w3c.github.io/user-timing/#mark-method
+  // TODO delete when `markWithResult` is fully rolled out
   void mark(jsi::Runtime& rt, std::string name, double startTime);
 
+  // https://w3c.github.io/user-timing/#measure-method
+  // TODO delete when `measureWithResult` is fully rolled out
   void measure(
       jsi::Runtime& rt,
       std::string name,
@@ -30,6 +84,81 @@ class NativePerformance : public NativePerformanceCxxSpec<NativePerformance> {
       std::optional<std::string> startMark,
       std::optional<std::string> endMark);
 
+  // https://w3c.github.io/user-timing/#mark-method
+  double markWithResult(
+      jsi::Runtime& rt,
+      std::string name,
+      std::optional<double> startTime);
+
+  // https://w3c.github.io/user-timing/#measure-method
+  std::tuple<double, double> measureWithResult(
+      jsi::Runtime& rt,
+      std::string name,
+      double startTime,
+      double endTime,
+      std::optional<double> duration,
+      std::optional<std::string> startMark,
+      std::optional<std::string> endMark);
+
+  // https://w3c.github.io/user-timing/#clearmarks-method
+  void clearMarks(
+      jsi::Runtime& rt,
+      std::optional<std::string> entryName = std::nullopt);
+
+  // https://w3c.github.io/user-timing/#clearmeasures-method
+  void clearMeasures(
+      jsi::Runtime& rt,
+      std::optional<std::string> entryName = std::nullopt);
+
+#pragma mark - Performance Timeline (https://w3c.github.io/performance-timeline/#performance-timeline)
+
+  // https://www.w3.org/TR/performance-timeline/#getentries-method
+  std::vector<PerformanceEntry> getEntries(jsi::Runtime& rt);
+
+  // https://www.w3.org/TR/performance-timeline/#getentriesbytype-method
+  std::vector<PerformanceEntry> getEntriesByType(
+      jsi::Runtime& rt,
+      PerformanceEntryType entryType);
+
+  // https://www.w3.org/TR/performance-timeline/#getentriesbyname-method
+  std::vector<PerformanceEntry> getEntriesByName(
+      jsi::Runtime& rt,
+      std::string entryName,
+      std::optional<PerformanceEntryType> entryType = std::nullopt);
+
+#pragma mark - Performance Observer (https://w3c.github.io/performance-timeline/#the-performanceobserver-interface)
+
+  jsi::Object createObserver(
+      jsi::Runtime& rt,
+      NativePerformancePerformanceObserverCallback callback);
+
+  // https://www.w3.org/TR/performance-timeline/#dom-performanceobservercallbackoptions-droppedentriescount
+  double getDroppedEntriesCount(jsi::Runtime& rt, jsi::Object observerObj);
+
+  void observe(
+      jsi::Runtime& rt,
+      jsi::Object observer,
+      NativePerformancePerformanceObserverObserveOptions options);
+  void disconnect(jsi::Runtime& rt, jsi::Object observer);
+  std::vector<PerformanceEntry> takeRecords(
+      jsi::Runtime& rt,
+      jsi::Object observerObj,
+      // When called via `observer.takeRecords` it should be in insertion order.
+      // When called via the observer callback, it should be in chronological
+      // order with respect to `startTime`.
+      bool sort);
+
+  std::vector<PerformanceEntryType> getSupportedPerformanceEntryTypes(
+      jsi::Runtime& rt);
+
+#pragma mark - Event Timing API functions (https://www.w3.org/TR/event-timing/)
+
+  // https://www.w3.org/TR/event-timing/#dom-performance-eventcounts
+  std::vector<std::pair<std::string, uint32_t>> getEventCounts(
+      jsi::Runtime& rt);
+
+#pragma mark - Non-standard memory functions
+
   // To align with web API, we will make sure to return three properties
   // (jsHeapSizeLimit, totalJSHeapSize, usedJSHeapSize) + anything needed from
   // the VM side.
@@ -43,6 +172,8 @@ class NativePerformance : public NativePerformanceCxxSpec<NativePerformance> {
   // for heap size information, as double's 2^53 sig bytes is large enough.
   std::unordered_map<std::string, double> getSimpleMemoryInfo(jsi::Runtime& rt);
 
+#pragma mark - RN-specific startup timing
+
   // Collect and return the RN app startup timing information for performance
   // tracking.
   std::unordered_map<std::string, double> getReactNativeStartupTiming(

package/ReactCommon/react/performance/timeline/CircularBuffer.h

@@ -0,0 +1,133 @@
+/*
+ * 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 <algorithm>
+#include <functional>
+#include <vector>
+#include "PerformanceEntry.h"
+
+namespace facebook::react {
+
+/**
+ * A container for storing entries of type T, with the following properties:
+ * - It can only grow up to a specified max size
+ * - It's a circular buffer (the oldest elements are dropped if reached max
+ * size and adding a new element)
+ *
+ * Note that the space for maxSize elements is reserved on construction. This
+ * ensures that pointers to elements remain stable across add() operations.
+ */
+template <class T>
+class CircularBuffer {
+ public:
+  explicit CircularBuffer(size_t maxSize) : maxSize_(maxSize) {
+    entries_.reserve(maxSize_);
+  }
+
+  /**
+   * Adds (pushes) element into the buffer.
+   *
+   * Returns the result of the operation, which will depend on whether the
+   * buffer reached the max allowed size, in which case `true` is returned. If
+   * no items were overridden `false` is returned.
+   */
+  bool add(const T& el) {
+    if (entries_.size() < maxSize_) {
+      // Haven't reached max buffer size yet, just add and grow the buffer
+      entries_.emplace_back(el);
+      return false;
+    } else {
+      // Overwrite the oldest (but already consumed) element in the buffer
+      entries_[position_] = el;
+      position_ = (position_ + 1) % entries_.size();
+      return true;
+    }
+  }
+
+  T& operator[](size_t idx) {
+    return entries_[(position_ + idx) % entries_.size()];
+  }
+
+  size_t size() const {
+    return entries_.size();
+  }
+
+  void clear() {
+    entries_.clear();
+    position_ = 0;
+  }
+
+  /**
+   * Clears buffer entries by predicate
+   */
+  void clear(std::function<bool(const T&)> predicate) {
+    std::vector<T> entries;
+
+    entries.reserve(maxSize_);
+    for (size_t i = 0; i < entries_.size(); i++) {
+      T& el = entries_[(i + position_) % entries_.size()];
+      if (predicate(el)) {
+        continue;
+      }
+
+      entries.push_back(std::move(el));
+    }
+
+    position_ = 0;
+    entries.swap(entries_);
+  }
+
+  /**
+   * Retrieves buffer entries, whether consumed or not
+   */
+  std::vector<T> getEntries() const {
+    std::vector<T> res;
+    getEntries(res);
+    return res;
+  }
+
+  /**
+   * Retrieves buffer entries, whether consumed or not, with predicate
+   */
+  std::vector<T> getEntries(std::function<bool(const T&)> predicate) const {
+    std::vector<T> res;
+    getEntries(res, predicate);
+    return res;
+  }
+
+  void getEntries(std::vector<T>& res) const {
+    const size_t oldSize = res.size();
+    res.resize(oldSize + entries_.size());
+    std::copy(
+        entries_.begin() + position_, entries_.end(), res.begin() + oldSize);
+    std::copy(
+        entries_.begin(),
+        entries_.begin() + position_,
+        res.begin() + oldSize + entries_.size() - position_);
+  }
+
+  void getEntries(std::vector<T>& res, std::function<bool(const T&)> predicate)
+      const {
+    for (size_t i = 0; i < entries_.size(); i++) {
+      const T& el = entries_[(i + position_) % entries_.size()];
+      if (predicate(el)) {
+        res.push_back(el);
+      }
+    }
+  }
+
+ private:
+  std::vector<T> entries_;
+  const size_t maxSize_;
+
+  // Current starting position in the circular buffer:
+  size_t position_{0};
+};
+
+} // namespace facebook::react

package/ReactCommon/react/performance/timeline/PerformanceEntry.h

@@ -0,0 +1,53 @@
+/*
+ * 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 <react/timing/primitives.h>
+#include <optional>
+#include <string>
+#include <unordered_set>
+
+namespace facebook::react {
+
+using PerformanceEntryInteractionId = uint32_t;
+
+enum class PerformanceEntryType {
+  // We need to preserve these values for backwards compatibility.
+  MARK = 1,
+  MEASURE = 2,
+  EVENT = 3,
+  LONGTASK = 4,
+  _NEXT = 5,
+};
+
+struct PerformanceEntry {
+  std::string name;
+  PerformanceEntryType entryType;
+  DOMHighResTimeStamp startTime;
+  DOMHighResTimeStamp duration = 0;
+
+  // For "event" entries only:
+  std::optional<DOMHighResTimeStamp> processingStart;
+  std::optional<DOMHighResTimeStamp> processingEnd;
+  std::optional<PerformanceEntryInteractionId> interactionId;
+};
+
+constexpr size_t NUM_PERFORMANCE_ENTRY_TYPES =
+    (size_t)PerformanceEntryType::_NEXT - 1; // Valid types start from 1.
+
+struct PerformanceEntrySorter {
+  bool operator()(const PerformanceEntry& lhs, const PerformanceEntry& rhs) {
+    if (lhs.startTime != rhs.startTime) {
+      return lhs.startTime < rhs.startTime;
+    } else {
+      return lhs.duration < rhs.duration;
+    }
+  }
+};
+
+} // namespace facebook::react