Support captureNumericValue flag for heap snapshot

Summary:
When `captureNumericValue` is false, all number nodes and all edges to
those nodes are omitted.

Note that when someone uses `getUniqueID` to try to convert a
jsi::Value and its underlying HermesValue to a snapshot ID, if no
previous captures included numeric values, then we'll simply allocate
an ID for the requested numeric value (if it's number). The next time
someone requests a snapshot that included numeric values, we'll reuse
that same ID when the same numeric value is requested.

Reviewed By: neildhar

Differential Revision: D60798281

fbshipit-source-id: 9748247d4703eb26005cb81640ba4dcb0d7dddcc

API/hermes/hermes.cpp

@@ -392,14 +392,14 @@ class HermesRuntimeImpl final : public HermesRuntime,
   // Overridden from jsi::Instrumentation
   void createSnapshotToFile(
       const std::string &path,
-      const HeapSnapshotOptions & /*options*/) override {
+      const HeapSnapshotOptions &options) override {
 #ifdef HERMES_MEMORY_INSTRUMENTATION
     std::error_code code;
     llvh::raw_fd_ostream os(path, code, llvh::sys::fs::FileAccess::FA_Write);
     if (code) {
       throw std::system_error(code);
     }
-    runtime_.getHeap().createSnapshot(os);
+    runtime_.getHeap().createSnapshot(os, options.captureNumericValue);
 #else
     throw std::logic_error(
         "Cannot create heap snapshots if Hermes isn't built with "
@@ -410,10 +410,10 @@ class HermesRuntimeImpl final : public HermesRuntime,
   // Overridden from jsi::Instrumentation
   void createSnapshotToStream(
       std::ostream &os,
-      const HeapSnapshotOptions & /*options*/) override {
+      const HeapSnapshotOptions &options) override {
 #ifdef HERMES_MEMORY_INSTRUMENTATION
     llvh::raw_os_ostream ros(os);
-    runtime_.getHeap().createSnapshot(ros);
+    runtime_.getHeap().createSnapshot(ros, options.captureNumericValue);
 #else
     throw std::logic_error(
         "Cannot create heap snapshots if Hermes isn't built with "

include/hermes/VM/GCBase.h

@@ -1007,12 +1007,14 @@ class GCBase {
 
   /// Creates a snapshot of the heap, which includes information about what
   /// objects exist, their sizes, and what they point to.
-  virtual void createSnapshot(llvh::raw_ostream &os) = 0;
-  void createSnapshot(GC &gc, llvh::raw_ostream &os);
+  virtual void createSnapshot(
+      llvh::raw_ostream &os,
+      bool captureNumericValue) = 0;
+  void createSnapshot(GC &gc, llvh::raw_ostream &os, bool captureNumericValue);
   /// Actual implementation of writing the snapshot. If \p numRootEdges is
-  // uninitialized, it will be populated with the edge counts for each root
-  // section. Otherwise, it will be used to pad the output with additional edges
-  // if necessary so they match the recorded count.
+  /// uninitialized, it will be populated with the edge counts for each root
+  /// section. Otherwise, it will be used to pad the output with additional
+  /// edges if necessary so they match the recorded count.
   void createSnapshotImpl(
       GC &gc,
       HeapSnapshot &snap,

include/hermes/VM/HadesGC.h

@@ -91,7 +91,7 @@ class HadesGC final : public GCBase {
   void getHeapInfoWithMallocSize(HeapInfo &info) override;
   void getCrashManagerHeapInfo(CrashManager::HeapInformation &info) override;
 #ifdef HERMES_MEMORY_INSTRUMENTATION
-  void createSnapshot(llvh::raw_ostream &os) override;
+  void createSnapshot(llvh::raw_ostream &os, bool captureNumericValue) override;
   void snapshotAddGCNativeNodes(HeapSnapshot &snap) override;
   void snapshotAddGCNativeEdges(HeapSnapshot &snap) override;
   void enableHeapProfiler(

include/hermes/VM/MallocGC.h

@@ -221,7 +221,8 @@ class MallocGC final : public GCBase {
 
 #ifdef HERMES_MEMORY_INSTRUMENTATION
   /// Same as in superclass GCBase.
-  virtual void createSnapshot(llvh::raw_ostream &os) override;
+  virtual void createSnapshot(llvh::raw_ostream &os, bool captureNumericValue)
+      override;
 #endif
 
   virtual void creditExternalMemory(GCCell *alloc, uint32_t size) override;

lib/VM/GCBase.cpp

@@ -136,7 +136,7 @@ std::error_code GCBase::createSnapshotToFile(const std::string &fileName) {
   if (code) {
     return code;
   }
-  createSnapshot(os);
+  createSnapshot(os, true);
   return std::error_code{};
 }
 
@@ -191,13 +191,13 @@ struct PrimitiveNodeAcceptor : public SnapshotAcceptor {
   void accept(GCCell *&ptr, const char *name) override {}
 
   void acceptHV(HermesValue &hv, const char *) override {
-    if (hv.isNumber()) {
+    if (tracker_.isTrackingNumberIDs() && hv.isNumber()) {
       seenNumbers_.insert(hv.getNumber());
     }
   }
 
   void acceptSHV(SmallHermesValue &hv, const char *) override {
-    if (hv.isNumber()) {
+    if (tracker_.isTrackingNumberIDs() && hv.isNumber()) {
       seenNumbers_.insert(hv.getNumber(pointerBase_));
     }
   }
@@ -233,18 +233,29 @@ struct PrimitiveNodeAcceptor : public SnapshotAcceptor {
         GCBase::IDTracker::reserved(GCBase::IDTracker::ReservedObjectID::False),
         0,
         0);
-    for (double num : seenNumbers_) {
-      // A number never has any edges, so just make a node for it.
+    if (tracker_.isTrackingNumberIDs()) {
+      for (double num : seenNumbers_) {
+        // A number never has any edges, so just make a node for it.
+        snap_.beginNode();
+        // Convert the number value to a string, according to the JS conversion
+        // routines.
+        char buf[hermes::NUMBER_TO_STRING_BUF_SIZE];
+        size_t len = hermes::numberToString(num, buf, sizeof(buf));
+        snap_.endNode(
+            HeapSnapshot::NodeType::Number,
+            llvh::StringRef{buf, len},
+            tracker_.getNumberID(num),
+            // Numbers are zero-sized in the heap because they're stored inline.
+            0,
+            0);
+      }
+    } else {
       snap_.beginNode();
-      // Convert the number value to a string, according to the JS conversion
-      // routines.
-      char buf[hermes::NUMBER_TO_STRING_BUF_SIZE];
-      size_t len = hermes::numberToString(num, buf, sizeof(buf));
       snap_.endNode(
-          HeapSnapshot::NodeType::Number,
-          llvh::StringRef{buf, len},
-          tracker_.getNumberID(num),
-          // Numbers are zero-sized in the heap because they're stored inline.
+          HeapSnapshot::NodeType::Object,
+          "number",
+          GCBase::IDTracker::reserved(
+              GCBase::IDTracker::ReservedObjectID::Number),
           0,
           0);
     }
@@ -596,7 +607,13 @@ void GCBase::createSnapshotImpl(
   snap.endSection(HeapSnapshot::Section::Locations);
 }
 
-void GCBase::createSnapshot(GC &gc, llvh::raw_ostream &os) {
+void GCBase::createSnapshot(
+    GC &gc,
+    llvh::raw_ostream &os,
+    bool captureNumericValue) {
+  if (!captureNumericValue) {
+    idTracker_.stopTrackingNumberIDs();
+  }
   // Chrome 125 requires correct node count and edge count in the "snapshot"
   // field, which is at the beginning of the heap snapshot. We do two passes to
   // populate the correct node/edge count. First, we create a dummy HeapSnapshot
@@ -628,6 +645,7 @@ void GCBase::createSnapshot(GC &gc, llvh::raw_ostream &os) {
   assert(
       dummySnap.getEdgeCount() == snap.getEdgeCount() &&
       "Edge count of two passes of createSnapshotImpl are not equal");
+  idTracker_.startTrackingNumberIDs();
 }
 
 void GCBase::snapshotAddGCNativeNodes(HeapSnapshot &snap) {
@@ -684,9 +702,10 @@ void GCBase::checkTripwire(size_t dataSize) {
       return gc_->createSnapshotToFile(path);
     }
 
-    std::error_code createSnapshot(std::ostream &os) override {
+    std::error_code createSnapshot(std::ostream &os, bool captureNumericValue)
+        override {
       llvh::raw_os_ostream ros(os);
-      gc_->createSnapshot(ros);
+      gc_->createSnapshot(ros, captureNumericValue);
       return std::error_code{};
     }
 
@@ -700,7 +719,8 @@ void GCBase::checkTripwire(size_t dataSize) {
       return std::error_code(ENOSYS, std::system_category());
     }
 
-    std::error_code createSnapshot(std::ostream &os) override {
+    std::error_code createSnapshot(std::ostream &os, bool captureNumericValue)
+        override {
       return std::error_code(ENOSYS, std::system_category());
     }
   } ctx;

lib/VM/JSArray.cpp

@@ -52,7 +52,7 @@ void ArrayImpl::_snapshotAddEdgesImpl(
   for (uint32_t i = beginIndex; i < endIndex; i++) {
     const auto &elem = indexedStorage->at(gc.getPointerBase(), i - beginIndex);
     const llvh::Optional<HeapSnapshot::NodeID> elemID =
-        gc.getSnapshotID(elem.toHV(gc.getPointerBase()));
+        gc.getSnapshotID(elem.unboxToHV(gc.getPointerBase()));
     if (!elemID) {
       continue;
     }

lib/VM/gcs/HadesGC.cpp

@@ -1349,15 +1349,15 @@ void HadesGC::getCrashManagerHeapInfo(
 }
 
 #ifdef HERMES_MEMORY_INSTRUMENTATION
-void HadesGC::createSnapshot(llvh::raw_ostream &os) {
+void HadesGC::createSnapshot(llvh::raw_ostream &os, bool captureNumericValue) {
   std::lock_guard<Mutex> lk{gcMutex_};
   // No allocations are allowed throughout the entire heap snapshot process.
   NoAllocScope scope{*this};
   // Let any existing collections complete before taking the snapshot.
   waitForCollectionToFinish("snapshot");
   {
     GCCycle cycle{*this, "GC Heap Snapshot"};
-    GCBase::createSnapshot(*this, os);
+    GCBase::createSnapshot(*this, os, captureNumericValue);
   }
 }
 

lib/VM/gcs/MallocGC.cpp

@@ -517,9 +517,9 @@ bool MallocGC::needsWriteBarrier(void *loc, GCCell *value) {
 #endif
 
 #ifdef HERMES_MEMORY_INSTRUMENTATION
-void MallocGC::createSnapshot(llvh::raw_ostream &os) {
+void MallocGC::createSnapshot(llvh::raw_ostream &os, bool captureNumericValue) {
   GCCycle cycle{*this};
-  GCBase::createSnapshot(*this, os);
+  GCBase::createSnapshot(*this, os, captureNumericValue);
 }
 #endif
 

public/hermes/Public/GCTripwireContext.h

@@ -32,7 +32,9 @@ class HERMES_EXPORT GCTripwireContext {
   /// \param os stream to save the heap capture to.
   /// \return Empty error code if the heap capture succeeded, else a real error
   ///   code.
-  virtual std::error_code createSnapshot(std::ostream &os) = 0;
+  virtual std::error_code createSnapshot(
+      std::ostream &os,
+      bool captureNumericValue) = 0;
 };
 
 } // namespace vm