Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	heap_utils.cc	Lines:	114	231	49.4 %
Date:	2022-02-19 04:14:15	Branches:	28	108	25.9 %


#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"

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::HeapSnapshot;
using v8::Isolate;
using v8::Local;
using v8::MaybeLocal;
using v8::Number;
using v8::Object;
using v8::ObjectTemplate;
using v8::String;
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:
  explicit FileOutputStream(FILE* stream) : stream_(stream) {}

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

  void EndOfStream() override {}

  WriteResult WriteAsciiChunk(char* data, int size) override {
    const size_t len = static_cast<size_t>(size);
    size_t off = 0;

    while (off < len && !feof(stream_) && !ferror(stream_))
      off += fwrite(data + off, 1, len - off, stream_);

    return off == len ? kContinue : kAbort;
  }

 private:
  FILE* stream_;
};

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) {
  HeapSnapshotPointer snapshot {
      env->isolate()->GetHeapProfiler()->TakeHeapSnapshot() };
  snapshot->Serialize(out, HeapSnapshot::kJSON);
}

}  // namespace

bool WriteSnapshot(Environment* env, const char* filename) {
  FILE* fp = fopen(filename, "w");
  if (fp == nullptr) {
    env->ThrowErrnoException(errno, "open");
    return false;
  }
  FileOutputStream stream(fp);
  TakeSnapshot(env, &stream);
  if (fclose(fp) == EOF) {
    env->ThrowErrnoException(errno, "close");
    return false;
  }
  return true;
}

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);
}

void CreateHeapSnapshotStream(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  HeapSnapshotPointer snapshot {
      env->isolate()->GetHeapProfiler()->TakeHeapSnapshot() };
  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();

  Local<Value> filename_v = args[0];

  if (filename_v->IsUndefined()) {
    DiagnosticFilename name(env, "Heap", "heapsnapshot");
    if (!WriteSnapshot(env, *name))
      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))
    return;
  return args.GetReturnValue().Set(filename_v);
}

void Initialize(Local<Object> target,
                Local<Value> unused,
                Local<Context> context,
                void* priv) {
  Environment* env = Environment::GetCurrent(context);

  env->SetMethod(target, "buildEmbedderGraph", BuildEmbedderGraph);
  env->SetMethod(target, "triggerHeapSnapshot", TriggerHeapSnapshot);
  env->SetMethod(target, "createHeapSnapshotStream", CreateHeapSnapshotStream);
}

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

}  // namespace heap
}  // namespace node

