src: allow tracking children in MemoryTracker with weak edges

Allowing the addition of child nodes with a weak edge
between them enables expressing a relationship of the
"node A keeps track of node B and no other node does,
but node A does not keep node B alive" kind, which is
the relationship between `Realm`s and weak `BaseObject` instances.
This is a prerequisite for the following commit.

Note that the relevant V8 feature is not available
in Node.js yet. It's still worth doing this, both
because it allows us to prepare for that upstream
change, and because the current representation of
these edges in heap dumps is factually incorrect
and hinders debugging in existing Node.js versions.

Refs: v8/v8@e37cadf
Signed-off-by: Anna Henningsen <anna@addaleax.net>
PR-URL: #63842
Refs: #57417
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>

Author: addaleax

src/base_object.cc

@@ -180,4 +180,6 @@ void BaseObjectList::MemoryInfo(node::MemoryTracker* tracker) const {
   }
 }
 
+const char* const MemoryTracker::kWeakEdge = "<MemoryTracker::kWeakEdge>";
+
 }  // namespace node

src/memory_tracker-inl.h

@@ -131,7 +131,7 @@ void MemoryTracker::TrackField(const char* edge_name,
   if (value == nullptr) return;
   auto it = seen_.find(value);
   if (it != seen_.end()) {
-    graph_->AddEdge(CurrentNode(), it->second, edge_name);
+    AddEdge(CurrentNode(), it->second, edge_name);
   } else {
     Track(value, edge_name);
   }
@@ -253,9 +253,9 @@ void MemoryTracker::TrackField(const char* edge_name,
                                const v8::Local<T>& value,
                                const char* node_name) {
   if (!value.IsEmpty())
-    graph_->AddEdge(CurrentNode(),
-                    graph_->V8Node(value.template As<v8::Value>()),
-                    edge_name);
+    AddEdge(CurrentNode(),
+            graph_->V8Node(value.template As<v8::Value>()),
+            edge_name);
 }
 
 template <typename T>
@@ -300,7 +300,7 @@ void MemoryTracker::Track(const CppgcMixin* retainer, const char* edge_name) {
   auto it = seen_.find(retainer);
   if (it != seen_.end()) {
     if (CurrentNode() != nullptr) {
-      graph_->AddEdge(CurrentNode(), it->second, edge_name);
+      AddEdge(CurrentNode(), it->second, edge_name);
     }
     return;  // It has already been tracked, no need to call MemoryInfo again
   }
@@ -317,7 +317,7 @@ void MemoryTracker::Track(const MemoryRetainer* retainer,
   auto it = seen_.find(retainer);
   if (it != seen_.end()) {
     if (CurrentNode() != nullptr) {
-      graph_->AddEdge(CurrentNode(), it->second, edge_name);
+      AddEdge(CurrentNode(), it->second, edge_name);
     }
     return;  // It has already been tracked, no need to call MemoryInfo again
   }
@@ -376,7 +376,7 @@ MemoryRetainerNode* MemoryTracker::AddNode(const CppgcMixin* retainer,
   MemoryRetainerNode* n = new MemoryRetainerNode(this, retainer);
   seen_[retainer] = n;
   if (CurrentNode() != nullptr) {
-    graph_->AddEdge(CurrentNode(), n->JSWrapperNode(), edge_name);
+    AddEdge(CurrentNode(), n->JSWrapperNode(), edge_name);
   }
 
   return n;
@@ -392,11 +392,11 @@ MemoryRetainerNode* MemoryTracker::AddNode(const MemoryRetainer* retainer,
   MemoryRetainerNode* n = new MemoryRetainerNode(this, retainer);
   graph_->AddNode(std::unique_ptr<v8::EmbedderGraph::Node>(n));
   seen_[retainer] = n;
-  if (CurrentNode() != nullptr) graph_->AddEdge(CurrentNode(), n, edge_name);
+  if (CurrentNode() != nullptr) AddEdge(CurrentNode(), n, edge_name);
 
   if (n->JSWrapperNode() != nullptr) {
-    graph_->AddEdge(n, n->JSWrapperNode(), "native_to_javascript");
-    graph_->AddEdge(n->JSWrapperNode(), n, "javascript_to_native");
+    AddEdge(n, n->JSWrapperNode(), "native_to_javascript");
+    AddEdge(n->JSWrapperNode(), n, "javascript_to_native");
   }
 
   return n;
@@ -408,7 +408,7 @@ MemoryRetainerNode* MemoryTracker::AddNode(const char* node_name,
   MemoryRetainerNode* n = new MemoryRetainerNode(this, node_name, size);
   graph_->AddNode(std::unique_ptr<v8::EmbedderGraph::Node>(n));
 
-  if (CurrentNode() != nullptr) graph_->AddEdge(CurrentNode(), n, edge_name);
+  if (CurrentNode() != nullptr) AddEdge(CurrentNode(), n, edge_name);
 
   return n;
 }
@@ -435,6 +435,13 @@ MemoryRetainerNode* MemoryTracker::PushNode(const char* node_name,
   return n;
 }
 
+void MemoryTracker::AddEdge(v8::EmbedderGraph::Node* from,
+                            v8::EmbedderGraph::Node* to,
+                            const char* edge_name) {
+  if (edge_name == kWeakEdge) return;
+  graph_->AddEdge(from, to, edge_name);
+}
+
 void MemoryTracker::PopNode() {
   node_stack_.pop();
 }

src/memory_tracker.h

@@ -300,6 +300,13 @@ class MemoryTracker {
                                 v8::EmbedderGraph* graph)
     : isolate_(isolate), graph_(graph) {}
 
+  // Can be passed to Track() if it is not desirable
+  // to create a strong edge between nodes, i.e. when
+  // the node should be added to the graph and the
+  // parent node is "tracking" the target node but
+  // not directly keeping it alive.
+  static const char* const kWeakEdge;
+
  private:
   typedef std::unordered_map<const MemoryRetainer*, MemoryRetainerNode*>
       NodeMap;
@@ -321,6 +328,9 @@ class MemoryTracker {
                                       size_t size,
                                       const char* edge_name = nullptr);
   inline void PopNode();
+  inline void AddEdge(v8::EmbedderGraph::Node* from,
+                      v8::EmbedderGraph::Node* to,
+                      const char* edge_name = nullptr);
 
   v8::Isolate* isolate_;
   v8::EmbedderGraph* graph_;