@encharm/cws 4.1.0 → 4.2.0

package/src/headers/12/memory_tracker-inl.h

@@ -1,339 +0,0 @@
-#ifndef SRC_MEMORY_TRACKER_INL_H_
-#define SRC_MEMORY_TRACKER_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "memory_tracker.h"
-
-namespace node {
-
-// Fallback edge_name if node_name is not available, or "" if edge_name
-// is not available either.
-inline const char* GetNodeName(const char* node_name, const char* edge_name) {
-  if (node_name != nullptr) {
-    return node_name;
-  }
-  if (edge_name != nullptr) {
-    return edge_name;
-  }
-  return "";
-}
-
-class MemoryRetainerNode : public v8::EmbedderGraph::Node {
- public:
-  inline MemoryRetainerNode(MemoryTracker* tracker,
-                                     const MemoryRetainer* retainer)
-      : retainer_(retainer) {
-    CHECK_NOT_NULL(retainer_);
-    v8::HandleScope handle_scope(tracker->isolate());
-    v8::Local<v8::Object> obj = retainer_->WrappedObject();
-    if (!obj.IsEmpty()) wrapper_node_ = tracker->graph()->V8Node(obj);
-
-    name_ = retainer_->MemoryInfoName();
-    size_ = retainer_->SelfSize();
-  }
-
-  inline MemoryRetainerNode(MemoryTracker* tracker,
-                                     const char* name,
-                                     size_t size,
-                                     bool is_root_node = false)
-      : retainer_(nullptr) {
-    name_ = name;
-    size_ = size;
-    is_root_node_ = is_root_node;
-  }
-
-  const char* Name() override { return name_.c_str(); }
-  const char* NamePrefix() override { return "Node /"; }
-  size_t SizeInBytes() override { return size_; }
-  // TODO(addaleax): Merging this with the "official" WrapperNode() method
-  // seems to lose accuracy, e.g. SizeInBytes() is disregarded.
-  // Figure out whether to do anything about that.
-  Node* JSWrapperNode() { return wrapper_node_; }
-
-  bool IsRootNode() override {
-    if (retainer_ != nullptr) {
-      return retainer_->IsRootNode();
-    }
-    return is_root_node_;
-  }
-
- private:
-  friend class MemoryTracker;
-
-  // If retainer_ is not nullptr, then it must have a wrapper_node_,
-  // and we have
-  // name_ == retainer_->MemoryInfoName()
-  // size_ == retainer_->SelfSize()
-  // is_root_node_ == retainer_->IsRootNode()
-  const MemoryRetainer* retainer_;
-  Node* wrapper_node_ = nullptr;
-
-  // Otherwise (retainer == nullptr), we set these fields in an ad-hoc way
-  bool is_root_node_ = false;
-  std::string name_;
-  size_t size_ = 0;
-};
-
-void MemoryTracker::TrackFieldWithSize(const char* edge_name,
-                                       size_t size,
-                                       const char* node_name) {
-  if (size > 0) AddNode(GetNodeName(node_name, edge_name), size, edge_name);
-}
-
-void MemoryTracker::TrackInlineFieldWithSize(const char* edge_name,
-                                             size_t size,
-                                             const char* node_name) {
-  if (size > 0) AddNode(GetNodeName(node_name, edge_name), size, edge_name);
-  CHECK(CurrentNode());
-  CurrentNode()->size_ -= size;
-}
-
-void MemoryTracker::TrackField(const char* edge_name,
-                               const MemoryRetainer& value,
-                               const char* node_name) {
-  TrackField(edge_name, &value);
-}
-
-void MemoryTracker::TrackField(const char* edge_name,
-                               const MemoryRetainer* value,
-                               const char* node_name) {
-  if (value == nullptr) return;
-  auto it = seen_.find(value);
-  if (it != seen_.end()) {
-    graph_->AddEdge(CurrentNode(), it->second, edge_name);
-  } else {
-    Track(value, edge_name);
-  }
-}
-
-template <typename T, typename D>
-void MemoryTracker::TrackField(const char* edge_name,
-                               const std::unique_ptr<T, D>& value,
-                               const char* node_name) {
-  if (value.get() == nullptr) {
-    return;
-  }
-  TrackField(edge_name, value.get(), node_name);
-}
-
-template <typename T, bool kIsWeak>
-void MemoryTracker::TrackField(const char* edge_name,
-                               const BaseObjectPtrImpl<T, kIsWeak>& value,
-                               const char* node_name) {
-  if (value.get() == nullptr) return;
-  TrackField(edge_name, value.get(), node_name);
-}
-
-template <typename T, typename Iterator>
-void MemoryTracker::TrackField(const char* edge_name,
-                               const T& value,
-                               const char* node_name,
-                               const char* element_name,
-                               bool subtract_from_self) {
-  // If the container is empty, the size has been accounted into the parent's
-  // self size
-  if (value.begin() == value.end()) return;
-  // Fall back to edge name if node names are not provided
-  if (CurrentNode() != nullptr && subtract_from_self) {
-    // Shift the self size of this container out to a separate node
-    CurrentNode()->size_ -= sizeof(T);
-  }
-  PushNode(GetNodeName(node_name, edge_name), sizeof(T), edge_name);
-  for (Iterator it = value.begin(); it != value.end(); ++it) {
-    // Use nullptr as edge names so the elements appear as indexed properties
-    TrackField(nullptr, *it, element_name);
-  }
-  PopNode();
-}
-
-template <typename T>
-void MemoryTracker::TrackField(const char* edge_name,
-                               const std::queue<T>& value,
-                               const char* node_name,
-                               const char* element_name) {
-  struct ContainerGetter : public std::queue<T> {
-    static const typename std::queue<T>::container_type& Get(
-        const std::queue<T>& value) {
-      return value.*&ContainerGetter::c;
-    }
-  };
-
-  const auto& container = ContainerGetter::Get(value);
-  TrackField(edge_name, container, node_name, element_name);
-}
-
-template <typename T, typename test_for_number, typename dummy>
-void MemoryTracker::TrackField(const char* edge_name,
-                               const T& value,
-                               const char* node_name) {
-  // For numbers, creating new nodes is not worth the overhead.
-  CurrentNode()->size_ += sizeof(T);
-}
-
-template <typename T, typename U>
-void MemoryTracker::TrackField(const char* edge_name,
-                               const std::pair<T, U>& value,
-                               const char* node_name) {
-  PushNode(node_name == nullptr ? "pair" : node_name,
-           sizeof(const std::pair<T, U>),
-           edge_name);
-  // TODO(joyeecheung): special case if one of these is a number type
-  // that meets the test_for_number trait so that their sizes don't get
-  // merged into the pair node
-  TrackField("first", value.first);
-  TrackField("second", value.second);
-  PopNode();
-}
-
-template <typename T>
-void MemoryTracker::TrackField(const char* edge_name,
-                               const std::basic_string<T>& value,
-                               const char* node_name) {
-  TrackFieldWithSize(edge_name, value.size() * sizeof(T), "std::basic_string");
-}
-
-template <typename T>
-void MemoryTracker::TrackField(const char* edge_name,
-                               const v8::Eternal<T>& value,
-                               const char* node_name) {
-  TrackField(edge_name, value.Get(isolate_));
-}
-
-template <typename T>
-void MemoryTracker::TrackField(const char* edge_name,
-                               const v8::PersistentBase<T>& value,
-                               const char* node_name) {
-  TrackField(edge_name, value.Get(isolate_));
-}
-
-template <typename T>
-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), edge_name);
-}
-
-template <typename T>
-void MemoryTracker::TrackField(const char* edge_name,
-                               const MallocedBuffer<T>& value,
-                               const char* node_name) {
-  TrackFieldWithSize(edge_name, value.size, "MallocedBuffer");
-}
-
-void MemoryTracker::TrackField(const char* name,
-                               const uv_buf_t& value,
-                               const char* node_name) {
-  TrackFieldWithSize(name, value.len, "uv_buf_t");
-}
-
-void MemoryTracker::TrackField(const char* name,
-                               const uv_timer_t& value,
-                               const char* node_name) {
-  TrackFieldWithSize(name, sizeof(value), "uv_timer_t");
-}
-
-void MemoryTracker::TrackField(const char* name,
-                               const uv_async_t& value,
-                               const char* node_name) {
-  TrackFieldWithSize(name, sizeof(value), "uv_async_t");
-}
-
-void MemoryTracker::TrackInlineField(const char* name,
-                                     const uv_async_t& value,
-                                     const char* node_name) {
-  TrackInlineFieldWithSize(name, sizeof(value), "uv_async_t");
-}
-
-template <class NativeT, class V8T>
-void MemoryTracker::TrackField(const char* name,
-                               const AliasedBufferBase<NativeT, V8T>& value,
-                               const char* node_name) {
-  TrackField(name, value.GetJSArray(), "AliasedBuffer");
-}
-
-void MemoryTracker::Track(const MemoryRetainer* retainer,
-                          const char* edge_name) {
-  v8::HandleScope handle_scope(isolate_);
-  auto it = seen_.find(retainer);
-  if (it != seen_.end()) {
-    if (CurrentNode() != nullptr) {
-      graph_->AddEdge(CurrentNode(), it->second, edge_name);
-    }
-    return;  // It has already been tracked, no need to call MemoryInfo again
-  }
-  MemoryRetainerNode* n = PushNode(retainer, edge_name);
-  retainer->MemoryInfo(this);
-  CHECK_EQ(CurrentNode(), n);
-  CHECK_NE(n->size_, 0);
-  PopNode();
-}
-
-void MemoryTracker::TrackInlineField(const MemoryRetainer* retainer,
-                                     const char* edge_name) {
-  Track(retainer, edge_name);
-  CHECK(CurrentNode());
-  CurrentNode()->size_ -= retainer->SelfSize();
-}
-
-MemoryRetainerNode* MemoryTracker::CurrentNode() const {
-  if (node_stack_.empty()) return nullptr;
-  return node_stack_.top();
-}
-
-MemoryRetainerNode* MemoryTracker::AddNode(const MemoryRetainer* retainer,
-                                           const char* edge_name) {
-  auto it = seen_.find(retainer);
-  if (it != seen_.end()) {
-    return it->second;
-  }
-
-  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 (n->JSWrapperNode() != nullptr) {
-    graph_->AddEdge(n, n->JSWrapperNode(), "wrapped");
-    graph_->AddEdge(n->JSWrapperNode(), n, "wrapper");
-  }
-
-  return n;
-}
-
-MemoryRetainerNode* MemoryTracker::AddNode(const char* node_name,
-                                           size_t size,
-                                           const char* edge_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);
-
-  return n;
-}
-
-MemoryRetainerNode* MemoryTracker::PushNode(const MemoryRetainer* retainer,
-                                            const char* edge_name) {
-  MemoryRetainerNode* n = AddNode(retainer, edge_name);
-  node_stack_.push(n);
-  return n;
-}
-
-MemoryRetainerNode* MemoryTracker::PushNode(const char* node_name,
-                                            size_t size,
-                                            const char* edge_name) {
-  MemoryRetainerNode* n = AddNode(node_name, size, edge_name);
-  node_stack_.push(n);
-  return n;
-}
-
-void MemoryTracker::PopNode() {
-  node_stack_.pop();
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_MEMORY_TRACKER_INL_H_

package/src/headers/12/memory_tracker.h

@@ -1,283 +0,0 @@
-#pragma once
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "aliased_buffer.h"
-#include "v8-profiler.h"
-
-#include <uv.h>
-
-#include <limits>
-#include <queue>
-#include <stack>
-#include <string>
-#include <unordered_map>
-
-namespace node {
-
-// Set the node name of a MemoryRetainer to klass
-#define SET_MEMORY_INFO_NAME(Klass)                                            \
-  inline std::string MemoryInfoName() const override { return #Klass; }
-
-// Set the self size of a MemoryRetainer to the stack-allocated size of a
-// certain class
-#define SET_SELF_SIZE(Klass)                                                   \
-  inline size_t SelfSize() const override { return sizeof(Klass); }
-
-// Used when there is no additional fields to track
-#define SET_NO_MEMORY_INFO()                                                   \
-  inline void MemoryInfo(node::MemoryTracker* tracker) const override {}
-
-class MemoryTracker;
-class MemoryRetainerNode;
-template <typename T, bool kIsWeak>
-class BaseObjectPtrImpl;
-
-namespace crypto {
-class NodeBIO;
-}
-
-class CleanupHookCallback;
-
-/* Example:
- *
- * class ExampleRetainer : public MemoryRetainer {
- *   public:
- *     // Or use SET_NO_MEMORY_INFO() when there is no additional fields
- *     // to track.
- *     void MemoryInfo(MemoryTracker* tracker) const override {
- *       // Node name and size comes from the MemoryInfoName and SelfSize of
- *       // AnotherRetainerClass
- *       tracker->TrackField("another_retainer", another_retainer_);
- *
- *       // Add non_pointer_retainer as a separate node into the graph
- *       // and track its memory information recursively.
- *       // Note that we need to make sure its size is not accounted in
- *       // ExampleRetainer::SelfSize().
- *       tracker->TrackField("non_pointer_retainer", &non_pointer_retainer_);
- *
- *       // Specify node name and size explicitly
- *       tracker->TrackFieldWithSize("internal_member",
- *                                   internal_member_.size(),
- *                                   "InternalClass");
- *       // Node name falls back to the edge name,
- *       // elements in the container appear as grandchildren nodes
- *       tracker->TrackField("vector", vector_);
- *       // Node name and size come from the JS object
- *       tracker->TrackField("target", target_);
- *     }
- *
- *     // Or use SET_MEMORY_INFO_NAME(ExampleRetainer)
- *     std::string MemoryInfoName() const override {
- *       return "ExampleRetainer";
- *     }
- *
- *     // Classes that only want to return its sizeof() value can use the
- *     // SET_SELF_SIZE(Class) macro instead.
- *     size_t SelfSize() const override {
- *       // We need to exclude the size of non_pointer_retainer so that
- *       // we can track it separately in ExampleRetainer::MemoryInfo().
- *       return sizeof(ExampleRetainer) - sizeof(NonPointerRetainerClass);
- *     }
- *
- *     // Note: no need to implement these two methods when implementing
- *     // a BaseObject or an AsyncWrap class
- *     bool IsRootNode() const override { return !wrapped_.IsWeak(); }
- *     v8::Local<v8::Object> WrappedObject() const override {
- *       return node::PersistentToLocal::Default(wrapped_);
- *     }
- *
- *   private:
- *     AnotherRetainerClass* another_retainer_;
- *     NonPointerRetainerClass non_pointer_retainer;
- *     InternalClass internal_member_;
- *     std::vector<uv_async_t> vector_;
- *     v8::Global<Object> target_;
- *
- *     v8::Global<Object> wrapped_;
- * }
- *
- * This creates the following graph:
- *   Node / ExampleRetainer
- *    |> another_retainer :: Node / AnotherRetainerClass
- *    |> internal_member :: Node / InternalClass
- *    |> vector :: Node / vector (elements will be grandchildren)
- *        |> [1] :: Node / uv_async_t (uv_async_t has predefined names)
- *        |> [2] :: Node / uv_async_t
- *        |> ...
- *    |> target :: TargetClass (JS class name of the target object)
- *    |> wrapped :: WrappedClass (JS class name of the wrapped object)
- *        |> wrapper :: Node / ExampleRetainer (back reference)
- */
-class MemoryRetainer {
- public:
-  virtual ~MemoryRetainer() = default;
-
-  // Subclasses should implement these methods to provide information
-  // for the V8 heap snapshot generator.
-  // The MemoryInfo() method is assumed to be called within a context
-  // where all the edges start from the node of the current retainer,
-  // and point to the nodes as specified by tracker->Track* calls.
-  virtual void MemoryInfo(MemoryTracker* tracker) const = 0;
-  virtual std::string MemoryInfoName() const = 0;
-  virtual size_t SelfSize() const = 0;
-
-  virtual v8::Local<v8::Object> WrappedObject() const {
-    return v8::Local<v8::Object>();
-  }
-
-  virtual bool IsRootNode() const { return false; }
-};
-
-class MemoryTracker {
- public:
-  // Used to specify node name and size explicitly
-  inline void TrackFieldWithSize(const char* edge_name,
-                                 size_t size,
-                                 const char* node_name = nullptr);
-  inline void TrackInlineFieldWithSize(const char* edge_name,
-                                       size_t size,
-                                       const char* node_name = nullptr);
-
-  // Shortcut to extract the underlying object out of the smart pointer
-  template <typename T, typename D>
-  inline void TrackField(const char* edge_name,
-                         const std::unique_ptr<T, D>& value,
-                         const char* node_name = nullptr);
-
-  template <typename T, bool kIsWeak>
-  void TrackField(const char* edge_name,
-                  const BaseObjectPtrImpl<T, kIsWeak>& value,
-                  const char* node_name = nullptr);
-
-  // For containers, the elements will be graphed as grandchildren nodes
-  // if the container is not empty.
-  // By default, we assume the parent count the stack size of the container
-  // into its SelfSize so that will be subtracted from the parent size when we
-  // spin off a new node for the container.
-  // TODO(joyeecheung): use RTTI to retrieve the class name at runtime?
-  template <typename T, typename Iterator = typename T::const_iterator>
-  inline void TrackField(const char* edge_name,
-                         const T& value,
-                         const char* node_name = nullptr,
-                         const char* element_name = nullptr,
-                         bool subtract_from_self = true);
-  template <typename T>
-  inline void TrackField(const char* edge_name,
-                         const std::queue<T>& value,
-                         const char* node_name = nullptr,
-                         const char* element_name = nullptr);
-  template <typename T, typename U>
-  inline void TrackField(const char* edge_name,
-                         const std::pair<T, U>& value,
-                         const char* node_name = nullptr);
-
-  // For the following types, node_name will be ignored and predefined names
-  // will be used instead. They are only in the signature for template
-  // expansion.
-  inline void TrackField(const char* edge_name,
-                         const MemoryRetainer& value,
-                         const char* node_name = nullptr);
-  inline void TrackField(const char* edge_name,
-                         const MemoryRetainer* value,
-                         const char* node_name = nullptr);
-  template <typename T>
-  inline void TrackField(const char* edge_name,
-                         const std::basic_string<T>& value,
-                         const char* node_name = nullptr);
-  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* edge_name,
-                         const T& value,
-                         const char* node_name = nullptr);
-  template <typename T>
-  void TrackField(const char* edge_name,
-                  const v8::Eternal<T>& value,
-                  const char* node_name);
-  template <typename T>
-  inline void TrackField(const char* edge_name,
-                         const v8::PersistentBase<T>& value,
-                         const char* node_name = nullptr);
-  template <typename T>
-  inline void TrackField(const char* edge_name,
-                         const v8::Local<T>& value,
-                         const char* node_name = nullptr);
-  template <typename T>
-  inline void TrackField(const char* edge_name,
-                         const MallocedBuffer<T>& value,
-                         const char* node_name = nullptr);
-  // We do not implement CleanupHookCallback as MemoryRetainer
-  // but instead specialize the method here to avoid the cost of
-  // virtual pointers.
-  // TODO(joyeecheung): do this for BaseObject and remove WrappedObject()
-  void TrackField(const char* edge_name,
-                  const CleanupHookCallback& value,
-                  const char* node_name = nullptr);
-  inline void TrackField(const char* edge_name,
-                         const uv_buf_t& value,
-                         const char* node_name = nullptr);
-  inline void TrackField(const char* edge_name,
-                         const uv_timer_t& value,
-                         const char* node_name = nullptr);
-  inline void TrackField(const char* edge_name,
-                         const uv_async_t& value,
-                         const char* node_name = nullptr);
-  inline void TrackInlineField(const char* edge_name,
-                               const uv_async_t& value,
-                               const char* node_name = nullptr);
-  template <class NativeT, class V8T>
-  inline void TrackField(const char* edge_name,
-                         const AliasedBufferBase<NativeT, V8T>& value,
-                         const char* node_name = nullptr);
-
-  // Put a memory container into the graph, create an edge from
-  // the current node if there is one on the stack.
-  inline void Track(const MemoryRetainer* retainer,
-                    const char* edge_name = nullptr);
-
-  // Useful for parents that do not wish to perform manual
-  // adjustments to its `SelfSize()` when embedding retainer
-  // objects inline.
-  // Put a memory container into the graph, create an edge from
-  // the current node if there is one on the stack - there should
-  // be one, of the container object which the current field is part of.
-  // Reduce the size of memory from the container so as to avoid
-  // duplication in accounting.
-  inline void TrackInlineField(const MemoryRetainer* retainer,
-                               const char* edge_name = nullptr);
-
-  inline v8::EmbedderGraph* graph() { return graph_; }
-  inline v8::Isolate* isolate() { return isolate_; }
-
-  inline explicit MemoryTracker(v8::Isolate* isolate,
-                                v8::EmbedderGraph* graph)
-    : isolate_(isolate), graph_(graph) {}
-
- private:
-  typedef std::unordered_map<const MemoryRetainer*, MemoryRetainerNode*>
-      NodeMap;
-
-  inline MemoryRetainerNode* CurrentNode() const;
-  inline MemoryRetainerNode* AddNode(const MemoryRetainer* retainer,
-                                     const char* edge_name = nullptr);
-  inline MemoryRetainerNode* PushNode(const MemoryRetainer* retainer,
-                                      const char* edge_name = nullptr);
-  inline MemoryRetainerNode* AddNode(const char* node_name,
-                                     size_t size,
-                                     const char* edge_name = nullptr);
-  inline MemoryRetainerNode* PushNode(const char* node_name,
-                                      size_t size,
-                                      const char* edge_name = nullptr);
-  inline void PopNode();
-
-  v8::Isolate* isolate_;
-  v8::EmbedderGraph* graph_;
-  std::stack<MemoryRetainerNode*> node_stack_;
-  NodeMap seen_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS