Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	heap_utils.cc	Lines:	232	257	90.3 %
Date:	2022-12-31 04:22:30	Branches:	75	114	65.8 %


#include "diagnosticfilename-inl.h"
#include "env-inl.h"
#include "memory_tracker-inl.h"
#include "node_external_reference.h"
#include "stream_base-inl.h"
#include "util-inl.h"

// Copied from https://github.com/nodejs/node/blob/b07dc4d19fdbc15b4f76557dc45b3ce3a43ad0c3/src/util.cc#L36-L41.
#ifdef _WIN32
#include <io.h>  // _S_IREAD _S_IWRITE
#ifndef S_IRUSR
#define S_IRUSR _S_IREAD
#endif  // S_IRUSR
#ifndef S_IWUSR
#define S_IWUSR _S_IWRITE
#endif  // S_IWUSR
#endif

using v8::Array;
using v8::Boolean;
using v8::Context;
using v8::EmbedderGraph;
using v8::EscapableHandleScope;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Global;
using v8::HandleScope;
using v8::HeapProfiler;
using v8::HeapSnapshot;
using v8::Isolate;
using v8::JustVoid;
using v8::Local;
using v8::Maybe;
using v8::MaybeLocal;
using v8::Nothing;
using v8::Number;
using v8::Object;
using v8::ObjectTemplate;
using v8::String;
using v8::Uint8Array;
using v8::Value;

namespace node {
namespace heap {

class JSGraphJSNode : public EmbedderGraph::Node {
 public:
  const char* Name() override { return "<JS Node>"; }
  size_t SizeInBytes() override { return 0; }
  bool IsEmbedderNode() override { return false; }
  Local<Value> JSValue() { return PersistentToLocal::Strong(persistent_); }

  int IdentityHash() {
    Local<Value> v = JSValue();
    if (v->IsObject()) return v.As<Object>()->GetIdentityHash();
    if (v->IsName()) return v.As<v8::Name>()->GetIdentityHash();
    if (v->IsInt32()) return v.As<v8::Int32>()->Value();
    return 0;
  }

  JSGraphJSNode(Isolate* isolate, Local<Value> val)
      : persistent_(isolate, val) {
    CHECK(!val.IsEmpty());
  }

  struct Hash {
    inline size_t operator()(JSGraphJSNode* n) const {
      return static_cast<size_t>(n->IdentityHash());
    }
  };

  struct Equal {
    inline bool operator()(JSGraphJSNode* a, JSGraphJSNode* b) const {
      return a->JSValue()->SameValue(b->JSValue());
    }
  };

 private:
  Global<Value> persistent_;
};

class JSGraph : public EmbedderGraph {
 public:
  explicit JSGraph(Isolate* isolate) : isolate_(isolate) {}

  Node* V8Node(const Local<Value>& value) override {
    std::unique_ptr<JSGraphJSNode> n { new JSGraphJSNode(isolate_, value) };
    auto it = engine_nodes_.find(n.get());
    if (it != engine_nodes_.end())
      return *it;
    engine_nodes_.insert(n.get());
    return AddNode(std::unique_ptr<Node>(n.release()));
  }

  Node* AddNode(std::unique_ptr<Node> node) override {
    Node* n = node.get();
    nodes_.emplace(std::move(node));
    return n;
  }

  void AddEdge(Node* from, Node* to, const char* name = nullptr) override {
    edges_[from].insert(std::make_pair(name, to));
  }

  MaybeLocal<Array> CreateObject() const {
    EscapableHandleScope handle_scope(isolate_);
    Local<Context> context = isolate_->GetCurrentContext();
    Environment* env = Environment::GetCurrent(context);

    std::unordered_map<Node*, Local<Object>> info_objects;
    Local<Array> nodes = Array::New(isolate_, nodes_.size());
    Local<String> edges_string = FIXED_ONE_BYTE_STRING(isolate_, "edges");
    Local<String> is_root_string = FIXED_ONE_BYTE_STRING(isolate_, "isRoot");
    Local<String> name_string = env->name_string();
    Local<String> size_string = env->size_string();
    Local<String> value_string = env->value_string();
    Local<String> wraps_string = FIXED_ONE_BYTE_STRING(isolate_, "wraps");
    Local<String> to_string = FIXED_ONE_BYTE_STRING(isolate_, "to");

    for (const std::unique_ptr<Node>& n : nodes_)
      info_objects[n.get()] = Object::New(isolate_);

    {
      HandleScope handle_scope(isolate_);
      size_t i = 0;
      for (const std::unique_ptr<Node>& n : nodes_) {
        Local<Object> obj = info_objects[n.get()];
        Local<Value> value;
        std::string name_str;
        const char* prefix = n->NamePrefix();
        if (prefix == nullptr) {
          name_str = n->Name();
        } else {
          name_str = n->NamePrefix();
          name_str += " ";
          name_str += n->Name();
        }
        if (!String::NewFromUtf8(isolate_, name_str.c_str()).ToLocal(&value) ||
            obj->Set(context, name_string, value).IsNothing() ||
            obj->Set(context,
                     is_root_string,
                     Boolean::New(isolate_, n->IsRootNode()))
                .IsNothing() ||
            obj->Set(
                   context,
                   size_string,
                   Number::New(isolate_, static_cast<double>(n->SizeInBytes())))
                .IsNothing() ||
            obj->Set(context, edges_string, Array::New(isolate_)).IsNothing()) {
          return MaybeLocal<Array>();
        }
        if (nodes->Set(context, i++, obj).IsNothing())
          return MaybeLocal<Array>();
        if (!n->IsEmbedderNode()) {
          value = static_cast<JSGraphJSNode*>(n.get())->JSValue();
          if (obj->Set(context, value_string, value).IsNothing())
            return MaybeLocal<Array>();
        }
      }
    }

    for (const std::unique_ptr<Node>& n : nodes_) {
      Node* wraps = n->WrapperNode();
      if (wraps == nullptr) continue;
      Local<Object> from = info_objects[n.get()];
      Local<Object> to = info_objects[wraps];
      if (from->Set(context, wraps_string, to).IsNothing())
        return MaybeLocal<Array>();
    }

    for (const auto& edge_info : edges_) {
      Node* source = edge_info.first;
      Local<Value> edges;
      if (!info_objects[source]->Get(context, edges_string).ToLocal(&edges) ||
          !edges->IsArray()) {
        return MaybeLocal<Array>();
      }

      size_t i = 0;
      size_t j = 0;
      for (const auto& edge : edge_info.second) {
        Local<Object> to_object = info_objects[edge.second];
        Local<Object> edge_obj = Object::New(isolate_);
        Local<Value> edge_name_value;
        const char* edge_name = edge.first;
        if (edge_name != nullptr) {
          if (!String::NewFromUtf8(isolate_, edge_name)
              .ToLocal(&edge_name_value)) {
            return MaybeLocal<Array>();
          }
        } else {
          edge_name_value = Number::New(isolate_, static_cast<double>(j++));
        }
        if (edge_obj->Set(context, name_string, edge_name_value).IsNothing() ||
            edge_obj->Set(context, to_string, to_object).IsNothing() ||
            edges.As<Array>()->Set(context, i++, edge_obj).IsNothing()) {
          return MaybeLocal<Array>();
        }
      }
    }

    return handle_scope.Escape(nodes);
  }

 private:
  Isolate* isolate_;
  std::unordered_set<std::unique_ptr<Node>> nodes_;
  std::unordered_set<JSGraphJSNode*, JSGraphJSNode::Hash, JSGraphJSNode::Equal>
      engine_nodes_;
  std::unordered_map<Node*, std::set<std::pair<const char*, Node*>>> edges_;
};

void BuildEmbedderGraph(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  JSGraph graph(env->isolate());
  Environment::BuildEmbedderGraph(env->isolate(), &graph, env);
  Local<Array> ret;
  if (graph.CreateObject().ToLocal(&ret))
    args.GetReturnValue().Set(ret);
}

namespace {
class FileOutputStream : public v8::OutputStream {
 public:
  FileOutputStream(const int fd, uv_fs_t* req) : fd_(fd), req_(req) {}

  int GetChunkSize() override {
    return 65536;  // big chunks == faster
  }

  void EndOfStream() override {}

  WriteResult WriteAsciiChunk(char* data, const int size) override {
    DCHECK_EQ(status_, 0);
    int offset = 0;
    while (offset < size) {
      const uv_buf_t buf = uv_buf_init(data + offset, size - offset);
      const int num_bytes_written = uv_fs_write(nullptr,
                                                req_,
                                                fd_,
                                                &buf,
                                                1,
                                                -1,
                                                nullptr);
      uv_fs_req_cleanup(req_);
      if (num_bytes_written < 0) {
        status_ = num_bytes_written;
        return kAbort;
      }
      DCHECK_LE(static_cast<size_t>(num_bytes_written), buf.len);
      offset += num_bytes_written;
    }
    DCHECK_EQ(offset, size);
    return kContinue;
  }

  int status() const { return status_; }

