src: implement AliasedBufferBase bookkeeping

In addition implement Environment::PrintAllBuffers() and
Environment::PrintAllBaseObjects() for bookkeeping.

Author: joyeecheung

src/aliased_buffer.h

@@ -4,6 +4,7 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include <cinttypes>
+#include <unordered_set>
 #include "util-inl.h"
 #include "v8.h"
 
@@ -26,14 +27,23 @@ namespace node {
  * The encapsulation herein provides a placeholder where such writes can be
  * observed. Any notification APIs will be left as a future exercise.
  */
+
+enum class AliasedBufferType { kNew, kCopy, kShared, kAssigned };
+
 template <class NativeT,
           class V8T,
           // SFINAE NativeT to be scalar
-          typename = std::enable_if_t<std::is_scalar<NativeT>::value>>
+          typename Trait = std::enable_if_t<std::is_scalar<NativeT>::value>>
 class AliasedBufferBase {
  public:
-  AliasedBufferBase(v8::Isolate* isolate, const size_t count)
-      : isolate_(isolate), count_(count), byte_offset_(0) {
+  static std::unordered_set<AliasedBufferBase*> buffers;
+
+  inline AliasedBufferBase(v8::Isolate* isolate, const size_t count)
+      : isolate_(isolate),
+        count_(count),
+        byte_offset_(0),
+        type_(AliasedBufferType::kNew) {
+    buffers.insert(this);
     CHECK_GT(count, 0);
     const v8::HandleScope handle_scope(isolate_);
     const size_t size_in_bytes =
@@ -63,7 +73,11 @@ class AliasedBufferBase {
       const size_t byte_offset,
       const size_t count,
       const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer)
-      : isolate_(isolate), count_(count), byte_offset_(byte_offset) {
+      : isolate_(isolate),
+        count_(count),
+        byte_offset_(byte_offset),
+        type_(AliasedBufferType::kShared) {
+    buffers.insert(this);
     const v8::HandleScope handle_scope(isolate_);
 
     v8::Local<v8::ArrayBuffer> ab = backing_buffer.GetArrayBuffer();
@@ -85,10 +99,14 @@ class AliasedBufferBase {
       : isolate_(that.isolate_),
         count_(that.count_),
         byte_offset_(that.byte_offset_),
-        buffer_(that.buffer_) {
+        buffer_(that.buffer_),
+        type_(AliasedBufferType::kCopy) {
+    buffers.insert(this);
     js_array_ = v8::Global<V8T>(that.isolate_, that.GetJSArray());
   }
 
+  inline ~AliasedBufferBase() { buffers.erase(this); }
+
   AliasedBufferBase& operator=(AliasedBufferBase&& that) noexcept {
     this->~AliasedBufferBase();
     isolate_ = that.isolate_;
@@ -97,6 +115,7 @@ class AliasedBufferBase {
     buffer_ = that.buffer_;
 
     js_array_.Reset(isolate_, that.js_array_.Get(isolate_));
+    type_ = AliasedBufferType::kAssigned;
 
     that.buffer_ = nullptr;
     that.js_array_.Reset();
@@ -243,19 +262,40 @@ class AliasedBufferBase {
     count_ = new_capacity;
   }
 
+  AliasedBufferType type() const { return type_; }
+
+  typedef void (*AliasedBufferIterator)(AliasedBufferBase*, void* data);
+
+  static void ForEachBuffer(AliasedBufferIterator iter, void* data) {
+    for (const auto& item : buffers) {
+      iter(item, data);
+    }
+  }
+
  private:
   v8::Isolate* isolate_;
   size_t count_;
   size_t byte_offset_;
   NativeT* buffer_;
   v8::Global<V8T> js_array_;
+  AliasedBufferType type_;
 };
 
-typedef AliasedBufferBase<int32_t, v8::Int32Array> AliasedInt32Array;
-typedef AliasedBufferBase<uint8_t, v8::Uint8Array> AliasedUint8Array;
-typedef AliasedBufferBase<uint32_t, v8::Uint32Array> AliasedUint32Array;
-typedef AliasedBufferBase<double, v8::Float64Array> AliasedFloat64Array;
-typedef AliasedBufferBase<uint64_t, v8::BigUint64Array> AliasedBigUint64Array;
+template <class NativeT, class V8T, typename Trait>
+std::unordered_set<AliasedBufferBase<NativeT, V8T, Trait>*>
+    AliasedBufferBase<NativeT, V8T, Trait>::buffers;
+
+#define ALIASED_BUFFER_TYPES(V)                                                \
+  V(uint8_t, Uint8Array)                                                       \
+  V(int32_t, Int32Array)                                                       \
+  V(uint32_t, Uint32Array)                                                     \
+  V(double, Float64Array)                                                      \
+  V(uint64_t, BigUint64Array)
+
+#define V(NativeT, V8T)                                                        \
+  typedef AliasedBufferBase<NativeT, v8::V8T> Aliased##V8T;
+ALIASED_BUFFER_TYPES(V)
+#undef V
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

src/env-inl.h

@@ -1229,15 +1229,6 @@ BaseObject* CleanupHookCallback::GetBaseObject() const {
     return nullptr;
 }
 
-template <typename T>
-void Environment::ForEachBaseObject(T&& iterator) {
-  for (const auto& hook : cleanup_hooks_) {
-    BaseObject* obj = hook.GetBaseObject();
-    if (obj != nullptr)
-      iterator(obj);
-  }
-}
-
 void Environment::modify_base_object_count(int64_t delta) {
   base_object_count_ += delta;
 }

src/env.cc

@@ -22,6 +22,7 @@
 #include <algorithm>
 #include <atomic>
 #include <cstdio>
+#include <iostream>
 #include <memory>
 
 namespace node {
@@ -1097,6 +1098,102 @@ Environment* Environment::worker_parent_env() const {
   return worker_context()->env();
 }
 
+void Environment::ForEachBaseObject(BaseObjectIterator iterator) {
+  size_t i = 0;
+  for (const auto& hook : cleanup_hooks_) {
+    BaseObject* obj = hook.GetBaseObject();
+    if (obj != nullptr) iterator(i, obj);
+    i++;
+  }
+}
+
+void PrintBaseObject(size_t i, BaseObject* obj) {
+  std::cout << "#" << i << " " << obj << ": " << obj->MemoryInfoName() << "\n";
+}
+
+void Environment::PrintAllBaseObjects() {
+  std::cout << "BaseObjects\n";
+  ForEachBaseObject(PrintBaseObject);
+}
+
+struct PrinterData {
+  const std::map<const void*, std::string>* names;
+  size_t index = 0;
+};
+
+template <typename AliasedBufferBase>
+static void PrintBuffer(AliasedBufferBase* buf, void* data) {
+  PrinterData* printer_data = static_cast<PrinterData*>(data);
+  std::cout << "#" << printer_data->index++;
+  auto it = printer_data->names->find(buf);
+  if (it == printer_data->names->end()) {
+    std::cout << " Unkonwn " << buf;
+    // Require the Environment to register all known AliasedBuffers.
+    UNREACHABLE();
+  }
+
+  std::string type_name;
+  switch (buf->type()) {
+    case AliasedBufferType::kNew:
+      type_name = "new";
+      break;
+    case AliasedBufferType::kCopy:
+      type_name = "copy";
+      break;
+    case AliasedBufferType::kAssigned:
+      type_name = "assigned";
+      break;
+    case AliasedBufferType::kShared:
+      type_name = "shared";
+      break;
+    default:
+      UNREACHABLE();
+  }
+
+  std::cout << " " << it->second << "(length=" << buf->Length()
+            << ", address=" << buf << ", type=" << type_name << "): ";
+
+  size_t len = buf->Length();
+  auto buf_data = buf->GetNativeBuffer();
+  for (size_t j = 0; j < len; ++j) {
+    std::cout << std::to_string(buf_data[j]) << (j == len - 1 ? "\n" : ", ");
+  }
+}
+
+#define FOR_EACH_KNOWN_BUFFER_IN_ENV(V)                                        \
+  V(stream_base_state_, Int32Array)                                            \
+  V(performance_state_->root, Uint8Array)                                      \
+  V(performance_state_->milestones, Float64Array)                              \
+  V(performance_state_->observers, Uint32Array)                                \
+  V(should_abort_on_uncaught_toggle_, Uint32Array)                             \
+  V(async_hooks_.fields_, Uint32Array)                                         \
+  V(async_hooks_.async_ids_stack_, Float64Array)                               \
+  V(async_hooks_.async_id_fields_, Float64Array)                               \
+  V(tick_info_.fields_, Uint8Array)                                            \
+  V(immediate_info_.fields_, Uint32Array)
+
+std::map<const void*, std::string> Environment::GetKnownBufferNames() const {
+  std::map<const void*, std::string> names;
+
+#define V(Reference, V8T) names[&(Reference)] = #Reference;
+  FOR_EACH_KNOWN_BUFFER_IN_ENV(V)
+#undef V
+
+  return names;
+}
+
+void Environment::PrintAllBuffers() {
+  std::map<const void*, std::string> names = GetKnownBufferNames();
+  PrinterData printer_data{&names, 0};
+
+#define V(NativeT, V8T)                                                        \
+  std::cout << "Aliased" #V8T << "s\n";                                        \
+  Aliased##V8T::ForEachBuffer(PrintBuffer<Aliased##V8T>, &printer_data);       \
+  std::cout << "\n";
+  ALIASED_BUFFER_TYPES(V)
+#undef V
+}
+
 void MemoryTracker::TrackField(const char* edge_name,
                                const CleanupHookCallback& value,
                                const char* node_name) {

src/env.h

@@ -45,6 +45,7 @@
 #include <cstdint>
 #include <functional>
 #include <list>
+#include <map>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
@@ -862,6 +863,12 @@ class Environment : public MemoryRetainer {
   void MemoryInfo(MemoryTracker* tracker) const override;
 
   void CreateProperties();
+
+  typedef void (*BaseObjectIterator)(size_t, BaseObject*);
+  void ForEachBaseObject(BaseObjectIterator iterator);
+  void PrintAllBaseObjects();
+  void PrintAllBuffers();
+
   // Should be called before InitializeInspector()
   void InitializeDiagnostics();
 #if HAVE_INSPECTOR
@@ -1287,7 +1294,8 @@ class Environment : public MemoryRetainer {
  private:
   template <typename Fn>
   inline void CreateImmediate(Fn&& cb, bool ref);
-
+  
+  std::map<const void*, std::string> GetKnownBufferNames() const;
   inline void ThrowError(v8::Local<v8::Value> (*fun)(v8::Local<v8::String>),
                          const char* errmsg);
 
@@ -1476,9 +1484,6 @@ class Environment : public MemoryRetainer {
   std::function<void(Environment*, int)> process_exit_handler_ {
       DefaultProcessExitHandler };
 
-  template <typename T>
-  void ForEachBaseObject(T&& iterator);
-
 #define V(PropertyName, TypeName) v8::Global<TypeName> PropertyName ## _;
   ENVIRONMENT_CALLBACK_DATA(V)
   ENVIRONMENT_STRONG_PERSISTENT_VALUES(V)