Skip to content

Commit c54c984

Browse files
committed
v8: support gc profile
1 parent 5d50b84 commit c54c984

File tree

8 files changed

+480
-2
lines changed

8 files changed

+480
-2
lines changed

doc/api/v8.md

Lines changed: 77 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -390,6 +390,83 @@ The API is a no-op if `--heapsnapshot-near-heap-limit` is already set from the
390390
command line or the API is called more than once. `limit` must be a positive
391391
integer. See [`--heapsnapshot-near-heap-limit`][] for more information.
392392

393+
## `v8.takeGCProfile(options)`
394+
395+
<!-- YAML
396+
added: REPLACEME
397+
-->
398+
399+
* `options` {Object}
400+
* `filename` {string} Node.js will write data to `filename`.
401+
* `duration` {number} how long you want to collect the gc data.
402+
403+
* Returns: {Promise}
404+
405+
This API collects gc data over a period of time and write it to the `filename`.
406+
The content is as follows.
407+
408+
```json
409+
{
410+
"version": 1,
411+
"startTime": 1674059033862,
412+
"statistics": [
413+
{
414+
"gcType": "Scavenge",
415+
"beforeGC": {
416+
"heapStatistics": {
417+
"totalHeapSize": 5005312,
418+
"totalHeapSizeExecutable": 524288,
419+
"totalPhysicalSize": 5226496,
420+
"totalAvailableSize": 4341325216,
421+
"totalGlobalHandlesSize": 8192,
422+
"usedGlobalHandlesSize": 2112,
423+
"usedHeapSize": 4883840,
424+
"heapSizeLimit": 4345298944,
425+
"mallocedMemory": 254128,
426+
"externalMemory": 225138,
427+
"peakMallocedMemory": 181760
428+
},
429+
"heapSpaceStatistics": [
430+
{
431+
"spaceName": "read_only_space",
432+
"spaceSize": 0,
433+
"spaceUsedSize": 0,
434+
"spaceAvailableSize": 0,
435+
"physicalSpaceSize": 0
436+
}
437+
]
438+
},
439+
"cost": 1574.14,
440+
"afterGC": {
441+
"heapStatistics": {
442+
"totalHeapSize": 6053888,
443+
"totalHeapSizeExecutable": 524288,
444+
"totalPhysicalSize": 5500928,
445+
"totalAvailableSize": 4341101384,
446+
"totalGlobalHandlesSize": 8192,
447+
"usedGlobalHandlesSize": 2112,
448+
"usedHeapSize": 4059096,
449+
"heapSizeLimit": 4345298944,
450+
"mallocedMemory": 254128,
451+
"externalMemory": 225138,
452+
"peakMallocedMemory": 181760
453+
},
454+
"heapSpaceStatistics": [
455+
{
456+
"spaceName": "read_only_space",
457+
"spaceSize": 0,
458+
"spaceUsedSize": 0,
459+
"spaceAvailableSize": 0,
460+
"physicalSpaceSize": 0
461+
}
462+
]
463+
}
464+
}
465+
],
466+
"endtTime": 1674059036865
467+
}
468+
```
469+
393470
## Serialization API
394471

395472
The serialization API provides means of serializing JavaScript values in a way

lib/v8.js

Lines changed: 29 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ const {
3333
} = primordials;
3434

