react-native 0.71.4 → 0.72.0-rc.0

package/Libraries/WebPerformance/PerformanceEntryReporter.cpp

@@ -0,0 +1,408 @@
+/*
+ * 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 "PerformanceEntryReporter.h"
+#include <cxxreact/JSExecutor.h>
+#include <react/renderer/core/EventLogger.h>
+#include "NativePerformanceObserver.h"
+
+#include <unordered_map>
+
+// All the unflushed entries beyond this amount will get discarded, with
+// the amount of discarded ones sent back to the observers' callbacks as
+// "droppedEntryCount" value
+static constexpr size_t MAX_ENTRY_BUFFER_SIZE = 1024;
+
+namespace facebook::react {
+EventTag PerformanceEntryReporter::sCurrentEventTag_{0};
+
+RawPerformanceEntry PerformanceMark::toRawPerformanceEntry() const {
+  return {
+      name,
+      static_cast<int>(PerformanceEntryType::MARK),
+      timeStamp,
+      0.0,
+      std::nullopt,
+      std::nullopt,
+      std::nullopt};
+}
+
+RawPerformanceEntry PerformanceMeasure::toRawPerformanceEntry() const {
+  return {
+      name,
+      static_cast<int>(PerformanceEntryType::MEASURE),
+      timeStamp,
+      duration,
+      std::nullopt,
+      std::nullopt,
+      std::nullopt};
+}
+
+PerformanceEntryReporter &PerformanceEntryReporter::getInstance() {
+  static PerformanceEntryReporter instance;
+  return instance;
+}
+
+void PerformanceEntryReporter::setReportingCallback(
+    std::optional<AsyncCallback<>> callback) {
+  callback_ = callback;
+}
+
+void PerformanceEntryReporter::startReporting(PerformanceEntryType entryType) {
+  int entryTypeIdx = static_cast<int>(entryType);
+  reportingType_[entryTypeIdx] = true;
+  durationThreshold_[entryTypeIdx] = DEFAULT_DURATION_THRESHOLD;
+}
+
+void PerformanceEntryReporter::setDurationThreshold(
+    PerformanceEntryType entryType,
+    double durationThreshold) {
+  durationThreshold_[static_cast<int>(entryType)] = durationThreshold;
+}
+
+void PerformanceEntryReporter::stopReporting(PerformanceEntryType entryType) {
+  reportingType_[static_cast<int>(entryType)] = false;
+}
+
+void PerformanceEntryReporter::stopReporting() {
+  reportingType_.fill(false);
+}
+
+GetPendingEntriesResult PerformanceEntryReporter::popPendingEntries() {
+  std::lock_guard<std::mutex> lock(entriesMutex_);
+
+  GetPendingEntriesResult res = {std::move(entries_), droppedEntryCount_};
+  entries_ = {};
+  droppedEntryCount_ = 0;
+  return res;
+}
+
+void PerformanceEntryReporter::logEntry(const RawPerformanceEntry &entry) {
+  const auto entryType = static_cast<PerformanceEntryType>(entry.entryType);
+  if (entryType == PerformanceEntryType::EVENT) {
+    eventCounts_[entry.name]++;
+  }
+
+  if (!isReporting(entryType)) {
+    return;
+  }
+
+  if (entry.duration < durationThreshold_[entry.entryType]) {
+    // The entries duration is lower than the desired reporting threshold, skip
+    // return;
+  }
+
+  std::lock_guard<std::mutex> lock(entriesMutex_);
+
+  if (entries_.size() == MAX_ENTRY_BUFFER_SIZE) {
+    // Start dropping entries once reached maximum buffer size.
+    // The number of dropped entries will be reported back to the corresponding
+    // PerformanceObserver callback.
+    droppedEntryCount_ += 1;
+    return;
+  }
+
+  entries_.emplace_back(entry);
+
+  if (entries_.size() == 1) {
+    // If the buffer was empty, it signals that JS side just has possibly
+    // consumed it and is ready to get more
+    scheduleFlushBuffer();
+  }
+}
+
+void PerformanceEntryReporter::mark(
+    const std::string &name,
+    double startTime,
+    double duration) {
+  // Register the mark for further possible "measure" lookup, as well as add
+  // it to a circular buffer:
+  PerformanceMark &mark = marksBuffer_[marksBufferPosition_];
+  marksBufferPosition_ = (marksBufferPosition_ + 1) % marksBuffer_.size();
+  marksCount_ = std::min(marksBuffer_.size(), marksCount_ + 1);
+
+  if (!mark.name.empty()) {
+    // Drop off the oldest mark out of the queue, but only if that's indeed the
+    // oldest one
+    auto it = marksRegistry_.find(&mark);
+    if (it != marksRegistry_.end() && *it == &mark) {
+      marksRegistry_.erase(it);
+    }
+  }
+
+  mark.name = name;
+  mark.timeStamp = startTime;
+  marksRegistry_.insert(&mark);
+
+  logEntry(
+      {name,
+       static_cast<int>(PerformanceEntryType::MARK),
+       startTime,
+       duration,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt});
+}
+
+void PerformanceEntryReporter::clearEntries(
+    PerformanceEntryType entryType,
+    const char *entryName) {
+  if (entryType == PerformanceEntryType::MARK ||
+      entryType == PerformanceEntryType::UNDEFINED) {
+    if (entryName != nullptr) {
+      // remove a named mark from the mark/measure registry
+      PerformanceMark mark{{entryName, 0}};
+      marksRegistry_.erase(&mark);
+
+      clearCircularBuffer(
+          marksBuffer_, marksCount_, marksBufferPosition_, entryName);
+    } else {
+      marksCount_ = 0;
+      marksRegistry_.clear();
+    }
+  }
+
+  if (entryType == PerformanceEntryType::MEASURE ||
+      entryType == PerformanceEntryType::UNDEFINED) {
+    if (entryName != nullptr) {
+      clearCircularBuffer(
+          measuresBuffer_, measuresCount_, measuresBufferPosition_, entryName);
+    } else {
+      measuresCount_ = 0;
+    }
+  }
+
+  int lastPos = entries_.size() - 1;
+  int pos = lastPos;
+  while (pos >= 0) {
+    const RawPerformanceEntry &entry = entries_[pos];
+    if (entry.entryType == static_cast<int32_t>(entryType) &&
+        (entryName == nullptr || entry.name == entryName)) {
+      entries_[pos] = entries_[lastPos];
+      lastPos--;
+    }
+    pos--;
+  }
+  entries_.resize(lastPos + 1);
+}
+
+std::vector<RawPerformanceEntry> PerformanceEntryReporter::getEntries(
+    PerformanceEntryType entryType,
+    const char *entryName) const {
+  if (entryType == PerformanceEntryType::MARK) {
+    return getCircularBufferContents(
+        marksBuffer_, marksCount_, marksBufferPosition_, entryName);
+  } else if (entryType == PerformanceEntryType::MEASURE) {
+    return getCircularBufferContents(
+        measuresBuffer_, measuresCount_, measuresBufferPosition_, entryName);
+  } else if (entryType == PerformanceEntryType::UNDEFINED) {
+    auto marks = getCircularBufferContents(
+        marksBuffer_, marksCount_, marksBufferPosition_, entryName);
+    auto measures = getCircularBufferContents(
+        measuresBuffer_, measuresCount_, measuresBufferPosition_, entryName);
+    marks.insert(marks.end(), measures.begin(), measures.end());
+    return marks;
+  }
+  return {};
+}
+
+void PerformanceEntryReporter::measure(
+    const std::string &name,
+    double startTime,
+    double endTime,
+    const std::optional<double> &duration,
+    const std::optional<std::string> &startMark,
+    const std::optional<std::string> &endMark) {
+  double startTimeVal = startMark ? getMarkTime(*startMark) : startTime;
+  double endTimeVal = endMark ? getMarkTime(*endMark) : endTime;
+  double durationVal = duration ? *duration : endTimeVal - startTimeVal;
+
+  measuresBuffer_[measuresBufferPosition_] =
+      PerformanceMeasure{name, startTime, endTime};
+  measuresBufferPosition_ =
+      (measuresBufferPosition_ + 1) % measuresBuffer_.size();
+  measuresCount_ = std::min(measuresBuffer_.size(), measuresCount_ + 1);
+
+  logEntry(
+      {name,
+       static_cast<int>(PerformanceEntryType::MEASURE),
+       startTimeVal,
+       durationVal,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt});
+}
+
+double PerformanceEntryReporter::getMarkTime(
+    const std::string &markName) const {
+  PerformanceMark mark{{std::move(markName), 0}};
+  auto it = marksRegistry_.find(&mark);
+  if (it != marksRegistry_.end()) {
+    return (*it)->timeStamp;
+  } else {
+    return 0.0;
+  }
+}
+
+void PerformanceEntryReporter::event(
+    std::string name,
+    double startTime,
+    double duration,
+    double processingStart,
+    double processingEnd,
+    uint32_t interactionId) {
+  logEntry(
+      {std::move(name),
+       static_cast<int>(PerformanceEntryType::EVENT),
+       startTime,
+       duration,
+       processingStart,
+       processingEnd,
+       interactionId});
+}
+
+void PerformanceEntryReporter::scheduleFlushBuffer() {
+  if (callback_) {
+    callback_->callWithPriority(SchedulerPriority::IdlePriority);
+  }
+}
+
+struct StrKey {
+  uint32_t key;
+  constexpr StrKey(const char *s)
+      : key(folly::hash::fnv32_buf(s, sizeof(s) - 1)) {}
+
+  constexpr bool operator==(const StrKey &rhs) const {
+    return key == rhs.key;
+  }
+};
+
+struct StrKeyHash {
+  constexpr size_t operator()(const StrKey &strKey) const {
+    return static_cast<size_t>(strKey.key);
+  }
+};
+
+// Supported events for reporting, see
+// https://www.w3.org/TR/event-timing/#sec-events-exposed
+// Not all of these are currently supported by RN, but we map them anyway for
+// future-proofing.
+using SupportedEventTypeRegistry =
+    std::unordered_map<StrKey, const char *, StrKeyHash>;
+
+static const SupportedEventTypeRegistry &getSupportedEvents() {
+  static SupportedEventTypeRegistry SUPPORTED_EVENTS = {
+      {"topAuxClick", "auxclick"},
+      {"topClick", "click"},
+      {"topContextMenu", "contextmenu"},
+      {"topDblClick", "dblclick"},
+      {"topMouseDown", "mousedown"},
+      {"topMouseEnter", "mouseenter"},
+      {"topMouseLeave", "mouseleave"},
+      {"topMouseOut", "mouseout"},
+      {"topMouseOver", "mouseover"},
+      {"topMouseUp", "mouseup"},
+      {"topPointerOver", "pointerover"},
+      {"topPointerEnter", "pointerenter"},
+      {"topPointerDown", "pointerdown"},
+      {"topPointerUp", "pointerup"},
+      {"topPointerCancel", "pointercancel"},
+      {"topPointerOut", "pointerout"},
+      {"topPointerLeave", "pointerleave"},
+      {"topGotPointerCapture", "gotpointercapture"},
+      {"topLostPointerCapture", "lostpointercapture"},
+      {"topTouchStart", "touchstart"},
+      {"topTouchEnd", "touchend"},
+      {"topTouchCancel", "touchcancel"},
+      {"topKeyDown", "keydown"},
+      {"topKeyPress", "keypress"},
+      {"topKeyUp", "keyup"},
+      {"topBeforeInput", "beforeinput"},
+      {"topInput", "input"},
+      {"topCompositionStart", "compositionstart"},
+      {"topCompositionUpdate", "compositionupdate"},
+      {"topCompositionEnd", "compositionend"},
+      {"topDragStart", "dragstart"},
+      {"topDragEnd", "dragend"},
+      {"topDragEnter", "dragenter"},
+      {"topDragLeave", "dragleave"},
+      {"topDragOver", "dragover"},
+      {"topDrop", "drop"},
+  };
+  return SUPPORTED_EVENTS;
+}
+
+EventTag PerformanceEntryReporter::onEventStart(const char *name) {
+  if (!isReportingEvents()) {
+    return 0;
+  }
+  const auto &supportedEvents = getSupportedEvents();
+  auto it = supportedEvents.find(name);
+  if (it == supportedEvents.end()) {
+    return 0;
+  }
+
+  const char *reportedName = it->second;
+
+  sCurrentEventTag_++;
+  if (sCurrentEventTag_ == 0) {
+    // The tag wrapped around (which is highly unlikely, but still)
+    sCurrentEventTag_ = 1;
+  }
+
+  auto timeStamp = JSExecutor::performanceNow();
+  {
+    std::lock_guard<std::mutex> lock(eventsInFlightMutex_);
+    eventsInFlight_.emplace(std::make_pair(
+        sCurrentEventTag_, EventEntry{reportedName, timeStamp, 0.0}));
+  }
+  return sCurrentEventTag_;
+}
+
+void PerformanceEntryReporter::onEventDispatch(EventTag tag) {
+  if (!isReportingEvents() || tag == 0) {
+    return;
+  }
+  auto timeStamp = JSExecutor::performanceNow();
+  {
+    std::lock_guard<std::mutex> lock(eventsInFlightMutex_);
+    auto it = eventsInFlight_.find(tag);
+    if (it != eventsInFlight_.end()) {
+      it->second.dispatchTime = timeStamp;
+    }
+  }
+}
+
+void PerformanceEntryReporter::onEventEnd(EventTag tag) {
+  if (!isReportingEvents() || tag == 0) {
+    return;
+  }
+  auto timeStamp = JSExecutor::performanceNow();
+  {
+    std::lock_guard<std::mutex> lock(eventsInFlightMutex_);
+    auto it = eventsInFlight_.find(tag);
+    if (it == eventsInFlight_.end()) {
+      return;
+    }
+    auto &entry = it->second;
+    auto &name = entry.name;
+
+    // TODO: Define the way to assign interaction IDs to the event chains
+    // (T141358175)
+    const uint32_t interactionId = 0;
+    event(
+        name,
+        entry.startTime,
+        timeStamp - entry.startTime,
+        entry.dispatchTime,
+        timeStamp,
+        interactionId);
+    eventsInFlight_.erase(it);
+  }
+}
+
+} // namespace facebook::react

package/Libraries/WebPerformance/PerformanceEntryReporter.h

@@ -0,0 +1,219 @@
+/*
+ * 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/bridging/Function.h>
+#include <react/renderer/core/EventLogger.h>
+#include <array>
+#include <functional>
+#include <mutex>
+#include <optional>
+#include <unordered_map>
+#include <unordered_set>
+#include "NativePerformanceObserver.h"
+
+namespace facebook::react {
+
+struct PerformanceMark {
+  std::string name;
+  double timeStamp;
+
+  RawPerformanceEntry toRawPerformanceEntry() const;
+};
+
+struct PerformanceMarkHash {
+  size_t operator()(const PerformanceMark *mark) const {
+    return std::hash<std::string>()(mark->name);
+  }
+};
+
+struct PerformanceMarkEqual {
+  bool operator()(const PerformanceMark *lhs, const PerformanceMark *rhs)
+      const {
+    return lhs->name == rhs->name;
+  }
+};
+
+struct PerformanceMeasure {
+  std::string name;
+  double timeStamp;
+  double duration;
+
+  RawPerformanceEntry toRawPerformanceEntry() const;
+};
+
+using PerformanceMarkRegistryType = std::
+    unordered_set<PerformanceMark *, PerformanceMarkHash, PerformanceMarkEqual>;
+
+// Only the MARKS_BUFFER_SIZE amount of the latest marks will be kept in
+// memory for the sake of the "Performance.measure" mark name lookup
+constexpr size_t MARKS_BUFFER_SIZE = 1024;
+
+// Limit buffer size for the measures kept in memory (only keep the latest ones)
+constexpr size_t MEASURES_BUFFER_SIZE = 1024;
+
+constexpr double DEFAULT_DURATION_THRESHOLD = 0.0;
+
+enum class PerformanceEntryType {
+  UNDEFINED = 0,
+  MARK = 1,
+  MEASURE = 2,
+  EVENT = 3,
+  _COUNT = 4,
+};
+
+class PerformanceEntryReporter : public EventLogger {
+ public:
+  PerformanceEntryReporter(PerformanceEntryReporter const &) = delete;
+  void operator=(PerformanceEntryReporter const &) = delete;
+
+  // NOTE: This class is not thread safe, make sure that the calls are made from
+  // the same thread.
+  // TODO: Consider passing it as a parameter to the corresponding modules at
+  // creation time instead of having the singleton.
+  static PerformanceEntryReporter &getInstance();
+
+  void setReportingCallback(std::optional<AsyncCallback<>> callback);
+  void startReporting(PerformanceEntryType entryType);
+  void stopReporting(PerformanceEntryType entryType);
+  void stopReporting();
+  void setDurationThreshold(
+      PerformanceEntryType entryType,
+      double durationThreshold);
+
+  GetPendingEntriesResult popPendingEntries();
+  void logEntry(const RawPerformanceEntry &entry);
+
+  bool isReporting(PerformanceEntryType entryType) const {
+    return reportingType_[static_cast<int>(entryType)];
+  }
+
+  bool isReportingEvents() const {
+    return isReporting(PerformanceEntryType::EVENT);
+  }
+
+  uint32_t getDroppedEntryCount() const {
+    return droppedEntryCount_;
+  }
+
+  void mark(const std::string &name, double startTime, double duration);
+
+  void measure(
+      const std::string &name,
+      double startTime,
+      double endTime,
+      const std::optional<double> &duration = std::nullopt,
+      const std::optional<std::string> &startMark = std::nullopt,
+      const std::optional<std::string> &endMark = std::nullopt);
+
+  void clearEntries(
+      PerformanceEntryType entryType = PerformanceEntryType::UNDEFINED,
+      const char *entryName = nullptr);
+
+  std::vector<RawPerformanceEntry> getEntries(
+      PerformanceEntryType entryType = PerformanceEntryType::UNDEFINED,
+      const char *entryName = nullptr) const;
+
+  void event(
+      std::string name,
+      double startTime,
+      double duration,
+      double processingStart,
+      double processingEnd,
+      uint32_t interactionId);
+
+  EventTag onEventStart(const char *name) override;
+  void onEventDispatch(EventTag tag) override;
+  void onEventEnd(EventTag tag) override;
+
+  const std::unordered_map<std::string, uint32_t> &getEventCounts() const {
+    return eventCounts_;
+  }
+
+ private:
+  std::optional<AsyncCallback<>> callback_;
+  std::vector<RawPerformanceEntry> entries_;
+  std::mutex entriesMutex_;
+  std::array<bool, (size_t)PerformanceEntryType::_COUNT> reportingType_{false};
+  std::unordered_map<std::string, uint32_t> eventCounts_;
+  std::array<double, (size_t)PerformanceEntryType::_COUNT> durationThreshold_{
+      DEFAULT_DURATION_THRESHOLD};
+
+  // Mark registry for "measure" lookup
+  PerformanceMarkRegistryType marksRegistry_;
+  std::array<PerformanceMark, MARKS_BUFFER_SIZE> marksBuffer_;
+  size_t marksBufferPosition_{0};
+  size_t marksCount_{0};
+
+  std::array<PerformanceMeasure, MEASURES_BUFFER_SIZE> measuresBuffer_;
+  size_t measuresBufferPosition_{0};
+  size_t measuresCount_{0};
+
+  uint32_t droppedEntryCount_{0};
+
+  struct EventEntry {
+    const char *name;
+    double startTime{0.0};
+    double dispatchTime{0.0};
+  };
+
+  // Registry to store the events that are currently ongoing.
+  // Note that we could probably use a more efficient container for that,
+  // but since we only report discrete events, the volume is normally low,
+  // so a hash map should be just fine.
+  std::unordered_map<EventTag, EventEntry> eventsInFlight_;
+  std::mutex eventsInFlightMutex_;
+
+  static EventTag sCurrentEventTag_;
+
+  PerformanceEntryReporter() {}
+
+  double getMarkTime(const std::string &markName) const;
+  void scheduleFlushBuffer();
+
+  template <class T, size_t N>
+  std::vector<RawPerformanceEntry> getCircularBufferContents(
+      const std::array<T, N> &buffer,
+      size_t entryCount,
+      size_t bufferPosition,
+      const char *entryName = nullptr) const {
+    std::vector<RawPerformanceEntry> res;
+    size_t pos = (bufferPosition - entryCount + buffer.size()) % buffer.size();
+    for (size_t i = 0; i < entryCount; i++) {
+      if (entryName == nullptr || buffer[pos].name == entryName) {
+        res.push_back(buffer[pos].toRawPerformanceEntry());
+      }
+      pos = (pos + 1) % buffer.size();
+    }
+    return res;
+  }
+
+  template <class T, size_t N>
+  void clearCircularBuffer(
+      std::array<T, N> &buffer,
+      size_t &entryCount,
+      size_t &bufferPosition,
+      const char *entryName) const {
+    std::array<T, N> newBuffer;
+    size_t newEntryCount = 0;
+
+    size_t pos = (bufferPosition - entryCount + buffer.size()) % buffer.size();
+    for (size_t i = 0; i < entryCount; i++) {
+      if (buffer[pos].name != entryName) {
+        newBuffer[newEntryCount++] = buffer[pos];
+      }
+      pos = (pos + 1) % buffer.size();
+    }
+
+    buffer = newBuffer;
+    bufferPosition = newEntryCount;
+    entryCount = newEntryCount;
+  }
+};
+
+} // namespace facebook::react

package/Libraries/WebPerformance/PerformanceEventTiming.js

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ *
+ * @format
+ * @flow strict
+ */
+
+import type {HighResTimeStamp} from './PerformanceEntry';
+
+import {PerformanceEntry} from './PerformanceEntry';
+
+export class PerformanceEventTiming extends PerformanceEntry {
+  processingStart: HighResTimeStamp;
+  processingEnd: HighResTimeStamp;
+  interactionId: number;
+
+  constructor(init: {
+    name: string,
+    startTime?: HighResTimeStamp,
+    duration?: HighResTimeStamp,
+    processingStart?: HighResTimeStamp,
+    processingEnd?: HighResTimeStamp,
+    interactionId?: number,
+  }) {
+    super({
+      name: init.name,
+      entryType: 'event',
+      startTime: init.startTime ?? 0,
+      duration: init.duration ?? 0,
+    });
+    this.processingStart = init.processingStart ?? 0;
+    this.processingEnd = init.processingEnd ?? 0;
+    this.interactionId = init.interactionId ?? 0;
+  }
+}