 private:
  const int fd_;
  uv_fs_t* req_;
  int status_ = 0;
};

class HeapSnapshotStream : public AsyncWrap,
                           public StreamBase,
                           public v8::OutputStream {
 public:
  HeapSnapshotStream(
      Environment* env,
      HeapSnapshotPointer&& snapshot,
      Local<Object> obj) :
      AsyncWrap(env, obj, AsyncWrap::PROVIDER_HEAPSNAPSHOT),
      StreamBase(env),
      snapshot_(std::move(snapshot)) {
    MakeWeak();
    StreamBase::AttachToObject(GetObject());
  }

  ~HeapSnapshotStream() override {}

  int GetChunkSize() override {
    return 65536;  // big chunks == faster
  }

  void EndOfStream() override {
    EmitRead(UV_EOF);
    snapshot_.reset();
  }

  WriteResult WriteAsciiChunk(char* data, int size) override {
    int len = size;
    while (len != 0) {
      uv_buf_t buf = EmitAlloc(size);
      ssize_t avail = len;
      if (static_cast<ssize_t>(buf.len) < avail)
        avail = buf.len;
      memcpy(buf.base, data, avail);
      data += avail;
      len -= static_cast<int>(avail);
      EmitRead(size, buf);
    }
    return kContinue;
  }

  int ReadStart() override {
    CHECK_NE(snapshot_, nullptr);
    snapshot_->Serialize(this, HeapSnapshot::kJSON);
    return 0;
  }

  int ReadStop() override {
    return 0;
  }

  int DoShutdown(ShutdownWrap* req_wrap) override {
    UNREACHABLE();
  }

  int DoWrite(WriteWrap* w,
              uv_buf_t* bufs,
              size_t count,
              uv_stream_t* send_handle) override {
    UNREACHABLE();
  }

  bool IsAlive() override { return snapshot_ != nullptr; }
  bool IsClosing() override { return snapshot_ == nullptr; }
  AsyncWrap* GetAsyncWrap() override { return this; }

  void MemoryInfo(MemoryTracker* tracker) const override {
    if (snapshot_ != nullptr) {
      tracker->TrackFieldWithSize(
          "snapshot", sizeof(*snapshot_), "HeapSnapshot");
    }
  }

  SET_MEMORY_INFO_NAME(HeapSnapshotStream)
  SET_SELF_SIZE(HeapSnapshotStream)

 private:
  HeapSnapshotPointer snapshot_;
};

inline void TakeSnapshot(Environment* env,
                         v8::OutputStream* out,
                         HeapProfiler::HeapSnapshotOptions options) {
  HeapSnapshotPointer snapshot{
      env->isolate()->GetHeapProfiler()->TakeHeapSnapshot(options)};
  snapshot->Serialize(out, HeapSnapshot::kJSON);
}

}  // namespace

Maybe<void> WriteSnapshot(Environment* env,
                          const char* filename,
                          HeapProfiler::HeapSnapshotOptions options) {
  uv_fs_t req;
  int err;

  const int fd = uv_fs_open(nullptr,
                            &req,
                            filename,
                            O_WRONLY | O_CREAT | O_TRUNC,
                            S_IWUSR | S_IRUSR,
                            nullptr);
  uv_fs_req_cleanup(&req);
  if ((err = fd) < 0) {
    env->ThrowUVException(err, "open", nullptr, filename);
    return Nothing<void>();
  }

  FileOutputStream stream(fd, &req);
  TakeSnapshot(env, &stream, options);
  if ((err = stream.status()) < 0) {
    env->ThrowUVException(err, "write", nullptr, filename);
    return Nothing<void>();
  }

  err = uv_fs_close(nullptr, &req, fd, nullptr);
  uv_fs_req_cleanup(&req);
  if (err < 0) {
    env->ThrowUVException(err, "close", nullptr, filename);
    return Nothing<void>();
  }

  return JustVoid();
}

void DeleteHeapSnapshot(const HeapSnapshot* snapshot) {
  const_cast<HeapSnapshot*>(snapshot)->Delete();
}

BaseObjectPtr<AsyncWrap> CreateHeapSnapshotStream(
    Environment* env, HeapSnapshotPointer&& snapshot) {
  HandleScope scope(env->isolate());

  if (env->streambaseoutputstream_constructor_template().IsEmpty()) {
    // Create FunctionTemplate for HeapSnapshotStream
    Local<FunctionTemplate> os = FunctionTemplate::New(env->isolate());
    os->Inherit(AsyncWrap::GetConstructorTemplate(env));
    Local<ObjectTemplate> ost = os->InstanceTemplate();
    ost->SetInternalFieldCount(StreamBase::kInternalFieldCount);
    os->SetClassName(
        FIXED_ONE_BYTE_STRING(env->isolate(), "HeapSnapshotStream"));
    StreamBase::AddMethods(env, os);
    env->set_streambaseoutputstream_constructor_template(ost);
  }

  Local<Object> obj;
  if (!env->streambaseoutputstream_constructor_template()
           ->NewInstance(env->context())
           .ToLocal(&obj)) {
    return {};
  }
  return MakeBaseObject<HeapSnapshotStream>(env, std::move(snapshot), obj);
}

HeapProfiler::HeapSnapshotOptions GetHeapSnapshotOptions(
    Local<Value> options_value) {
  CHECK(options_value->IsUint8Array());
  Local<Uint8Array> arr = options_value.As<Uint8Array>();
  uint8_t* options =
      static_cast<uint8_t*>(arr->Buffer()->Data()) + arr->ByteOffset();
  HeapProfiler::HeapSnapshotOptions result;
  result.snapshot_mode = options[0]
                             ? HeapProfiler::HeapSnapshotMode::kExposeInternals
                             : HeapProfiler::HeapSnapshotMode::kRegular;
  result.numerics_mode = options[1]
                             ? HeapProfiler::NumericsMode::kExposeNumericValues
                             : HeapProfiler::NumericsMode::kHideNumericValues;
  return result;
}

void CreateHeapSnapshotStream(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  CHECK_EQ(args.Length(), 1);
  auto options = GetHeapSnapshotOptions(args[0]);
  HeapSnapshotPointer snapshot{
      env->isolate()->GetHeapProfiler()->TakeHeapSnapshot(options)};
  CHECK(snapshot);
  BaseObjectPtr<AsyncWrap> stream =
      CreateHeapSnapshotStream(env, std::move(snapshot));
  if (stream)
    args.GetReturnValue().Set(stream->object());
}

void TriggerHeapSnapshot(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  Isolate* isolate = args.GetIsolate();
  CHECK_EQ(args.Length(), 2);
  Local<Value> filename_v = args[0];
  auto options = GetHeapSnapshotOptions(args[1]);

  if (filename_v->IsUndefined()) {
    DiagnosticFilename name(env, "Heap", "heapsnapshot");
    if (WriteSnapshot(env, *name, options).IsNothing()) return;
    if (String::NewFromUtf8(isolate, *name).ToLocal(&filename_v)) {
      args.GetReturnValue().Set(filename_v);
    }
    return;
  }

  BufferValue path(isolate, filename_v);
  CHECK_NOT_NULL(*path);
  if (WriteSnapshot(env, *path, options).IsNothing()) return;
  return args.GetReturnValue().Set(filename_v);
}

void Initialize(Local<Object> target,
                Local<Value> unused,
                Local<Context> context,
                void* priv) {
  SetMethod(context, target, "buildEmbedderGraph", BuildEmbedderGraph);
  SetMethod(context, target, "triggerHeapSnapshot", TriggerHeapSnapshot);
  SetMethod(
      context, target, "createHeapSnapshotStream", CreateHeapSnapshotStream);
}

void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
  registry->Register(BuildEmbedderGraph);
  registry->Register(TriggerHeapSnapshot);
  registry->Register(CreateHeapSnapshotStream);
}

}  // namespace heap
}  // namespace node

