react-native-tvos 0.78.0-0rc3 → 0.79.0-0

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

@@ -0,0 +1,163 @@
+/*
+ * 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 <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+/// Contains relevant information about the sampled runtime from start to
+/// finish.
+struct RuntimeSamplingProfile {
+ public:
+  /// Represents a single frame inside the captured sample stack.
+  struct SampleCallStackFrame {
+    /// Represents type of frame inside of recorded call stack.
+    enum class Kind {
+      JSFunction, /// JavaScript function frame.
+      NativeFunction, /// Native built-in functions, like arrayPrototypeMap.
+      HostFunction, /// Native functions, defined by Host, a.k.a. Host
+                    /// functions.
+      GarbageCollector, /// Garbage collection frame.
+    };
+
+   public:
+    SampleCallStackFrame(
+        const Kind kind,
+        const uint32_t scriptId,
+        std::string functionName,
+        std::optional<std::string> url = std::nullopt,
+        const std::optional<uint32_t>& lineNumber = std::nullopt,
+        const std::optional<uint32_t>& columnNumber = std::nullopt)
+        : kind_(kind),
+          scriptId_(scriptId),
+          functionName_(std::move(functionName)),
+          url_(std::move(url)),
+          lineNumber_(lineNumber),
+          columnNumber_(columnNumber) {}
+
+    /// \return type of the call stack frame.
+    Kind getKind() const {
+      return kind_;
+    }
+
+    /// \return id of the corresponding script in the VM.
+    uint32_t getScriptId() const {
+      return scriptId_;
+    }
+
+    /// \return name of the function that represents call frame.
+    const std::string& getFunctionName() const {
+      return functionName_;
+    }
+
+    bool hasUrl() const {
+      return url_.has_value();
+    }
+
+    /// \return source url of the corresponding script in the VM.
+    const std::string& getUrl() const {
+      return url_.value();
+    }
+
+    bool hasLineNumber() const {
+      return lineNumber_.has_value();
+    }
+
+    /// \return 0-based line number of the corresponding call frame.
+    uint32_t getLineNumber() const {
+      return lineNumber_.value();
+    }
+
+    bool hasColumnNumber() const {
+      return columnNumber_.has_value();
+    }
+
+    /// \return 0-based column number of the corresponding call frame.
+    uint32_t getColumnNumber() const {
+      return columnNumber_.value();
+    }
+
+    inline bool operator==(const SampleCallStackFrame& rhs) const noexcept {
+      return kind_ == rhs.kind_ && scriptId_ == rhs.scriptId_ &&
+          functionName_ == rhs.functionName_ && url_ == rhs.url_ &&
+          lineNumber_ == rhs.lineNumber_ && columnNumber_ == rhs.columnNumber_;
+    }
+
+   private:
+    Kind kind_;
+    uint32_t scriptId_;
+    std::string functionName_;
+    std::optional<std::string> url_;
+    std::optional<uint32_t> lineNumber_;
+    std::optional<uint32_t> columnNumber_;
+  };
+
+  /// A pair of a timestamp and a snapshot of the call stack at this point in
+  /// time.
+  struct Sample {
+   public:
+    Sample(
+        uint64_t timestamp,
+        uint64_t threadId,
+        std::vector<SampleCallStackFrame> callStack)
+        : timestamp_(timestamp),
+          threadId_(threadId),
+          callStack_(std::move(callStack)) {}
+
+    /// \return serialized unix timestamp in microseconds granularity. The
+    /// moment when this sample was recorded.
+    uint64_t getTimestamp() const {
+      return timestamp_;
+    }
+
+    /// \return thread id where sample was recorded.
+    uint64_t getThreadId() const {
+      return threadId_;
+    }
+
+    /// \return a snapshot of the call stack. The first element of the vector is
+    /// the lowest frame in the stack.
+    const std::vector<SampleCallStackFrame>& getCallStack() const {
+      return callStack_;
+    }
+
+   private:
+    /// When the call stack snapshot was taken (μs).
+    uint64_t timestamp_;
+    /// Thread id where sample was recorded.
+    uint64_t threadId_;
+    /// Snapshot of the call stack. The first element of the vector is
+    /// the lowest frame in the stack.
+    std::vector<SampleCallStackFrame> callStack_;
+  };
+
+  RuntimeSamplingProfile(std::string runtimeName, std::vector<Sample> samples)
+      : runtimeName_(std::move(runtimeName)), samples_(std::move(samples)) {}
+
+  /// \return name of the JavaScript runtime, where sampling occurred.
+  const std::string& getRuntimeName() const {
+    return runtimeName_;
+  }
+
+  /// \return list of recorded samples, should be chronologically sorted.
+  const std::vector<Sample>& getSamples() const {
+    return samples_;
+  }
+
+ private:
+  /// Name of the runtime, where sampling occurred: Hermes, V8, etc.
+  std::string runtimeName_;
+  /// List of recorded samples, should be chronologically sorted.
+  std::vector<Sample> samples_;
+};
+
+} // namespace facebook::react::jsinspector_modern::tracing

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

@@ -0,0 +1,231 @@
+/*
+ * 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 "RuntimeSamplingProfileTraceEventSerializer.h"
+#include "ProfileTreeNode.h"
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+namespace {
+
+uint64_t formatTimePointToUnixTimestamp(
+    std::chrono::steady_clock::time_point timestamp) {
+  return std::chrono::duration_cast<std::chrono::microseconds>(
+             timestamp.time_since_epoch())
+      .count();
+}
+
+TraceEventProfileChunk::CPUProfile::Node convertToTraceEventProfileNode(
+    ProfileTreeNode* node) {
+  ProfileTreeNode* nodeParent = node->getParent();
+  const RuntimeSamplingProfile::SampleCallStackFrame& callFrame =
+      node->getCallFrame();
+  auto traceEventCallFrame =
+      TraceEventProfileChunk::CPUProfile::Node::CallFrame{
+          node->getCodeType() == ProfileTreeNode::CodeType::JavaScript
+              ? "JS"
+              : "other",
+          callFrame.getScriptId(),
+          callFrame.getFunctionName(),
+          callFrame.hasUrl() ? std::optional<std::string>(callFrame.getUrl())
+                             : std::nullopt,
+          callFrame.hasLineNumber()
+              ? std::optional<uint32_t>(callFrame.getLineNumber())
+              : std::nullopt,
+          callFrame.hasColumnNumber()
+              ? std::optional<uint32_t>(callFrame.getColumnNumber())
+              : std::nullopt};
+
+  return TraceEventProfileChunk::CPUProfile::Node{
+      node->getId(),
+      traceEventCallFrame,
+      nodeParent != nullptr ? std::optional<uint32_t>(nodeParent->getId())
+                            : std::nullopt};
+}
+
+void emitSingleProfileChunk(
+    PerformanceTracer& performanceTracer,
+    uint16_t profileId,
+    uint64_t threadId,
+    uint64_t chunkTimestamp,
+    std::vector<ProfileTreeNode*>& nodes,
+    std::vector<uint32_t>& samples,
+    std::vector<long long>& timeDeltas) {
+  std::vector<TraceEventProfileChunk::CPUProfile::Node> traceEventNodes;
+  traceEventNodes.reserve(nodes.size());
+  for (ProfileTreeNode* node : nodes) {
+    traceEventNodes.push_back(convertToTraceEventProfileNode(node));
+  }
+
+  performanceTracer.reportRuntimeProfileChunk(
+      profileId,
+      threadId,
+      chunkTimestamp,
+      TraceEventProfileChunk{
+          TraceEventProfileChunk::CPUProfile{traceEventNodes, samples},
+          TraceEventProfileChunk::TimeDeltas{timeDeltas},
+      });
+}
+
+} // namespace
+
+/* static */ void
+RuntimeSamplingProfileTraceEventSerializer::serializeAndBuffer(
+    PerformanceTracer& performanceTracer,
+    const RuntimeSamplingProfile& profile,
+    std::chrono::steady_clock::time_point tracingStartTime,
+    uint16_t profileChunkSize) {
+  std::vector<RuntimeSamplingProfile::Sample> runtimeSamples =
+      profile.getSamples();
+  if (runtimeSamples.empty()) {
+    return;
+  }
+
+  uint64_t chunkThreadId = runtimeSamples.front().getThreadId();
+  uint64_t tracingStartUnixTimestamp =
+      formatTimePointToUnixTimestamp(tracingStartTime);
+  uint16_t profileId = performanceTracer.reportRuntimeProfile(
+      chunkThreadId, tracingStartUnixTimestamp);
+
+  uint32_t nodeCount = 0;
+  auto* rootNode = new ProfileTreeNode(
+      ++nodeCount,
+      ProfileTreeNode::CodeType::Other,
+      nullptr,
+      RuntimeSamplingProfile::SampleCallStackFrame{
+          RuntimeSamplingProfile::SampleCallStackFrame::Kind::JSFunction,
+          0,
+          "(root)"});
+  auto* programNode = new ProfileTreeNode(
+      ++nodeCount,
+      ProfileTreeNode::CodeType::Other,
+      rootNode,
+      RuntimeSamplingProfile::SampleCallStackFrame{
+          RuntimeSamplingProfile::SampleCallStackFrame::Kind::JSFunction,
+          0,
+          "(program)"});
+  auto* idleNode = new ProfileTreeNode(
+      ++nodeCount,
+      ProfileTreeNode::CodeType::Other,
+      rootNode,
+      RuntimeSamplingProfile::SampleCallStackFrame{
+          RuntimeSamplingProfile::SampleCallStackFrame::Kind::JSFunction,
+          0,
+          "(idle)"});
+
+  rootNode->addChild(programNode);
+  rootNode->addChild(idleNode);
+
+  // Ideally, we should use a timestamp from Runtime Sampling Profiler.
+  // We currently use tracingStartTime, which is defined in TracingAgent.
+  uint64_t previousSampleTimestamp = tracingStartUnixTimestamp;
+  // There could be any number of new nodes in this chunk. Empty if all nodes
+  // are already emitted in previous chunks.
+  std::vector<ProfileTreeNode*> nodesInThisChunk;
+  nodesInThisChunk.push_back(rootNode);
+  nodesInThisChunk.push_back(programNode);
+  nodesInThisChunk.push_back(idleNode);
+
+  std::vector<uint32_t> samplesInThisChunk;
+  samplesInThisChunk.reserve(profileChunkSize);
+  std::vector<long long> timeDeltasInThisChunk;
+  timeDeltasInThisChunk.reserve(profileChunkSize);
+
+  RuntimeSamplingProfile::SampleCallStackFrame garbageCollectorCallFrame =
+      RuntimeSamplingProfile::SampleCallStackFrame{
+          RuntimeSamplingProfile::SampleCallStackFrame::Kind::GarbageCollector,
+          0,
+          "(garbage collector)"};
+  uint64_t chunkTimestamp = tracingStartUnixTimestamp;
+  for (const RuntimeSamplingProfile::Sample& sample : runtimeSamples) {
+    uint64_t sampleThreadId = sample.getThreadId();
+    // If next sample was recorded on a different thread, emit the current chunk
+    // and continue.
+    if (chunkThreadId != sampleThreadId) {
+      emitSingleProfileChunk(
+          performanceTracer,
+          profileId,
+          chunkThreadId,
+          chunkTimestamp,
+          nodesInThisChunk,
+          samplesInThisChunk,
+          timeDeltasInThisChunk);
+
+      nodesInThisChunk.clear();
+      samplesInThisChunk.clear();
+      timeDeltasInThisChunk.clear();
+    }
+
+    chunkThreadId = sampleThreadId;
+    std::vector<RuntimeSamplingProfile::SampleCallStackFrame> callStack =
+        sample.getCallStack();
+    uint64_t sampleTimestamp = sample.getTimestamp();
+    if (samplesInThisChunk.empty()) {
+      // New chunk. Reset the timestamp.
+      chunkTimestamp = sampleTimestamp;
+    }
+
+    long long timeDelta = sampleTimestamp - previousSampleTimestamp;
+    timeDeltasInThisChunk.push_back(timeDelta);
+    previousSampleTimestamp = sampleTimestamp;
+
+    ProfileTreeNode* previousNode = callStack.empty() ? idleNode : rootNode;
+    for (auto it = callStack.rbegin(); it != callStack.rend(); ++it) {
+      auto callFrame = *it;
+      bool isGarbageCollectorFrame = callFrame.getKind() ==
+          RuntimeSamplingProfile::SampleCallStackFrame::Kind::GarbageCollector;
+      // We don't need real garbage collector call frame, we change it to
+      // what Chrome DevTools expects.
+      auto* currentNode = new ProfileTreeNode(
+          nodeCount + 1,
+          isGarbageCollectorFrame ? ProfileTreeNode::CodeType::Other
+                                  : ProfileTreeNode::CodeType::JavaScript,
+          previousNode,
+          isGarbageCollectorFrame ? garbageCollectorCallFrame : callFrame);
+
+      ProfileTreeNode* alreadyExistingNode =
+          previousNode->addChild(currentNode);
+      if (alreadyExistingNode != nullptr) {
+        previousNode = alreadyExistingNode;
+      } else {
+        nodesInThisChunk.push_back(currentNode);
+        ++nodeCount;
+
+        previousNode = currentNode;
+      }
+    }
+    samplesInThisChunk.push_back(previousNode->getId());
+
+    if (samplesInThisChunk.size() == profileChunkSize) {
+      emitSingleProfileChunk(
+          performanceTracer,
+          profileId,
+          chunkThreadId,
+          chunkTimestamp,
+          nodesInThisChunk,
+          samplesInThisChunk,
+          timeDeltasInThisChunk);
+
+      nodesInThisChunk.clear();
+      samplesInThisChunk.clear();
+      timeDeltasInThisChunk.clear();
+    }
+  }
+
+  if (!samplesInThisChunk.empty()) {
+    emitSingleProfileChunk(
+        performanceTracer,
+        profileId,
+        chunkThreadId,
+        chunkTimestamp,
+        nodesInThisChunk,
+        samplesInThisChunk,
+        timeDeltasInThisChunk);
+  }
+}
+
+} // namespace facebook::react::jsinspector_modern::tracing

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

