src: enable more detailed memory tracking

This will enable more detailed heap snapshots based on
a newer V8 API.

This commit itself is not tied to that API and could
be backported.

PR-URL: https://github.com/nodejs/node/pull/21742
Reviewed-By: James M Snell <jasnell@gmail.com>

1 files changed, 87 insertions, 0 deletions

diff --git a/src/memory_tracker.h b/src/memory_tracker.h
new file mode 100644
index 0000000000..18822651f6
--- /dev/null
+++ b/src/memory_tracker.h
@@ -0,0 +1,87 @@
+#ifndef SRC_MEMORY_TRACKER_H_
+#define SRC_MEMORY_TRACKER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <unordered_set>
+#include <queue>
+#include <limits>
+#include <uv.h>
+#include <aliased_buffer.h>
+
+namespace node {
+
+class MemoryTracker;
+
+namespace crypto {
+class NodeBIO;
+}
+
+class MemoryRetainer {
+ public:
+  virtual ~MemoryRetainer() {}
+
+  // Subclasses should implement this to provide information for heap snapshots.
+  virtual void MemoryInfo(MemoryTracker* tracker) const = 0;
+
+  virtual v8::Local<v8::Object> WrappedObject() const {
+    return v8::Local<v8::Object>();
+  }
+
+  virtual bool IsRootNode() const { return false; }
+};
+
+class MemoryTracker {
+ public:
+  template <typename T>
+  inline void TrackThis(const T* obj);
+
+  inline void TrackFieldWithSize(const char* name, size_t size);
+
+  inline void TrackField(const char* name, const MemoryRetainer& value);
+  inline void TrackField(const char* name, const MemoryRetainer* value);
+  template <typename T>
+  inline void TrackField(const char* name, const std::unique_ptr<T>& value);
+  template <typename T, typename Iterator = typename T::const_iterator>
+  inline void TrackField(const char* name, const T& value);
+  template <typename T>
+  inline void TrackField(const char* name, const std::queue<T>& value);
+  template <typename T>
+  inline void TrackField(const char* name, const std::basic_string<T>& value);
+  template <typename T, typename test_for_number =
+      typename std::enable_if<
+          std::numeric_limits<T>::is_specialized, bool>::type,
+      typename dummy = bool>
+  inline void TrackField(const char* name, const T& value);
+  template <typename T, typename U>
+  inline void TrackField(const char* name, const std::pair<T, U>& value);
+  template <typename T, typename Traits>
+  inline void TrackField(const char* name,
+                         const v8::Persistent<T, Traits>& value);
+  template <typename T>
+  inline void TrackField(const char* name, const v8::Local<T>& value);
+  template <typename T>
+  inline void TrackField(const char* name, const MallocedBuffer<T>& value);
+  inline void TrackField(const char* name, const uv_buf_t& value);
+  template <class NativeT, class V8T>
+  inline void TrackField(const char* name,
+                         const AliasedBuffer<NativeT, V8T>& value);
+
+  inline void Track(const MemoryRetainer* value);
+  inline size_t accumulated_size() const { return accumulated_size_; }
+
+  inline void set_track_only_self(bool value) { track_only_self_ = value; }
+
+  inline MemoryTracker() {}
+
+ private:
+  bool track_only_self_ = false;
+  size_t accumulated_size_ = 0;
+  std::unordered_set<const MemoryRetainer*> seen_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_MEMORY_TRACKER_H_