Gecko [ oric.aiou.edu.pk ]

Name	Size	Permission
aliased_buffer.h	6.42 KB	-rw-r--r--
async_wrap-inl.h	3.33 KB	-rw-r--r--
async_wrap.h	9.16 KB	-rw-r--r--
base64.h	5.82 KB	-rw-r--r--
base_object-inl.h	4.02 KB	-rw-r--r--
base_object.h	4.43 KB	-rw-r--r--
connect_wrap.h	617 B	-rw-r--r--
connection_wrap.h	699 B	-rw-r--r--
debug_utils.h	4.29 KB	-rw-r--r--
env-inl.h	30.64 KB	-rw-r--r--
env.h	46.48 KB	-rw-r--r--
handle_wrap.h	3.91 KB	-rw-r--r--
inspector_agent.h	4.13 KB	-rw-r--r--
inspector_io.h	2.63 KB	-rw-r--r--
inspector_socket.h	1.46 KB	-rw-r--r--
inspector_socket_server.h	3.21 KB	-rw-r--r--
js_stream.h	1.58 KB	-rw-r--r--
memory_tracker-inl.h	10.83 KB	-rw-r--r--
memory_tracker.h	9.96 KB	-rw-r--r--
module_wrap.h	3.07 KB	-rw-r--r--
node.h	35.16 KB	-rw-r--r--
node_api.h	35.44 KB	-rw-r--r--
node_api_types.h	4.16 KB	-rw-r--r--
node_buffer.h	3.4 KB	-rw-r--r--
node_code_cache.h	432 B	-rw-r--r--
node_constants.h	3.11 KB	-rw-r--r--
node_context_data.h	1.14 KB	-rw-r--r--
node_contextify.h	4.81 KB	-rw-r--r--
node_counters.h	2.37 KB	-rw-r--r--
node_crypto.h	23.92 KB	-rw-r--r--
node_crypto_bio.h	5.44 KB	-rw-r--r--
node_crypto_clienthello-inl.h	2.62 KB	-rw-r--r--
node_crypto_clienthello.h	4 KB	-rw-r--r--
node_crypto_groups.h	23.12 KB	-rw-r--r--
node_dtrace.h	2.91 KB	-rw-r--r--
node_errors.h	6.06 KB	-rw-r--r--
node_file.h	10.16 KB	-rw-r--r--
node_http2.h	47.76 KB	-rw-r--r--
node_http2_state.h	4.72 KB	-rw-r--r--
node_i18n.h	2.4 KB	-rw-r--r--
node_internals.h	28.47 KB	-rw-r--r--
node_javascript.h	1.72 KB	-rw-r--r--
node_messaging.h	8.38 KB	-rw-r--r--
node_mutex.h	4.42 KB	-rw-r--r--
node_object_wrap.h	3.7 KB	-rw-r--r--
node_options-inl.h	14.78 KB	-rw-r--r--
node_options.h	12.25 KB	-rw-r--r--
node_perf.h	3.64 KB	-rw-r--r--
node_perf_common.h	3 KB	-rw-r--r--
node_persistent.h	936 B	-rw-r--r--
node_platform.h	5.14 KB	-rw-r--r--
node_revert.h	2.21 KB	-rw-r--r--
node_root_certs.h	223.29 KB	-rw-r--r--
node_stat_watcher.h	2.15 KB	-rw-r--r--
node_url.h	6.16 KB	-rw-r--r--
node_version.h	3.79 KB	-rw-r--r--
node_watchdog.h	3.03 KB	-rw-r--r--
node_win32_etw_provider-inl.h	11.67 KB	-rw-r--r--
node_win32_etw_provider.h	3.67 KB	-rw-r--r--
node_win32_perfctr_provider.h	2.14 KB	-rw-r--r--
node_worker.h	2.88 KB	-rw-r--r--
pipe_wrap.h	2.62 KB	-rw-r--r--
req_wrap-inl.h	5.44 KB	-rw-r--r--
req_wrap.h	1.87 KB	-rw-r--r--
sharedarraybuffer_metadata.h	2.34 KB	-rw-r--r--
spawn_sync.h	6.82 KB	-rw-r--r--
stream_base-inl.h	14.08 KB	-rw-r--r--
stream_base.h	13.46 KB	-rw-r--r--
stream_pipe.h	2 KB	-rw-r--r--
stream_wrap.h	4.03 KB	-rw-r--r--
string_bytes.h	5.14 KB	-rw-r--r--
string_decoder-inl.h	876 B	-rw-r--r--
string_decoder.h	1.5 KB	-rw-r--r--
string_search.h	20.53 KB	-rw-r--r--
tcp_wrap.h	3.59 KB	-rw-r--r--
tls_wrap.h	6.61 KB	-rw-r--r--
tty_wrap.h	2.22 KB	-rw-r--r--
udp_wrap.h	4.12 KB	-rw-r--r--
util-inl.h	14.06 KB	-rw-r--r--
util.h	15.9 KB	-rw-r--r--
v8abbr.h	5.03 KB	-rw-r--r--

Code Editor : memory_tracker.h

#ifndef SRC_MEMORY_TRACKER_H_
#define SRC_MEMORY_TRACKER_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include <unordered_map>
#include <queue>
#include <stack>
#include <string>
#include <limits>
#include <uv.h>
#include "aliased_buffer.h"
#include "v8-profiler.h"

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;

namespace crypto {
class NodeBIO;
}

/* 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(wrapped_);
 *     }
 *
 *   private:
 *     AnotherRetainerClass* another_retainer_;
 *     NonPointerRetainerClass non_pointer_retainer;
 *     InternalClass internal_member_;
 *     std::vector<uv_async_t> vector_;
 *     node::Persistent<Object> target_;
 *
 *     node::Persistent<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() {}

// 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);
  // Shortcut to extract the underlying object out of the smart pointer
  template <typename T>
  inline void TrackField(const char* edge_name,
                         const std::unique_ptr<T>& 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, typename Traits>
  inline void TrackField(const char* edge_name,
                         const v8::Persistent<T, Traits>& 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);
  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);
  template <class NativeT, class V8T>
  inline void TrackField(const char* edge_name,
                         const AliasedBuffer<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);

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

#endif  // SRC_MEMORY_TRACKER_H_

${this.title}

Code Editor : memory_tracker.h