@@ -0,0 +1,30 @@
+/*
+ * 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 "PerformanceTracer.h"
+#include "RuntimeSamplingProfile.h"
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+/**
+ * Serializes RuntimeSamplingProfile into collection of specific Trace Events,
+ * which represent Profile information on a timeline.
+ */
+class RuntimeSamplingProfileTraceEventSerializer {
+ public:
+  RuntimeSamplingProfileTraceEventSerializer() = delete;
+
+  static void serializeAndBuffer(
+      PerformanceTracer& performanceTracer,
+      const RuntimeSamplingProfile& profile,
+      std::chrono::steady_clock::time_point tracingStartTime,
+      uint16_t profileChunkSize = 100);
+};
+
+} // namespace facebook::react::jsinspector_modern::tracing

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

@@ -0,0 +1,65 @@
+/*
+ * 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 <folly/dynamic.h>
+
+namespace facebook::react::jsinspector_modern {
+
+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 {
+  /**
+   * Optional. Serialized as a string, usually is hexadecimal number.
+   * https://github.com/ChromeDevTools/devtools-frontend/blob/99a9104ae974f8caa63927e356800f6762cdbf25/front_end/models/trace/helpers/Trace.ts#L198-L201
+   */
+  std::optional<uint32_t> id;
+
+  /** 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
+
+} // namespace facebook::react::jsinspector_modern

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

@@ -0,0 +1,157 @@
+/*
+ * 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 <folly/dynamic.h>
+
+#include <utility>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+/// Arbitrary data structure, which represents payload of the "ProfileChunk"
+/// Trace Event.
+struct TraceEventProfileChunk {
+  /// Deltas between timestamps of chronolocigally sorted samples.
+  /// Will be sent as part of the "ProfileChunk" trace event.
+  struct TimeDeltas {
+   public:
+    explicit TimeDeltas(std::vector<long long> deltas)
+        : deltas_(std::move(deltas)) {}
+
+    folly::dynamic asDynamic() const {
+      folly::dynamic value = folly::dynamic::array();
+      for (auto delta : deltas_) {
+        value.push_back(delta);
+      }
+
+      return value;
+    }
+
+   private:
+    std::vector<long long> deltas_;
+  };
+
+  /// Contains Profile information that will be emitted in this chunk: nodes and
+  /// sample root node ids.
+  struct CPUProfile {
+    /// Unique node in the profile tree, has unique id, call frame and
+    /// optionally
+    /// id of its parent node. Only root node has no parent.
+    struct Node {
+      /// Unique call frame in the call stack.
+      struct CallFrame {
+       public:
+        CallFrame(
+            std::string codeType,
+            uint32_t scriptId,
+            std::string functionName,
+            std::optional<std::string> url = std::nullopt,
+            std::optional<uint32_t> lineNumber = std::nullopt,
+            std::optional<uint32_t> columnNumber = std::nullopt)
+            : codeType_(std::move(codeType)),
+              scriptId_(scriptId),
+              functionName_(std::move(functionName)),
+              url_(std::move(url)),
+              lineNumber_(lineNumber),
+              columnNumber_(columnNumber) {}
+
+        folly::dynamic asDynamic() const {
+          folly::dynamic dynamicCallFrame = folly::dynamic::object();
+          dynamicCallFrame["codeType"] = codeType_;
+          dynamicCallFrame["scriptId"] = scriptId_;
+          dynamicCallFrame["functionName"] = functionName_;
+          if (url_.has_value()) {
+            dynamicCallFrame["url"] = url_.value();
+          }
+          if (lineNumber_.has_value()) {
+            dynamicCallFrame["lineNumber"] = lineNumber_.value();
+          }
+          if (columnNumber_.has_value()) {
+            dynamicCallFrame["columnNumber"] = columnNumber_.value();
+          }
+
+          return dynamicCallFrame;
+        }
+
+       private:
+        std::string codeType_;
+        uint32_t scriptId_;
+        std::string functionName_;
+        std::optional<std::string> url_;
+        std::optional<uint32_t> lineNumber_;
+        std::optional<uint32_t> columnNumber_;
+      };
+
+     public:
+      Node(
+          uint32_t id,
+          CallFrame callFrame,
+          std::optional<uint32_t> parentId = std::nullopt)
+          : id_(id), callFrame_(std::move(callFrame)), parentId_(parentId) {}
+
+      folly::dynamic asDynamic() const {
+        folly::dynamic dynamicNode = folly::dynamic::object();
+
+        dynamicNode["callFrame"] = callFrame_.asDynamic();
+        dynamicNode["id"] = id_;
+        if (parentId_.has_value()) {
+          dynamicNode["parent"] = parentId_.value();
+        }
+
+        return dynamicNode;
+      }
+
+     private:
+      uint32_t id_;
+      CallFrame callFrame_;
+      std::optional<uint32_t> parentId_;
+    };
+
+   public:
+    CPUProfile(std::vector<Node> nodes, std::vector<uint32_t> samples)
+        : nodes_(std::move(nodes)), samples_(std::move(samples)) {}
+
+    folly::dynamic asDynamic() const {
+      folly::dynamic dynamicNodes = folly::dynamic::array();
+      for (const auto& node : nodes_) {
+        dynamicNodes.push_back(node.asDynamic());
+      }
+
+      folly::dynamic dynamicSamples = folly::dynamic::array();
+      for (auto sample : samples_) {
+        dynamicSamples.push_back(sample);
+      }
+
+      return folly::dynamic::object("nodes", dynamicNodes)(
+          "samples", dynamicSamples);
+    }
+
+   private:
+    std::vector<Node> nodes_;
+    std::vector<uint32_t> samples_;
+  };
+
+ public:
+  TraceEventProfileChunk(CPUProfile cpuProfile, TimeDeltas timeDeltas)
+      : cpuProfile_(std::move(cpuProfile)),
+        timeDeltas_(std::move(timeDeltas)) {}
+
+  folly::dynamic asDynamic() const {
+    folly::dynamic value = folly::dynamic::object;
+    value["cpuProfile"] = cpuProfile_.asDynamic();
+    value["timeDeltas"] = timeDeltas_.asDynamic();
+
+    return value;
+  }
+
+ private:
+  CPUProfile cpuProfile_;
+  TimeDeltas timeDeltas_;
+};
+
+} // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsinspector-modern/tracing/tests/ProfileTreeNodeTest.cpp

@@ -0,0 +1,58 @@
+/*
+ * 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 "ProfileTreeNode.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+TEST(ProfileTreeNodeTest, EqualityOperator) {
+  auto callFrame = RuntimeSamplingProfile::SampleCallStackFrame{
+      RuntimeSamplingProfile::SampleCallStackFrame::Kind::JSFunction, 0, "foo"};
+  ProfileTreeNode* node1;
+  ProfileTreeNode* node2;
+
+  node1 = new ProfileTreeNode(
+      1, ProfileTreeNode::CodeType::JavaScript, nullptr, callFrame);
+  node2 = new ProfileTreeNode(
+      2, ProfileTreeNode::CodeType::JavaScript, nullptr, callFrame);
+  EXPECT_EQ(*node1 == node2, true);
+
+  node1 = new ProfileTreeNode(
+      3, ProfileTreeNode::CodeType::JavaScript, node1, callFrame);
+  node2 = new ProfileTreeNode(
+      4, ProfileTreeNode::CodeType::JavaScript, nullptr, callFrame);
+  EXPECT_EQ(*node1 == node2, false);
+
+  node1 = new ProfileTreeNode(
+      5, ProfileTreeNode::CodeType::JavaScript, node2, callFrame);
+  node2 = new ProfileTreeNode(
+      6, ProfileTreeNode::CodeType::JavaScript, node2, callFrame);
+  EXPECT_EQ(*node1 == node2, true);
+}
+
+TEST(ProfileTreeNodeTest, OnlyAddsUniqueChildren) {
+  auto callFrame = RuntimeSamplingProfile::SampleCallStackFrame{
+      RuntimeSamplingProfile::SampleCallStackFrame::Kind::JSFunction, 0, "foo"};
+  ProfileTreeNode* parent = new ProfileTreeNode(
+      1, ProfileTreeNode::CodeType::JavaScript, nullptr, callFrame);
+  ProfileTreeNode* existingChild = new ProfileTreeNode(
+      2, ProfileTreeNode::CodeType::JavaScript, parent, callFrame);
+
+  auto maybeAlreadyExistingChild = parent->addChild(existingChild);
+  EXPECT_EQ(maybeAlreadyExistingChild, nullptr);
+
+  auto copyOfExistingChild = new ProfileTreeNode(
+      3, ProfileTreeNode::CodeType::JavaScript, parent, callFrame);
+
+  maybeAlreadyExistingChild = parent->addChild(copyOfExistingChild);
+  EXPECT_EQ(maybeAlreadyExistingChild, existingChild);
+}
+
+} // namespace facebook::react::jsinspector_modern::tracing