perf_hooks: add property flags to GCPerformanceEntry

PR-URL: #29547
Reviewed-By: James M Snell <[email protected]>
Reviewed-By: Chengzhong Wu <[email protected]>

Author: fanatid

doc/api/perf_hooks.md

@@ -209,6 +209,25 @@ The value may be one of:
 * `perf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTAL`
 * `perf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCB`
 
+### performanceEntry.flags
+<!-- YAML
+added: REPLACEME
+-->
+
+* {number}
+
+When `performanceEntry.entryType` is equal to `'gc'`, the `performance.flags`
+property contains additional information about garbage collection operation.
+The value may be one of:
+
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY`
+* `perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE`
+
 ## Class: `PerformanceNodeTiming extends PerformanceEntry`
 <!-- YAML
 added: v8.5.0

src/node_perf.cc

@@ -249,6 +249,10 @@ void PerformanceGCCallback(Environment* env,
                            env->kind_string(),
                            Integer::New(env->isolate(), entry->gckind()),
                            attr).Check();
+    obj->DefineOwnProperty(context,
+                           env->flags_string(),
+                           Integer::New(env->isolate(), entry->gcflags()),
+                           attr).Check();
     PerformanceEntry::Notify(env, entry->kind(), obj);
   }
 }
@@ -275,6 +279,7 @@ void MarkGarbageCollectionEnd(Isolate* isolate,
   auto entry = std::make_unique<GCPerformanceEntry>(
       env,
       static_cast<PerformanceGCKind>(type),
+      static_cast<PerformanceGCFlags>(flags),
       state->performance_last_gc_start_mark,
       PERFORMANCE_NOW());
   env->SetUnrefImmediate([entry = std::move(entry)](Environment* env) mutable {
@@ -592,6 +597,21 @@ void Initialize(Local<Object> target,
   NODE_DEFINE_CONSTANT(constants, NODE_PERFORMANCE_GC_INCREMENTAL);
   NODE_DEFINE_CONSTANT(constants, NODE_PERFORMANCE_GC_WEAKCB);
 
+  NODE_DEFINE_CONSTANT(
+    constants, NODE_PERFORMANCE_GC_FLAGS_NO);
+  NODE_DEFINE_CONSTANT(
+    constants, NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED);
+  NODE_DEFINE_CONSTANT(
+    constants, NODE_PERFORMANCE_GC_FLAGS_FORCED);
+  NODE_DEFINE_CONSTANT(
+    constants, NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING);
+  NODE_DEFINE_CONSTANT(
+    constants, NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE);
+  NODE_DEFINE_CONSTANT(
+    constants, NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY);
+  NODE_DEFINE_CONSTANT(
+    constants, NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE);
+
 #define V(name, _)                                                            \
   NODE_DEFINE_HIDDEN_CONSTANT(constants, NODE_PERFORMANCE_ENTRY_TYPE_##name);
   NODE_PERFORMANCE_ENTRY_TYPES(V)

src/node_perf.h

@@ -21,6 +21,7 @@ namespace performance {
 
 using v8::FunctionCallbackInfo;
 using v8::GCType;
+using v8::GCCallbackFlags;
 using v8::Local;
 using v8::Object;
 using v8::Value;
@@ -110,19 +111,40 @@ enum PerformanceGCKind {
   NODE_PERFORMANCE_GC_WEAKCB = GCType::kGCTypeProcessWeakCallbacks
 };
 
+enum PerformanceGCFlags {
+  NODE_PERFORMANCE_GC_FLAGS_NO =
+    GCCallbackFlags::kNoGCCallbackFlags,
+  NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED =
+    GCCallbackFlags::kGCCallbackFlagConstructRetainedObjectInfos,
+  NODE_PERFORMANCE_GC_FLAGS_FORCED =
+    GCCallbackFlags::kGCCallbackFlagForced,
+  NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING =
+    GCCallbackFlags::kGCCallbackFlagSynchronousPhantomCallbackProcessing,
+  NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE =
+    GCCallbackFlags::kGCCallbackFlagCollectAllAvailableGarbage,
+  NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY =
+    GCCallbackFlags::kGCCallbackFlagCollectAllExternalMemory,
+  NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE =
+    GCCallbackFlags::kGCCallbackScheduleIdleGarbageCollection
+};
+
 class GCPerformanceEntry : public PerformanceEntry {
  public:
   GCPerformanceEntry(Environment* env,
                      PerformanceGCKind gckind,
+                     PerformanceGCFlags gcflags,
                      uint64_t startTime,
                      uint64_t endTime) :
                          PerformanceEntry(env, "gc", "gc", startTime, endTime),
-                         gckind_(gckind) { }
+                         gckind_(gckind),
+                         gcflags_(gcflags) { }
 
   PerformanceGCKind gckind() const { return gckind_; }
+  PerformanceGCFlags gcflags() const { return gcflags_; }
 
  private:
   PerformanceGCKind gckind_;
+  PerformanceGCFlags gcflags_;
 };
 
 class ELDHistogram : public HandleWrap, public Histogram {

test/parallel/test-performance-gc.js

@@ -12,7 +12,8 @@ const {
   NODE_PERFORMANCE_GC_MAJOR,
   NODE_PERFORMANCE_GC_MINOR,
   NODE_PERFORMANCE_GC_INCREMENTAL,
-  NODE_PERFORMANCE_GC_WEAKCB
+  NODE_PERFORMANCE_GC_WEAKCB,
+  NODE_PERFORMANCE_GC_FLAGS_FORCED
 } = constants;
 
 const kinds = [
@@ -30,6 +31,7 @@ const kinds = [
     assert.strictEqual(entry.name, 'gc');
     assert.strictEqual(entry.entryType, 'gc');
     assert(kinds.includes(entry.kind));
+    assert.strictEqual(entry.flags, NODE_PERFORMANCE_GC_FLAGS_FORCED);
     assert.strictEqual(typeof entry.startTime, 'number');
     assert.strictEqual(typeof entry.duration, 'number');
     obs.disconnect();