3535
const { Buffer } = require('buffer');
36-
const { validateString, validateUint32 } = require('internal/validators');
36+
const { validateString, validateUint32, validateObject, validateNumber } = require('internal/validators');
3737
const {
3838
Serializer,
3939
Deserializer
@@ -63,7 +63,8 @@ const {
6363
} = require('internal/heap_utils');
6464
const promiseHooks = require('internal/promise_hooks');
6565
const { getOptionValue } = require('internal/options');
66-
66+
const { setUnrefTimeout } = require('internal/timers');
67+
const { Promise } = primordials;
6768
/**
6869
* Generates a snapshot of the current V8 heap
6970
* and writes it to a JSON file.
@@ -397,6 +398,31 @@ function deserialize(buffer) {
397398
return der.readValue();
398399
}
399400

401+
/**
402+
* @param {{
403+
* filename: string,
404+
* duration: number,
405+
* }} [options]
406+
*/
407+
function takeGCProfile(options) {
408+
validateObject(options, 'options');
409+
validateString(options.filename, 'options.filename');
410+
validateNumber(options.duration, 'options.duration', 1);
411+
return new Promise((resolve, reject) => {
412+
const profiler = new binding.GCProfiler();
413+
try {
414+
profiler.startGCProfile(options.filename);
415+
} catch (e) {
416+
reject(e);
417+
return;
418+
}
419+
setUnrefTimeout(() => {
420+
profiler.stopGCProfile();
421+
resolve();
422+
}, options.duration);
423+
});
424+
}
425+
400426
module.exports = {
401427
cachedDataVersionTag,
402428
getHeapSnapshot,
@@ -416,4 +442,5 @@ module.exports = {
416442
promiseHooks,
417443
startupSnapshot,
418444
setHeapSnapshotNearHeapLimit,
445+
takeGCProfile,
419446
};

src/node_v8.cc

Lines changed: 188 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,7 @@ namespace v8_utils {
3333
using v8::Array;
3434
using v8::Context;
3535
using v8::FunctionCallbackInfo;
36+
using v8::FunctionTemplate;
3637
using v8::HandleScope;
3738
using v8::HeapCodeStatistics;
3839
using v8::HeapSpaceStatistics;
@@ -210,6 +211,180 @@ void SetFlagsFromString(const FunctionCallbackInfo<Value>& args) {
210211
V8::SetFlagsFromString(*flags, static_cast<size_t>(flags.length()));
211212
}
212213

214+
static const char * GetGCTypeName(v8::GCType gc_type) {
215+
switch (gc_type) {
216+
case v8::GCType::kGCTypeScavenge:
217+
return "Scavenge";
218+
case v8::GCType::kGCTypeMarkSweepCompact:
219+
return "MarkSweepCompact";
220+
case v8::GCType::kGCTypeIncrementalMarking:
221+
return "IncrementalMarking";
222+
case v8::GCType::kGCTypeProcessWeakCallbacks:
223+
return "ProcessWeakCallbacks";
224+
default:
225+
return "UnKnow";
226+
}
227+
}
228+
229+
static void SetHeapStatistics(JSONWriter* writer, Isolate * isolate) {
230+
HeapStatistics heap_statistics;
231+
isolate->GetHeapStatistics(&heap_statistics);
232+
writer->json_objectstart("heapStatistics");
233+
writer->json_keyvalue("totalHeapSize", heap_statistics.total_heap_size());
234+
writer->json_keyvalue("totalHeapSizeExecutable",
235+
heap_statistics.total_heap_size_executable());
236+
writer->json_keyvalue("totalPhysicalSize",
237+
heap_statistics.total_physical_size());
238+
writer->json_keyvalue("totalAvailableSize",
239+
heap_statistics.total_available_size());
240+
writer->json_keyvalue("totalGlobalHandlesSize",
241+
heap_statistics.total_global_handles_size());
242+
writer->json_keyvalue("usedGlobalHandlesSize",
243+
heap_statistics.used_global_handles_size());
244+
writer->json_keyvalue("usedHeapSize",
245+
heap_statistics.used_heap_size());
246+
writer->json_keyvalue("heapSizeLimit",
247+
heap_statistics.heap_size_limit());
248+
writer->json_keyvalue("mallocedMemory",
249+
heap_statistics.malloced_memory());
250+
writer->json_keyvalue("externalMemory",
251+
heap_statistics.external_memory());
252+
writer->json_keyvalue("peakMallocedMemory",
253+
heap_statistics.peak_malloced_memory());
254+
writer->json_objectend();
255+
256+
int space_count = isolate->NumberOfHeapSpaces();
257+
writer->json_arraystart("heapSpaceStatistics");
258+
for (int i = 0; i < space_count; i++) {
259+
HeapSpaceStatistics heap_space_statistics;
260+
isolate->GetHeapSpaceStatistics(&heap_space_statistics, i);
261+
writer->json_start();
262+
writer->json_keyvalue("spaceName",
263+
heap_space_statistics.space_name());
264+
writer->json_keyvalue("spaceSize",
265+
heap_space_statistics.space_size());
266+
writer->json_keyvalue("spaceUsedSize",
267+
heap_space_statistics.space_used_size());
268+
writer->json_keyvalue("spaceAvailableSize",
269+
heap_space_statistics.space_available_size());
270+
writer->json_keyvalue("physicalSpaceSize",
271+
heap_space_statistics.physical_space_size());
272+
writer->json_end();
273+
}
274+
writer->json_arrayend();
275+
}
276+
277+
static void BeforeGCCallback(Isolate* isolate,
278+
v8::GCType gc_type,
279+
v8::GCCallbackFlags flags,
280+
void* data) {
281+
GCProfiler* profiler = static_cast<GCProfiler *>(data);
282+
if (profiler->current_gc_type() != 0) {
283+
return;
284+
}
285+
profiler->set_current_gc_type(gc_type);
286+
profiler->set_start_time(uv_hrtime());
287+
JSONWriter* writer = profiler->writer();
288+
writer->json_start();
289+
writer->json_keyvalue("gcType", GetGCTypeName(gc_type));
290+
writer->json_objectstart("beforeGC");
291+
SetHeapStatistics(writer, isolate);
292+
writer->json_objectend();
293+
}
294+
295+
static void AfterGCCallback(Isolate* isolate,
296+
v8::GCType gc_type,
297+
v8::GCCallbackFlags flags,
298+
void* data) {
299+
GCProfiler* profiler = static_cast<GCProfiler *>(data);
300+
if (profiler->current_gc_type() != gc_type) {
301+
return;
302+
}
303+
JSONWriter* writer = profiler->writer();
304+
profiler->set_current_gc_type(0);
305+
u_int64_t start_time = profiler->start_time();
306+
profiler->set_start_time(0);
307+
writer->json_keyvalue("cost", (uv_hrtime() - start_time) / 1e3);
308+
writer->json_objectstart("afterGC");
309+
SetHeapStatistics(writer, isolate);
310+
writer->json_objectend();
311+
writer->json_end();
312+
}
313+
314+
GCProfiler::GCProfiler(Environment* env, Local<Object> object):
315+
BaseObject(env, object), writer_(outfile_, false) {
316+
MakeWeak();
317+
}
318+
319+
// This function will be called when
320+
// 1. StartGCProfile and StopGCProfile are called and
321+
// JS land do not keep the object any more.
322+
// 2. StartGCProfile is called then the env exits before
323+
// StopGCProfile is called.
324+
GCProfiler::~GCProfiler() {
325+
if (state_ != GCProfilerState::kInitialized) {
326+
env()->isolate()->RemoveGCPrologueCallback(BeforeGCCallback, this);
327+
env()->isolate()->RemoveGCEpilogueCallback(AfterGCCallback, this);
328+
}
329+
}
330+
331+
void GCProfiler::New(const FunctionCallbackInfo<Value>& args) {
332+
CHECK(args.IsConstructCall());
333+
Environment* env = Environment::GetCurrent(args);
334+
new GCProfiler(env, args.This());
335+
}
336+
337+
void GCProfiler::StartGCProfile(const FunctionCallbackInfo<Value>& args) {
338+
GCProfiler* profiler;
339+
ASSIGN_OR_RETURN_UNWRAP(&profiler, args.Holder());
340+
if (profiler->state() != GCProfilerState::kInitialized) {
341+
return;
342+
}
343+
Environment* env = Environment::GetCurrent(args);
344+
Isolate* isolate = args.GetIsolate();
345+
node::Utf8Value filename(env->isolate(), args[0]);
346+
profiler->outfile()->open(*filename, std::ios::out | std::ios::binary);
347+
if (!profiler->outfile()->is_open()) {
348+
env->ThrowError("failed to open file");
349+
return;
350+
}
351+
profiler->writer()->json_start();
352+
profiler->writer()->json_keyvalue("version", 1);
353+
354+
uv_timeval64_t ts;
355+
if (uv_gettimeofday(&ts) == 0) {
356+
profiler->writer()->json_keyvalue("startTime",
357+
ts.tv_sec * 1000 + ts.tv_usec / 1000);
358+
} else {
359+
profiler->writer()->json_keyvalue("startTime", 0);
360+
}
361+
profiler->writer()->json_arraystart("statistics");
362+
isolate->AddGCPrologueCallback(BeforeGCCallback,
363+
static_cast<void *>(profiler));
364+
isolate->AddGCEpilogueCallback(AfterGCCallback,
365+
static_cast<void *>(profiler));
366+
profiler->set_state(GCProfilerState::kStarted);
367+
}
368+
369+
void GCProfiler::StopGCProfile(const FunctionCallbackInfo<v8::Value>& args) {
370+
GCProfiler* profiler;
371+
ASSIGN_OR_RETURN_UNWRAP(&profiler, args.Holder());
372+
if (profiler->state() != GCProfilerState::kStarted) {
373+
return;
374+
}
375+
profiler->writer()->json_arrayend();
376+
uv_timeval64_t ts;
377+
if (uv_gettimeofday(&ts) == 0) {
378+
profiler->writer()->json_keyvalue("endtTime",
379+
ts.tv_sec * 1000 + ts.tv_usec / 1000);
380+
} else {
381+
profiler->writer()->json_keyvalue("endtTime", 0);
382+
}
383+
profiler->writer()->json_end();
384+
profiler->outfile()->close();
385+
profiler->set_state(GCProfilerState::kStopped);
386+
}
387+
213388
void Initialize(Local<Object> target,
214389
Local<Value> unused,
215390
Local<Context> context,
@@ -272,6 +447,17 @@ void Initialize(Local<Object> target,
272447

273448
// Export symbols used by v8.setFlagsFromString()
274449
SetMethod(context, target, "setFlagsFromString", SetFlagsFromString);
450+
451+
// GCProfiler
452+
Local<FunctionTemplate> t = NewFunctionTemplate(env->isolate(),
453+
GCProfiler::New);
454+
t->InstanceTemplate()->SetInternalFieldCount(
455+
BaseObject::kInternalFieldCount);
456+
SetProtoMethod(env->isolate(), t, "startGCProfile",
457+
GCProfiler::StartGCProfile);
458+
SetProtoMethod(env->isolate(), t, "stopGCProfile",
459+
GCProfiler::StopGCProfile);
460+
SetConstructorFunction(context, target, "GCProfiler", t);
275461
}
276462

277463
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
@@ -281,6 +467,8 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
281467
registry->Register(UpdateHeapSpaceStatisticsBuffer);
282468
registry->Register(SetFlagsFromString);
283469
registry->Register(SetHeapSnapshotNearHeapLimit);
470+
registry->Register(GCProfiler::StartGCProfile);
471+
registry->Register(GCProfiler::StopGCProfile);
284472
}
285473

286474
} // namespace v8_utils

0 commit comments

Comments
 (0)