NODE_BINDING_CONTEXT_AWARE_INTERNAL(heap_utils, node::heap::Initialize)
NODE_BINDING_EXTERNAL_REFERENCE(heap_utils,
                                node::heap::RegisterExternalReferences)


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#include "diagnosticfilename-inl.h"
2			#include "env-inl.h"
3			#include "memory_tracker-inl.h"
4			#include "node_external_reference.h"
5			#include "stream_base-inl.h"
6			#include "util-inl.h"
7
8			// Copied from https://github.com/nodejs/node/blob/b07dc4d19fdbc15b4f76557dc45b3ce3a43ad0c3/src/util.cc#L36-L41.
9			#ifdef _WIN32
10			#include <io.h> // _S_IREAD _S_IWRITE
11			#ifndef S_IRUSR
12			#define S_IRUSR _S_IREAD
13			#endif // S_IRUSR
14			#ifndef S_IWUSR
15			#define S_IWUSR _S_IWRITE
16			#endif // S_IWUSR
17			#endif
18
19			using v8::Array;
20			using v8::Boolean;
21			using v8::Context;
22			using v8::EmbedderGraph;
23			using v8::EscapableHandleScope;
24			using v8::FunctionCallbackInfo;
25			using v8::FunctionTemplate;
26			using v8::Global;
27			using v8::HandleScope;
28			using v8::HeapProfiler;
29			using v8::HeapSnapshot;
30			using v8::Isolate;
31			using v8::JustVoid;
32			using v8::Local;
33			using v8::Maybe;
34			using v8::MaybeLocal;
35			using v8::Nothing;
36			using v8::Number;
37			using v8::Object;
38			using v8::ObjectTemplate;
39			using v8::String;
40			using v8::Uint8Array;
41			using v8::Value;
42
43			namespace node {
44			namespace heap {
45
46			class JSGraphJSNode : public EmbedderGraph::Node {
47			public:
48		2581	const char* Name() override { return "<JS Node>"; }
49		2581	size_t SizeInBytes() override { return 0; }
50		2581	bool IsEmbedderNode() override { return false; }
51		7749	Local<Value> JSValue() { return PersistentToLocal::Strong(persistent_); }
52
53		5164	int IdentityHash() {
54		5164	Local<Value> v = JSValue();
55	✓✓	6164	if (v->IsObject()) return v.As<Object>()->GetIdentityHash();
56	✓✗	8328	if (v->IsName()) return v.As<v8::Name>()->GetIdentityHash();
57			if (v->IsInt32()) return v.As<v8::Int32>()->Value();
58			return 0;
59			}
60
61		2583	JSGraphJSNode(Isolate* isolate, Local<Value> val)
62		5166	: persistent_(isolate, val) {
63	✗✓	2583	CHECK(!val.IsEmpty());
64		2583	}
65
66			struct Hash {
67		5164	inline size_t operator()(JSGraphJSNode* n) const {
68		5164	return static_cast<size_t>(n->IdentityHash());
69			}
70			};
71
72			struct Equal {
73		2	inline bool operator()(JSGraphJSNode* a, JSGraphJSNode* b) const {
74		4	return a->JSValue()->SameValue(b->JSValue());
75			}
76			};
77
78			private:
79			Global<Value> persistent_;
80			};
81
82			class JSGraph : public EmbedderGraph {
83			public:
84		6	explicit JSGraph(Isolate* isolate) : isolate_(isolate) {}
85
86		2583	Node* V8Node(const Local<Value>& value) override {
87		5166	std::unique_ptr<JSGraphJSNode> n { new JSGraphJSNode(isolate_, value) };
88		2583	auto it = engine_nodes_.find(n.get());
89	✓✓	2583	if (it != engine_nodes_.end())
90		2	return *it;
91		2581	engine_nodes_.insert(n.get());
92		2581	return AddNode(std::unique_ptr<Node>(n.release()));
93			}
94
95		3462	Node* AddNode(std::unique_ptr<Node> node) override {
96		3462	Node* n = node.get();
97		3462	nodes_.emplace(std::move(node));
98		3462	return n;
99			}
100
101		3810	void AddEdge(Node* from, Node* to, const char* name = nullptr) override {
102		7620	edges_[from].insert(std::make_pair(name, to));
103		3810	}
104
105		6	MaybeLocal<Array> CreateObject() const {
106		6	EscapableHandleScope handle_scope(isolate_);
107		6	Local<Context> context = isolate_->GetCurrentContext();
108		6	Environment* env = Environment::GetCurrent(context);
109
110		12	std::unordered_map<Node*, Local<Object>> info_objects;
111		6	Local<Array> nodes = Array::New(isolate_, nodes_.size());
112		6	Local<String> edges_string = FIXED_ONE_BYTE_STRING(isolate_, "edges");
113		6	Local<String> is_root_string = FIXED_ONE_BYTE_STRING(isolate_, "isRoot");
114		6	Local<String> name_string = env->name_string();
115		6	Local<String> size_string = env->size_string();
116		6	Local<String> value_string = env->value_string();
117		6	Local<String> wraps_string = FIXED_ONE_BYTE_STRING(isolate_, "wraps");
118		6	Local<String> to_string = FIXED_ONE_BYTE_STRING(isolate_, "to");
119
120	✓✓	3468	for (const std::unique_ptr<Node>& n : nodes_)
121		3462	info_objects[n.get()] = Object::New(isolate_);
122
123			{
124		6	HandleScope handle_scope(isolate_);
125		6	size_t i = 0;
126	✓✓	3468	for (const std::unique_ptr<Node>& n : nodes_) {
127		3462	Local<Object> obj = info_objects[n.get()];
128			Local<Value> value;
129		3462	std::string name_str;
130		3462	const char* prefix = n->NamePrefix();
131	✓✓	3462	if (prefix == nullptr) {
132		2581	name_str = n->Name();
133			} else {
134		881	name_str = n->NamePrefix();
135		881	name_str += " ";
136		881	name_str += n->Name();
137			}
138		3462	if (!String::NewFromUtf8(isolate_, name_str.c_str()).ToLocal(&value) \|\|
139	✓✗	6924	obj->Set(context, name_string, value).IsNothing() \|\|
140		3462	obj->Set(context,
141			is_root_string,
142	✓✓	6924	Boolean::New(isolate_, n->IsRootNode()))
143	✓✗	3462	.IsNothing() \|\|
144		3462	obj->Set(
145			context,
146			size_string,
147		6924	Number::New(isolate_, static_cast<double>(n->SizeInBytes())))
148	✓✗✓✗	10386	.IsNothing() \|\|
149	✗✓✗✓	13848	obj->Set(context, edges_string, Array::New(isolate_)).IsNothing()) {
150			return MaybeLocal<Array>();
151			}
152	✗✓	6924	if (nodes->Set(context, i++, obj).IsNothing())
153			return MaybeLocal<Array>();
154	✓✓	3462	if (!n->IsEmbedderNode()) {
155		2581	value = static_cast<JSGraphJSNode*>(n.get())->JSValue();
156	✗✓	5162	if (obj->Set(context, value_string, value).IsNothing())
157			return MaybeLocal<Array>();
158			}
159			}
160			}
161
162	✓✓	3468	for (const std::unique_ptr<Node>& n : nodes_) {
163		3462	Node* wraps = n->WrapperNode();
164	✓✗	3462	if (wraps == nullptr) continue;
165			Local<Object> from = info_objects[n.get()];
166			Local<Object> to = info_objects[wraps];
167			if (from->Set(context, wraps_string, to).IsNothing())
168			return MaybeLocal<Array>();
169			}
170
171	✓✓	412	for (const auto& edge_info : edges_) {
172		406	Node* source = edge_info.first;
173			Local<Value> edges;
174	✓✗✗✓	1624	if (!info_objects[source]->Get(context, edges_string).ToLocal(&edges) \|\|
175	✗✓	406	!edges->IsArray()) {
176			return MaybeLocal<Array>();
177			}
178
179		406	size_t i = 0;
180		406	size_t j = 0;
181	✓✓	4216	for (const auto& edge : edge_info.second) {
182		3810	Local<Object> to_object = info_objects[edge.second];
183		3810	Local<Object> edge_obj = Object::New(isolate_);
184			Local<Value> edge_name_value;
185		3810	const char* edge_name = edge.first;
186	✓✓	3810	if (edge_name != nullptr) {
187		2496	if (!String::NewFromUtf8(isolate_, edge_name)
188	✗✓	2496	.ToLocal(&edge_name_value)) {
189			return MaybeLocal<Array>();
190			}
191			} else {
192		2628	edge_name_value = Number::New(isolate_, static_cast<double>(j++));
193			}
194		3810	if (edge_obj->Set(context, name_string, edge_name_value).IsNothing() \|\|
195	✓✗✓✗	15240	edge_obj->Set(context, to_string, to_object).IsNothing() \|\|
196	✗✓✗✓	11430	edges.As<Array>()->Set(context, i++, edge_obj).IsNothing()) {
197			return MaybeLocal<Array>();
198			}
199			}
200			}
201
202		6	return handle_scope.Escape(nodes);
203			}
204
205			private:
206			Isolate* isolate_;
207			std::unordered_set<std::unique_ptr<Node>> nodes_;
208			std::unordered_set<JSGraphJSNode*, JSGraphJSNode::Hash, JSGraphJSNode::Equal>
209			engine_nodes_;
210			std::unordered_map<Node, std::set<std::pair<const char, Node*>>> edges_;
211			};
212
213		6	void BuildEmbedderGraph(const FunctionCallbackInfo<Value>& args) {
214		6	Environment* env = Environment::GetCurrent(args);
215		12	JSGraph graph(env->isolate());
216		6	Environment::BuildEmbedderGraph(env->isolate(), &graph, env);
217			Local<Array> ret;
218	✓✗	12	if (graph.CreateObject().ToLocal(&ret))
219		12	args.GetReturnValue().Set(ret);
220		6	}
221
222			namespace {
223			class FileOutputStream : public v8::OutputStream {
224			public:
225		8	FileOutputStream(const int fd, uv_fs_t* req) : fd_(fd), req_(req) {}
226
227		16	int GetChunkSize() override {
228		16	return 65536; // big chunks == faster
229			}
230
231		8	void EndOfStream() override {}
232
233		627	WriteResult WriteAsciiChunk(char* data, const int size) override {
234			DCHECK_EQ(status_, 0);
235		627	int offset = 0;
236	✓✓	1254	while (offset < size) {
237		627	const uv_buf_t buf = uv_buf_init(data + offset, size - offset);
238		627	const int num_bytes_written = uv_fs_write(nullptr,
239			req_,
240		627	fd_,
241			&buf,
242			1,
243			-1,
244			nullptr);
245		627	uv_fs_req_cleanup(req_);
246	✗✓	627	if (num_bytes_written < 0) {
247			status_ = num_bytes_written;
248			return kAbort;
249			}
250			DCHECK_LE(static_cast<size_t>(num_bytes_written), buf.len);
251		627	offset += num_bytes_written;
252			}
253			DCHECK_EQ(offset, size);
254		627	return kContinue;
255			}
256
257		8	int status() const { return status_; }
258
259			private:
260			const int fd_;
261			uv_fs_t* req_;
262			int status_ = 0;
263			};
264
265			class HeapSnapshotStream : public AsyncWrap,
266			public StreamBase,
267			public v8::OutputStream {
268			public:
269		20	HeapSnapshotStream(
270			Environment* env,
271			HeapSnapshotPointer&& snapshot,
272		20	Local<Object> obj) :
273			AsyncWrap(env, obj, AsyncWrap::PROVIDER_HEAPSNAPSHOT),
274			StreamBase(env),
275		20	snapshot_(std::move(snapshot)) {
276		20	MakeWeak();
277		20	StreamBase::AttachToObject(GetObject());
278		20	}
279
280		80	~HeapSnapshotStream() override {}
281
282		34	int GetChunkSize() override {
283		34	return 65536; // big chunks == faster
284			}
285
286		17	void EndOfStream() override {
287		17	EmitRead(UV_EOF);
288			snapshot_.reset();
289		17	}
290
291		1362	WriteResult WriteAsciiChunk(char* data, int size) override {
292		1362	int len = size;
293	✓✓	2724	while (len != 0) {
294		1362	uv_buf_t buf = EmitAlloc(size);
295		1362	ssize_t avail = len;
296	✗✓	1362	if (static_cast<ssize_t>(buf.len) < avail)
297			avail = buf.len;
298		1362	memcpy(buf.base, data, avail);
299		1362	data += avail;
300		1362	len -= static_cast<int>(avail);
301		1362	EmitRead(size, buf);
302			}
303		1362	return kContinue;
304			}
305
306		17	int ReadStart() override {
307	✗✓	17	CHECK_NE(snapshot_, nullptr);
308		17	snapshot_->Serialize(this, HeapSnapshot::kJSON);
309		17	return 0;
310			}
311
312		1362	int ReadStop() override {
313		1362	return 0;
314			}
315
316			int DoShutdown(ShutdownWrap* req_wrap) override {
317			UNREACHABLE();
318			}
319
320			int DoWrite(WriteWrap* w,
321			uv_buf_t* bufs,
322			size_t count,
323			uv_stream_t* send_handle) override {
324			UNREACHABLE();
325			}
326
327		1379	bool IsAlive() override { return snapshot_ != nullptr; }
328			bool IsClosing() override { return snapshot_ == nullptr; }
329		2778	AsyncWrap* GetAsyncWrap() override { return this; }
330
331		12	void MemoryInfo(MemoryTracker* tracker) const override {
332	✓✓	12	if (snapshot_ != nullptr) {
333		7	tracker->TrackFieldWithSize(
334			"snapshot", sizeof(*snapshot_), "HeapSnapshot");
335			}
336		12	}
337
338		12	SET_MEMORY_INFO_NAME(HeapSnapshotStream)
339		12	SET_SELF_SIZE(HeapSnapshotStream)
340
341			private:
342			HeapSnapshotPointer snapshot_;
343			};
344
345		8	inline void TakeSnapshot(Environment* env,
346			v8::OutputStream* out,
347			HeapProfiler::HeapSnapshotOptions options) {
348			HeapSnapshotPointer snapshot{
349		16	env->isolate()->GetHeapProfiler()->TakeHeapSnapshot(options)};
350		8	snapshot->Serialize(out, HeapSnapshot::kJSON);
351		8	}
352
353			} // namespace
354
355		9	Maybe<void> WriteSnapshot(Environment* env,
356			const char* filename,
357			HeapProfiler::HeapSnapshotOptions options) {
358			uv_fs_t req;
359			int err;
360
361		9	const int fd = uv_fs_open(nullptr,
362			&req,
363			filename,
364			O_WRONLY \| O_CREAT \| O_TRUNC,
365			S_IWUSR \| S_IRUSR,
366			nullptr);
367		9	uv_fs_req_cleanup(&req);
368	✓✓	9	if ((err = fd) < 0) {
369		1	env->ThrowUVException(err, "open", nullptr, filename);
370		1	return Nothing<void>();
371			}
372
373		16	FileOutputStream stream(fd, &req);
374		8	TakeSnapshot(env, &stream, options);
375	✗✓	8	if ((err = stream.status()) < 0) {
376			env->ThrowUVException(err, "write", nullptr, filename);
377			return Nothing<void>();
378			}
379
380		8	err = uv_fs_close(nullptr, &req, fd, nullptr);
381		8	uv_fs_req_cleanup(&req);
382	✗✓	8	if (err < 0) {
383			env->ThrowUVException(err, "close", nullptr, filename);
384			return Nothing<void>();
385			}
386
387		8	return JustVoid();
388			}
389
390		28	void DeleteHeapSnapshot(const HeapSnapshot* snapshot) {
391		28	const_cast<HeapSnapshot*>(snapshot)->Delete();
392		28	}
393
394		20	BaseObjectPtr<AsyncWrap> CreateHeapSnapshotStream(
395			Environment* env, HeapSnapshotPointer&& snapshot) {
396		40	HandleScope scope(env->isolate());
397
398	✓✓	40	if (env->streambaseoutputstream_constructor_template().IsEmpty()) {
399			// Create FunctionTemplate for HeapSnapshotStream
400		10	Local<FunctionTemplate> os = FunctionTemplate::New(env->isolate());
401		10	os->Inherit(AsyncWrap::GetConstructorTemplate(env));
402		10	Local<ObjectTemplate> ost = os->InstanceTemplate();
403		10	ost->SetInternalFieldCount(StreamBase::kInternalFieldCount);
404		10	os->SetClassName(
405			FIXED_ONE_BYTE_STRING(env->isolate(), "HeapSnapshotStream"));
406		10	StreamBase::AddMethods(env, os);
407		10	env->set_streambaseoutputstream_constructor_template(ost);
408			}
409
410			Local<Object> obj;
411		20	if (!env->streambaseoutputstream_constructor_template()
412		20	->NewInstance(env->context())
413	✗✓	20	.ToLocal(&obj)) {
414			return {};
415			}
416		20	return MakeBaseObject<HeapSnapshotStream>(env, std::move(snapshot), obj);
417			}
418
419		27	HeapProfiler::HeapSnapshotOptions GetHeapSnapshotOptions(
420			Local<Value> options_value) {
421	✗✓	27	CHECK(options_value->IsUint8Array());
422		27	Local<Uint8Array> arr = options_value.As<Uint8Array>();
423			uint8_t* options =
424		81	static_cast<uint8_t*>(arr->Buffer()->Data()) + arr->ByteOffset();
425		27	HeapProfiler::HeapSnapshotOptions result;
426		54	result.snapshot_mode = options[0]
427	✓✓	27	? HeapProfiler::HeapSnapshotMode::kExposeInternals
428			: HeapProfiler::HeapSnapshotMode::kRegular;
429		54	result.numerics_mode = options[1]
430	✓✓	27	? HeapProfiler::NumericsMode::kExposeNumericValues
431			: HeapProfiler::NumericsMode::kHideNumericValues;
432		27	return result;
433			}
434
435		17	void CreateHeapSnapshotStream(const FunctionCallbackInfo<Value>& args) {
436		17	Environment* env = Environment::GetCurrent(args);
437	✗✓	17	CHECK_EQ(args.Length(), 1);
438		17	auto options = GetHeapSnapshotOptions(args[0]);
439			HeapSnapshotPointer snapshot{
440		34	env->isolate()->GetHeapProfiler()->TakeHeapSnapshot(options)};
441	✗✓	17	CHECK(snapshot);
442			BaseObjectPtr<AsyncWrap> stream =
443		34	CreateHeapSnapshotStream(env, std::move(snapshot));
444	✓✗	17	if (stream)
445		34	args.GetReturnValue().Set(stream->object());
446		17	}
447
448		7	void TriggerHeapSnapshot(const FunctionCallbackInfo<Value>& args) {
449		7	Environment* env = Environment::GetCurrent(args);
450		7	Isolate* isolate = args.GetIsolate();
451	✗✓	7	CHECK_EQ(args.Length(), 2);
452	✓✗	7	Local<Value> filename_v = args[0];
453		7	auto options = GetHeapSnapshotOptions(args[1]);
454
455	✓✓	14	if (filename_v->IsUndefined()) {
456		10	DiagnosticFilename name(env, "Heap", "heapsnapshot");
457	✗✓	10	if (WriteSnapshot(env, *name, options).IsNothing()) return;
458	✓✗	10	if (String::NewFromUtf8(isolate, *name).ToLocal(&filename_v)) {
459		10	args.GetReturnValue().Set(filename_v);
460			}
461		5	return;
462			}
463
464		4	BufferValue path(isolate, filename_v);
465	✗✓	2	CHECK_NOT_NULL(*path);
466	✓✓	4	if (WriteSnapshot(env, *path, options).IsNothing()) return;
467		2	return args.GetReturnValue().Set(filename_v);
468			}
469
470		737	void Initialize(Local<Object> target,
471			Local<Value> unused,
472			Local<Context> context,
473			void* priv) {
474		737	SetMethod(context, target, "buildEmbedderGraph", BuildEmbedderGraph);
475		737	SetMethod(context, target, "triggerHeapSnapshot", TriggerHeapSnapshot);
476		737	SetMethod(
477			context, target, "createHeapSnapshotStream", CreateHeapSnapshotStream);
478		737	}
479
480		5717	void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
481		5717	registry->Register(BuildEmbedderGraph);
482		5717	registry->Register(TriggerHeapSnapshot);
483		5717	registry->Register(CreateHeapSnapshotStream);
484		5717	}
485
486			} // namespace heap
487			} // namespace node
488
489		5788	NODE_BINDING_CONTEXT_AWARE_INTERNAL(heap_utils, node::heap::Initialize)
490		5717	NODE_BINDING_EXTERNAL_REFERENCE(heap_utils,
491			node::heap::RegisterExternalReferences)