NODE_MODULE_CONTEXT_AWARE_INTERNAL(heap_utils, node::heap::Initialize)
NODE_MODULE_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			using v8::Array;
9			using v8::Boolean;
10			using v8::Context;
11			using v8::EmbedderGraph;
12			using v8::EscapableHandleScope;
13			using v8::FunctionCallbackInfo;
14			using v8::FunctionTemplate;
15			using v8::Global;
16			using v8::HandleScope;
17			using v8::HeapSnapshot;
18			using v8::Isolate;
19			using v8::Local;
20			using v8::MaybeLocal;
21			using v8::Number;
22			using v8::Object;
23			using v8::ObjectTemplate;
24			using v8::String;
25			using v8::Value;
26
27			namespace node {
28			namespace heap {
29
30			class JSGraphJSNode : public EmbedderGraph::Node {
31			public:
32			const char* Name() override { return "<JS Node>"; }
33			size_t SizeInBytes() override { return 0; }
34			bool IsEmbedderNode() override { return false; }
35			Local<Value> JSValue() { return PersistentToLocal::Strong(persistent_); }
36
37			int IdentityHash() {
38			Local<Value> v = JSValue();
39			if (v->IsObject()) return v.As<Object>()->GetIdentityHash();
40			if (v->IsName()) return v.As<v8::Name>()->GetIdentityHash();
41			if (v->IsInt32()) return v.As<v8::Int32>()->Value();
42			return 0;
43			}
44
45			JSGraphJSNode(Isolate* isolate, Local<Value> val)
46			: persistent_(isolate, val) {
47			CHECK(!val.IsEmpty());
48			}
49
50			struct Hash {
51			inline size_t operator()(JSGraphJSNode* n) const {
52			return static_cast<size_t>(n->IdentityHash());
53			}
54			};
55
56			struct Equal {
57			inline bool operator()(JSGraphJSNode* a, JSGraphJSNode* b) const {
58			return a->JSValue()->SameValue(b->JSValue());
59			}
60			};
61
62			private:
63			Global<Value> persistent_;
64			};
65
66			class JSGraph : public EmbedderGraph {
67			public:
68			explicit JSGraph(Isolate* isolate) : isolate_(isolate) {}
69
70			Node* V8Node(const Local<Value>& value) override {
71			std::unique_ptr<JSGraphJSNode> n { new JSGraphJSNode(isolate_, value) };
72			auto it = engine_nodes_.find(n.get());
73			if (it != engine_nodes_.end())
74			return *it;
75			engine_nodes_.insert(n.get());
76			return AddNode(std::unique_ptr<Node>(n.release()));
77			}
78
79			Node* AddNode(std::unique_ptr<Node> node) override {
80			Node* n = node.get();
81			nodes_.emplace(std::move(node));
82			return n;
83			}
84
85			void AddEdge(Node* from, Node* to, const char* name = nullptr) override {
86			edges_[from].insert(std::make_pair(name, to));
87			}
88
89			MaybeLocal<Array> CreateObject() const {
90			EscapableHandleScope handle_scope(isolate_);
91			Local<Context> context = isolate_->GetCurrentContext();
92			Environment* env = Environment::GetCurrent(context);
93
94			std::unordered_map<Node*, Local<Object>> info_objects;
95			Local<Array> nodes = Array::New(isolate_, nodes_.size());
96			Local<String> edges_string = FIXED_ONE_BYTE_STRING(isolate_, "edges");
97			Local<String> is_root_string = FIXED_ONE_BYTE_STRING(isolate_, "isRoot");
98			Local<String> name_string = env->name_string();
99			Local<String> size_string = env->size_string();
100			Local<String> value_string = env->value_string();
101			Local<String> wraps_string = FIXED_ONE_BYTE_STRING(isolate_, "wraps");
102			Local<String> to_string = FIXED_ONE_BYTE_STRING(isolate_, "to");
103
104			for (const std::unique_ptr<Node>& n : nodes_)
105			info_objects[n.get()] = Object::New(isolate_);
106
107			{
108			HandleScope handle_scope(isolate_);
109			size_t i = 0;
110			for (const std::unique_ptr<Node>& n : nodes_) {
111			Local<Object> obj = info_objects[n.get()];
112			Local<Value> value;
113			std::string name_str;
114			const char* prefix = n->NamePrefix();
115			if (prefix == nullptr) {
116			name_str = n->Name();
117			} else {
118			name_str = n->NamePrefix();
119			name_str += " ";
120			name_str += n->Name();
121			}
122			if (!String::NewFromUtf8(isolate_, name_str.c_str()).ToLocal(&value) \|\|
123			obj->Set(context, name_string, value).IsNothing() \|\|
124			obj->Set(context,
125			is_root_string,
126			Boolean::New(isolate_, n->IsRootNode()))
127			.IsNothing() \|\|
128			obj->Set(
129			context,
130			size_string,
131			Number::New(isolate_, static_cast<double>(n->SizeInBytes())))
132			.IsNothing() \|\|
133			obj->Set(context, edges_string, Array::New(isolate_)).IsNothing()) {
134			return MaybeLocal<Array>();
135			}
136			if (nodes->Set(context, i++, obj).IsNothing())
137			return MaybeLocal<Array>();
138			if (!n->IsEmbedderNode()) {
139			value = static_cast<JSGraphJSNode*>(n.get())->JSValue();
140			if (obj->Set(context, value_string, value).IsNothing())
141			return MaybeLocal<Array>();
142			}
143			}
144			}
145
146			for (const std::unique_ptr<Node>& n : nodes_) {
147			Node* wraps = n->WrapperNode();
148			if (wraps == nullptr) continue;
149			Local<Object> from = info_objects[n.get()];
150			Local<Object> to = info_objects[wraps];
151			if (from->Set(context, wraps_string, to).IsNothing())
152			return MaybeLocal<Array>();
153			}
154
155			for (const auto& edge_info : edges_) {
156			Node* source = edge_info.first;
157			Local<Value> edges;
158			if (!info_objects[source]->Get(context, edges_string).ToLocal(&edges) \|\|
159			!edges->IsArray()) {
160			return MaybeLocal<Array>();
161			}
162
163			size_t i = 0;
164			size_t j = 0;
165			for (const auto& edge : edge_info.second) {
166			Local<Object> to_object = info_objects[edge.second];
167			Local<Object> edge_obj = Object::New(isolate_);
168			Local<Value> edge_name_value;
169			const char* edge_name = edge.first;
170			if (edge_name != nullptr) {
171			if (!String::NewFromUtf8(isolate_, edge_name)
172			.ToLocal(&edge_name_value)) {
173			return MaybeLocal<Array>();
174			}
175			} else {
176			edge_name_value = Number::New(isolate_, static_cast<double>(j++));
177			}
178			if (edge_obj->Set(context, name_string, edge_name_value).IsNothing() \|\|
179			edge_obj->Set(context, to_string, to_object).IsNothing() \|\|
180			edges.As<Array>()->Set(context, i++, edge_obj).IsNothing()) {
181			return MaybeLocal<Array>();
182			}
183			}
184			}
185
186			return handle_scope.Escape(nodes);
187			}
188
189			private:
190			Isolate* isolate_;
191			std::unordered_set<std::unique_ptr<Node>> nodes_;
192			std::unordered_set<JSGraphJSNode*, JSGraphJSNode::Hash, JSGraphJSNode::Equal>
193			engine_nodes_;
194			std::unordered_map<Node, std::set<std::pair<const char, Node*>>> edges_;
195			};
196
197			void BuildEmbedderGraph(const FunctionCallbackInfo<Value>& args) {
198			Environment* env = Environment::GetCurrent(args);
199			JSGraph graph(env->isolate());
200			Environment::BuildEmbedderGraph(env->isolate(), &graph, env);
201			Local<Array> ret;
202			if (graph.CreateObject().ToLocal(&ret))
203			args.GetReturnValue().Set(ret);
204			}
205
206			namespace {
207			class FileOutputStream : public v8::OutputStream {
208			public:
209		5	explicit FileOutputStream(FILE* stream) : stream_(stream) {}
210
211		10	int GetChunkSize() override {
212		10	return 65536; // big chunks == faster
213			}
214
215		5	void EndOfStream() override {}
216
217		361	WriteResult WriteAsciiChunk(char* data, int size) override {
218		361	const size_t len = static_cast<size_t>(size);
219		361	size_t off = 0;
220
221	✓✓✓✗ ✓✗✓✓	722	while (off < len && !feof(stream_) && !ferror(stream_))
222		361	off += fwrite(data + off, 1, len - off, stream_);
223
224	✓✗	361	return off == len ? kContinue : kAbort;
225			}
226
227			private:
228			FILE* stream_;
229			};
230
231			class HeapSnapshotStream : public AsyncWrap,
232			public StreamBase,
233			public v8::OutputStream {
234			public:
235		15	HeapSnapshotStream(
236			Environment* env,
237			HeapSnapshotPointer&& snapshot,
238		15	Local<Object> obj) :
239			AsyncWrap(env, obj, AsyncWrap::PROVIDER_HEAPSNAPSHOT),
240			StreamBase(env),
241		15	snapshot_(std::move(snapshot)) {
242		15	MakeWeak();
243		15	StreamBase::AttachToObject(GetObject());
244		15	}
245
246		60	~HeapSnapshotStream() override {}
247
248		24	int GetChunkSize() override {
249		24	return 65536; // big chunks == faster
250			}
251
252		12	void EndOfStream() override {
253		12	EmitRead(UV_EOF);
254		12	snapshot_.reset();
255		12	}
256
257		902	WriteResult WriteAsciiChunk(char* data, int size) override {
258		902	int len = size;
259	✓✓	1804	while (len != 0) {
260		902	uv_buf_t buf = EmitAlloc(size);
261		902	ssize_t avail = len;
262	✗✓	902	if (static_cast<ssize_t>(buf.len) < avail)
263			avail = buf.len;
264		902	memcpy(buf.base, data, avail);
265		902	data += avail;
266		902	len -= static_cast<int>(avail);
267		902	EmitRead(size, buf);
268			}
269		902	return kContinue;
270			}
271
272		12	int ReadStart() override {
273	✗✓	12	CHECK_NE(snapshot_, nullptr);
274		12	snapshot_->Serialize(this, HeapSnapshot::kJSON);
275		12	return 0;
276			}
277
278		902	int ReadStop() override {
279		902	return 0;
280			}
281
282			int DoShutdown(ShutdownWrap* req_wrap) override {
283			UNREACHABLE();
284			}
285
286			int DoWrite(WriteWrap* w,
287			uv_buf_t* bufs,
288			size_t count,
289			uv_stream_t* send_handle) override {
290			UNREACHABLE();
291			}
292
293		914	bool IsAlive() override { return snapshot_ != nullptr; }
294			bool IsClosing() override { return snapshot_ == nullptr; }
295		1843	AsyncWrap* GetAsyncWrap() override { return this; }
296
297		7	void MemoryInfo(MemoryTracker* tracker) const override {
298	✓✗	7	if (snapshot_ != nullptr) {
299		7	tracker->TrackFieldWithSize(
300			"snapshot", sizeof(*snapshot_), "HeapSnapshot");
301			}
302		7	}
303
304		7	SET_MEMORY_INFO_NAME(HeapSnapshotStream)
305		7	SET_SELF_SIZE(HeapSnapshotStream)
306
307			private:
308			HeapSnapshotPointer snapshot_;
309			};
310
311		5	inline void TakeSnapshot(Environment* env, v8::OutputStream* out) {
312			HeapSnapshotPointer snapshot {
313		10	env->isolate()->GetHeapProfiler()->TakeHeapSnapshot() };
314		5	snapshot->Serialize(out, HeapSnapshot::kJSON);
315		5	}
316
317			} // namespace
318
319		6	bool WriteSnapshot(Environment* env, const char* filename) {
320		6	FILE* fp = fopen(filename, "w");
321	✓✓	6	if (fp == nullptr) {
322		1	env->ThrowErrnoException(errno, "open");
323		1	return false;
324			}
325		10	FileOutputStream stream(fp);
326		5	TakeSnapshot(env, &stream);
327	✗✓	5	if (fclose(fp) == EOF) {
328			env->ThrowErrnoException(errno, "close");
329			return false;
330			}
331		5	return true;
332			}
333
334		20	void DeleteHeapSnapshot(const HeapSnapshot* snapshot) {
335		20	const_cast<HeapSnapshot*>(snapshot)->Delete();
336		20	}
337
338		15	BaseObjectPtr<AsyncWrap> CreateHeapSnapshotStream(
339			Environment* env, HeapSnapshotPointer&& snapshot) {
340		30	HandleScope scope(env->isolate());
341
342	✓✓	30	if (env->streambaseoutputstream_constructor_template().IsEmpty()) {
343			// Create FunctionTemplate for HeapSnapshotStream
344		6	Local<FunctionTemplate> os = FunctionTemplate::New(env->isolate());
345		6	os->Inherit(AsyncWrap::GetConstructorTemplate(env));
346		6	Local<ObjectTemplate> ost = os->InstanceTemplate();
347		6	ost->SetInternalFieldCount(StreamBase::kInternalFieldCount);
348		6	os->SetClassName(
349			FIXED_ONE_BYTE_STRING(env->isolate(), "HeapSnapshotStream"));
350		6	StreamBase::AddMethods(env, os);
351		6	env->set_streambaseoutputstream_constructor_template(ost);
352			}
353
354			Local<Object> obj;
355		15	if (!env->streambaseoutputstream_constructor_template()
356		15	->NewInstance(env->context())
357	✗✓	15	.ToLocal(&obj)) {
358			return {};
359			}
360		15	return MakeBaseObject<HeapSnapshotStream>(env, std::move(snapshot), obj);
361			}
362
363		14	void CreateHeapSnapshotStream(const FunctionCallbackInfo<Value>& args) {
364		14	Environment* env = Environment::GetCurrent(args);
365			HeapSnapshotPointer snapshot {
366		28	env->isolate()->GetHeapProfiler()->TakeHeapSnapshot() };
367	✗✓	14	CHECK(snapshot);
368			BaseObjectPtr<AsyncWrap> stream =
369		28	CreateHeapSnapshotStream(env, std::move(snapshot));
370	✓✗	14	if (stream)
371		28	args.GetReturnValue().Set(stream->object());
372		14	}
373
374		5	void TriggerHeapSnapshot(const FunctionCallbackInfo<Value>& args) {
375		5	Environment* env = Environment::GetCurrent(args);
376	✓✗	5	Isolate* isolate = args.GetIsolate();
377
378		5	Local<Value> filename_v = args[0];
379
380	✓✓	10	if (filename_v->IsUndefined()) {
381		6	DiagnosticFilename name(env, "Heap", "heapsnapshot");
382	✗✓	3	if (!WriteSnapshot(env, *name))
383			return;
384	✓✗	6	if (String::NewFromUtf8(isolate, *name).ToLocal(&filename_v)) {
385		6	args.GetReturnValue().Set(filename_v);
386			}
387		3	return;
388			}
389
390		4	BufferValue path(isolate, filename_v);
391	✗✓	2	CHECK_NOT_NULL(*path);
392	✓✓	2	if (!WriteSnapshot(env, *path))
393		1	return;
394		2	return args.GetReturnValue().Set(filename_v);
395			}
396
397		627	void Initialize(Local<Object> target,
398			Local<Value> unused,
399			Local<Context> context,
400			void* priv) {
401		627	Environment* env = Environment::GetCurrent(context);
402
403		627	env->SetMethod(target, "buildEmbedderGraph", BuildEmbedderGraph);
404		627	env->SetMethod(target, "triggerHeapSnapshot", TriggerHeapSnapshot);
405		627	env->SetMethod(target, "createHeapSnapshotStream", CreateHeapSnapshotStream);
406		627	}
407
408		4941	void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
409		4941	registry->Register(BuildEmbedderGraph);
410		4941	registry->Register(TriggerHeapSnapshot);
411		4941	registry->Register(CreateHeapSnapshotStream);
412		4941	}
413
414			} // namespace heap
415			} // namespace node
416
417		5002	NODE_MODULE_CONTEXT_AWARE_INTERNAL(heap_utils, node::heap::Initialize)
418		4941	NODE_MODULE_EXTERNAL_REFERENCE(heap_utils,
419			node::heap::RegisterExternalReferences)