src/node_perf.cc - external/github.com/v8/node - Git at Google

 #include "node_perf.h"
 #include "aliased_buffer-inl.h"
 #include "env-inl.h"
 #include "histogram-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_buffer.h"
 #include "node_external_reference.h"
 #include "node_internals.h"
 #include "node_process-inl.h"
 #include "util-inl.h"

 #include <cinttypes>

 namespace node {
 namespace performance {

 using v8::Context;
 using v8::DontDelete;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::GCCallbackFlags;
 using v8::GCType;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::PropertyAttribute;
 using v8::ReadOnly;
 using v8::Value;

 // Microseconds in a millisecond, as a float.
 #define MICROS_PER_MILLIS 1e3
 // Nanoseconds in a millisecond, as a float.
 #define NANOS_PER_MILLIS 1e6

 const uint64_t performance_process_start = PERFORMANCE_NOW();
 const double performance_process_start_timestamp =
     GetCurrentTimeInMicroseconds();
 uint64_t performance_v8_start;

 PerformanceState::PerformanceState(Isolate* isolate,
                                    uint64_t time_origin,
                                    double time_origin_timestamp,
                                    const PerformanceState::SerializeInfo* info)
     : root(isolate,
            sizeof(performance_state_internal),
            MAYBE_FIELD_PTR(info, root)),
       milestones(isolate,
                  offsetof(performance_state_internal, milestones),
                  NODE_PERFORMANCE_MILESTONE_INVALID,
                  root,
                  MAYBE_FIELD_PTR(info, milestones)),
       observers(isolate,
                 offsetof(performance_state_internal, observers),
                 NODE_PERFORMANCE_ENTRY_TYPE_INVALID,
                 root,
                 MAYBE_FIELD_PTR(info, observers)) {
   if (info == nullptr) {
     // For performance states initialized from scratch, reset
     // all the milestones and initialize the time origin.
     // For deserialized performance states, we will do the
     // initialization in the deserialize callback.
     ResetMilestones();
     Initialize(time_origin, time_origin_timestamp);
   }
 }

 void PerformanceState::ResetMilestones() {
   size_t milestones_length = milestones.Length();
   for (size_t i = 0; i < milestones_length; ++i) {
     milestones[i] = -1;
   }
 }

 PerformanceState::SerializeInfo PerformanceState::Serialize(
     v8::Local<v8::Context> context, v8::SnapshotCreator* creator) {
   // Reset all the milestones to improve determinism in the snapshot.
   // We'll re-initialize them after deserialization.
   ResetMilestones();

   SerializeInfo info{root.Serialize(context, creator),
                      milestones.Serialize(context, creator),
                      observers.Serialize(context, creator)};
   return info;
 }

 void PerformanceState::Initialize(uint64_t time_origin,
                                   double time_origin_timestamp) {
   // We are only reusing the milestone array to store the time origin
   // and time origin timestamp, so do not use the Mark() method.
   // The time origin milestone is not exposed to user land.
   this->milestones[NODE_PERFORMANCE_MILESTONE_TIME_ORIGIN] =
       static_cast<double>(time_origin);
   this->milestones[NODE_PERFORMANCE_MILESTONE_TIME_ORIGIN_TIMESTAMP] =
       time_origin_timestamp;
 }

 void PerformanceState::Deserialize(v8::Local<v8::Context> context,
                                    uint64_t time_origin,
                                    double time_origin_timestamp) {
   // Resets the pointers.
   root.Deserialize(context);
   milestones.Deserialize(context);
   observers.Deserialize(context);

   // Re-initialize the time origin and timestamp i.e. the process start time.
   Initialize(time_origin, time_origin_timestamp);
 }

 std::ostream& operator<<(std::ostream& o,
                          const PerformanceState::SerializeInfo& i) {
   o << "{\n"
     << "  " << i.root << ",  // root\n"
     << "  " << i.milestones << ",  // milestones\n"
     << "  " << i.observers << ",  // observers\n"
     << "}";
   return o;
 }

 void PerformanceState::Mark(PerformanceMilestone milestone, uint64_t ts) {
   this->milestones[milestone] = static_cast<double>(ts);
   TRACE_EVENT_INSTANT_WITH_TIMESTAMP0(
       TRACING_CATEGORY_NODE1(bootstrap),
       GetPerformanceMilestoneName(milestone),
       TRACE_EVENT_SCOPE_THREAD, ts / 1000);
 }

 void SetupPerformanceObservers(const FunctionCallbackInfo<Value>& args) {
   Realm* realm = Realm::GetCurrent(args);
   // TODO(legendecas): Remove this check once the sub-realms are supported.
   CHECK_EQ(realm->kind(), Realm::Kind::kPrincipal);
   CHECK(args[0]->IsFunction());
   realm->set_performance_entry_callback(args[0].As<Function>());
 }

 // Marks the start of a GC cycle
 void MarkGarbageCollectionStart(
     Isolate* isolate,
     GCType type,
     GCCallbackFlags flags,
     void* data) {
   Environment* env = static_cast<Environment*>(data);
   // Prevent gc callback from reentering with different type
   // See https://github.com/nodejs/node/issues/44046
   if (env->performance_state()->current_gc_type != 0) {
     return;
   }
   env->performance_state()->performance_last_gc_start_mark = PERFORMANCE_NOW();
   env->performance_state()->current_gc_type = type;
 }

 MaybeLocal<Object> GCPerformanceEntryTraits::GetDetails(
     Environment* env,
     const GCPerformanceEntry& entry) {
   Local<Object> obj = Object::New(env->isolate());

   if (!obj->Set(
           env->context(),
           env->kind_string(),
           Integer::NewFromUnsigned(
               env->isolate(),
               entry.details.kind)).IsJust()) {
     return MaybeLocal<Object>();
   }

   if (!obj->Set(
           env->context(),
           env->flags_string(),
           Integer::NewFromUnsigned(
               env->isolate(),
               entry.details.flags)).IsJust()) {
     return MaybeLocal<Object>();
   }

   return obj;
 }

 // Marks the end of a GC cycle
 void MarkGarbageCollectionEnd(
     Isolate* isolate,
     GCType type,
     GCCallbackFlags flags,
     void* data) {
   Environment* env = static_cast<Environment*>(data);
   PerformanceState* state = env->performance_state();
   if (type != state->current_gc_type) {
     return;
   }
   env->performance_state()->current_gc_type = 0;
   // If no one is listening to gc performance entries, do not create them.
   if (LIKELY(!state->observers[NODE_PERFORMANCE_ENTRY_TYPE_GC]))
     return;

   double start_time =
       (state->performance_last_gc_start_mark - env->time_origin()) /
       NANOS_PER_MILLIS;
   double duration = (PERFORMANCE_NOW() / NANOS_PER_MILLIS) -
                     (state->performance_last_gc_start_mark / NANOS_PER_MILLIS);

   std::unique_ptr<GCPerformanceEntry> entry =
       std::make_unique<GCPerformanceEntry>(
           "gc",
           start_time,
           duration,
           GCPerformanceEntry::Details(static_cast<PerformanceGCKind>(type),
                                       static_cast<PerformanceGCFlags>(flags)));

   env->SetImmediate([entry = std::move(entry)](Environment* env) {
     entry->Notify(env);
   }, CallbackFlags::kUnrefed);
 }

 void GarbageCollectionCleanupHook(void* data) {
   Environment* env = static_cast<Environment*>(data);
   // Reset current_gc_type to 0
   env->performance_state()->current_gc_type = 0;
   env->isolate()->RemoveGCPrologueCallback(MarkGarbageCollectionStart, data);
   env->isolate()->RemoveGCEpilogueCallback(MarkGarbageCollectionEnd, data);
 }

 static void InstallGarbageCollectionTracking(
     const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   // Reset current_gc_type to 0
   env->performance_state()->current_gc_type = 0;
   env->isolate()->AddGCPrologueCallback(MarkGarbageCollectionStart,
                                         static_cast<void*>(env));
   env->isolate()->AddGCEpilogueCallback(MarkGarbageCollectionEnd,
                                         static_cast<void*>(env));
   env->AddCleanupHook(GarbageCollectionCleanupHook, env);
 }

 static void RemoveGarbageCollectionTracking(
   const FunctionCallbackInfo<Value> &args) {
   Environment* env = Environment::GetCurrent(args);

   env->RemoveCleanupHook(GarbageCollectionCleanupHook, env);
   GarbageCollectionCleanupHook(env);
 }

 // Notify a custom PerformanceEntry to observers
 void Notify(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Utf8Value type(env->isolate(), args[0]);
   Local<Value> entry = args[1];
   PerformanceEntryType entry_type = ToPerformanceEntryTypeEnum(*type);
   AliasedUint32Array& observers = env->performance_state()->observers;
   if (entry_type != NODE_PERFORMANCE_ENTRY_TYPE_INVALID &&
       observers[entry_type]) {
     USE(env->performance_entry_callback()->
       Call(env->context(), Undefined(env->isolate()), 1, &entry));
   }
 }

 // Return idle time of the event loop
 void LoopIdleTime(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   uint64_t idle_time = uv_metrics_idle_time(env->event_loop());
   args.GetReturnValue().Set(1.0 * idle_time / NANOS_PER_MILLIS);
 }

 void CreateELDHistogram(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   int64_t interval = args[0].As<Integer>()->Value();
   CHECK_GT(interval, 0);
   BaseObjectPtr<IntervalHistogram> histogram =
       IntervalHistogram::Create(env, interval, [](Histogram& histogram) {
         uint64_t delta = histogram.RecordDelta();
         TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
                         "delay", delta);
         TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
                       "min", histogram.Min());
         TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
                       "max", histogram.Max());
         TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
                       "mean", histogram.Mean());
         TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
                       "stddev", histogram.Stddev());
       }, Histogram::Options { 1000 });
   args.GetReturnValue().Set(histogram->object());
 }

 void MarkBootstrapComplete(const FunctionCallbackInfo<Value>& args) {
   Realm* realm = Realm::GetCurrent(args);
   CHECK_EQ(realm->kind(), Realm::Kind::kPrincipal);
   realm->env()->performance_state()->Mark(
       performance::NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE);
 }

 static double PerformanceNowImpl() {
   return static_cast<double>(uv_hrtime() - performance_process_start) /
          NANOS_PER_MILLIS;
 }

 static double FastPerformanceNow(v8::Local<v8::Value> receiver) {
   return PerformanceNowImpl();
 }

 static void SlowPerformanceNow(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(PerformanceNowImpl());
 }

 static v8::CFunction fast_performance_now(
     v8::CFunction::Make(FastPerformanceNow));

 static void CreatePerIsolateProperties(IsolateData* isolate_data,
                                        Local<ObjectTemplate> target) {
   Isolate* isolate = isolate_data->isolate();

   HistogramBase::Initialize(isolate_data, target);

   SetMethod(isolate, target, "setupObservers", SetupPerformanceObservers);
   SetMethod(isolate,
             target,
             "installGarbageCollectionTracking",
             InstallGarbageCollectionTracking);
   SetMethod(isolate,
             target,
             "removeGarbageCollectionTracking",
             RemoveGarbageCollectionTracking);
   SetMethod(isolate, target, "notify", Notify);
   SetMethod(isolate, target, "loopIdleTime", LoopIdleTime);
   SetMethod(isolate, target, "createELDHistogram", CreateELDHistogram);
   SetMethod(isolate, target, "markBootstrapComplete", MarkBootstrapComplete);
   SetFastMethodNoSideEffect(
       isolate, target, "now", SlowPerformanceNow, &fast_performance_now);
 }

 void CreatePerContextProperties(Local<Object> target,
                                 Local<Value> unused,
                                 Local<Context> context,
                                 void* priv) {
   Environment* env = Environment::GetCurrent(context);
   Isolate* isolate = env->isolate();
   PerformanceState* state = env->performance_state();

   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "observerCounts"),
               state->observers.GetJSArray()).Check();
   target->Set(context,
               FIXED_ONE_BYTE_STRING(isolate, "milestones"),
               state->milestones.GetJSArray()).Check();

   Local<Object> constants = Object::New(isolate);

   NODE_DEFINE_CONSTANT(constants, NODE_PERFORMANCE_GC_MAJOR);
   NODE_DEFINE_CONSTANT(constants, NODE_PERFORMANCE_GC_MINOR);
   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)
 #undef V

 #define V(name, _)                                                            \
   NODE_DEFINE_HIDDEN_CONSTANT(constants, NODE_PERFORMANCE_MILESTONE_##name);
   NODE_PERFORMANCE_MILESTONES(V)
 #undef V

   PropertyAttribute attr =
       static_cast<PropertyAttribute>(ReadOnly | DontDelete);

   target->DefineOwnProperty(context, env->constants_string(), constants, attr)
       .ToChecked();
 }

 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(SetupPerformanceObservers);
   registry->Register(InstallGarbageCollectionTracking);
   registry->Register(RemoveGarbageCollectionTracking);
   registry->Register(Notify);
   registry->Register(LoopIdleTime);
   registry->Register(CreateELDHistogram);
   registry->Register(MarkBootstrapComplete);
   registry->Register(SlowPerformanceNow);
   registry->Register(FastPerformanceNow);
   registry->Register(fast_performance_now.GetTypeInfo());
   HistogramBase::RegisterExternalReferences(registry);
   IntervalHistogram::RegisterExternalReferences(registry);
 }
 }  // namespace performance
 }  // namespace node

 NODE_BINDING_CONTEXT_AWARE_INTERNAL(
     performance, node::performance::CreatePerContextProperties)
 NODE_BINDING_PER_ISOLATE_INIT(performance,
                               node::performance::CreatePerIsolateProperties)
 NODE_BINDING_EXTERNAL_REFERENCE(performance,
                                 node::performance::RegisterExternalReferences)
	#include "node_perf.h"
	#include "aliased_buffer-inl.h"
	#include "env-inl.h"
	#include "histogram-inl.h"
	#include "memory_tracker-inl.h"
	#include "node_buffer.h"
	#include "node_external_reference.h"
	#include "node_internals.h"
	#include "node_process-inl.h"
	#include "util-inl.h"

	#include <cinttypes>

	namespace node {
	namespace performance {

	using v8::Context;
	using v8::DontDelete;
	using v8::Function;
	using v8::FunctionCallbackInfo;
	using v8::GCCallbackFlags;
	using v8::GCType;
	using v8::Integer;
	using v8::Isolate;
	using v8::Local;
	using v8::MaybeLocal;
	using v8::Object;
	using v8::ObjectTemplate;
	using v8::PropertyAttribute;
	using v8::ReadOnly;
	using v8::Value;

	// Microseconds in a millisecond, as a float.
	#define MICROS_PER_MILLIS 1e3
	// Nanoseconds in a millisecond, as a float.
	#define NANOS_PER_MILLIS 1e6

	const uint64_t performance_process_start = PERFORMANCE_NOW();
	const double performance_process_start_timestamp =
	GetCurrentTimeInMicroseconds();
	uint64_t performance_v8_start;

	PerformanceState::PerformanceState(Isolate* isolate,
	uint64_t time_origin,
	double time_origin_timestamp,
	const PerformanceState::SerializeInfo* info)
	: root(isolate,
	sizeof(performance_state_internal),
	MAYBE_FIELD_PTR(info, root)),
	milestones(isolate,
	offsetof(performance_state_internal, milestones),
	NODE_PERFORMANCE_MILESTONE_INVALID,
	root,
	MAYBE_FIELD_PTR(info, milestones)),
	observers(isolate,
	offsetof(performance_state_internal, observers),
	NODE_PERFORMANCE_ENTRY_TYPE_INVALID,
	root,
	MAYBE_FIELD_PTR(info, observers)) {
	if (info == nullptr) {
	// For performance states initialized from scratch, reset
	// all the milestones and initialize the time origin.
	// For deserialized performance states, we will do the
	// initialization in the deserialize callback.
	ResetMilestones();
	Initialize(time_origin, time_origin_timestamp);
	}
	}

	void PerformanceState::ResetMilestones() {
	size_t milestones_length = milestones.Length();
	for (size_t i = 0; i < milestones_length; ++i) {
	milestones[i] = -1;
	}
	}

	PerformanceState::SerializeInfo PerformanceState::Serialize(
	v8::Local<v8::Context> context, v8::SnapshotCreator* creator) {
	// Reset all the milestones to improve determinism in the snapshot.
	// We'll re-initialize them after deserialization.
	ResetMilestones();

	SerializeInfo info{root.Serialize(context, creator),
	milestones.Serialize(context, creator),
	observers.Serialize(context, creator)};
	return info;
	}

	void PerformanceState::Initialize(uint64_t time_origin,
	double time_origin_timestamp) {
	// We are only reusing the milestone array to store the time origin
	// and time origin timestamp, so do not use the Mark() method.
	// The time origin milestone is not exposed to user land.
	this->milestones[NODE_PERFORMANCE_MILESTONE_TIME_ORIGIN] =
	static_cast<double>(time_origin);
	this->milestones[NODE_PERFORMANCE_MILESTONE_TIME_ORIGIN_TIMESTAMP] =
	time_origin_timestamp;
	}

	void PerformanceState::Deserialize(v8::Local<v8::Context> context,
	uint64_t time_origin,
	double time_origin_timestamp) {
	// Resets the pointers.
	root.Deserialize(context);
	milestones.Deserialize(context);
	observers.Deserialize(context);

	// Re-initialize the time origin and timestamp i.e. the process start time.
	Initialize(time_origin, time_origin_timestamp);
	}

	std::ostream& operator<<(std::ostream& o,
	const PerformanceState::SerializeInfo& i) {
	o << "{\n"
	<< " " << i.root << ", // root\n"
	<< " " << i.milestones << ", // milestones\n"
	<< " " << i.observers << ", // observers\n"
	<< "}";
	return o;
	}

	void PerformanceState::Mark(PerformanceMilestone milestone, uint64_t ts) {
	this->milestones[milestone] = static_cast<double>(ts);
	TRACE_EVENT_INSTANT_WITH_TIMESTAMP0(
	TRACING_CATEGORY_NODE1(bootstrap),
	GetPerformanceMilestoneName(milestone),
	TRACE_EVENT_SCOPE_THREAD, ts / 1000);
	}

	void SetupPerformanceObservers(const FunctionCallbackInfo<Value>& args) {
	Realm* realm = Realm::GetCurrent(args);
	// TODO(legendecas): Remove this check once the sub-realms are supported.
	CHECK_EQ(realm->kind(), Realm::Kind::kPrincipal);
	CHECK(args[0]->IsFunction());
	realm->set_performance_entry_callback(args[0].As<Function>());
	}

	// Marks the start of a GC cycle
	void MarkGarbageCollectionStart(
	Isolate* isolate,
	GCType type,
	GCCallbackFlags flags,
	void* data) {
	Environment* env = static_cast<Environment*>(data);
	// Prevent gc callback from reentering with different type
	// See https://github.com/nodejs/node/issues/44046
	if (env->performance_state()->current_gc_type != 0) {
	return;
	}
	env->performance_state()->performance_last_gc_start_mark = PERFORMANCE_NOW();
	env->performance_state()->current_gc_type = type;
	}

	MaybeLocal<Object> GCPerformanceEntryTraits::GetDetails(
	Environment* env,
	const GCPerformanceEntry& entry) {
	Local<Object> obj = Object::New(env->isolate());

	if (!obj->Set(
	env->context(),
	env->kind_string(),
	Integer::NewFromUnsigned(
	env->isolate(),
	entry.details.kind)).IsJust()) {
	return MaybeLocal<Object>();
	}

	if (!obj->Set(
	env->context(),
	env->flags_string(),
	Integer::NewFromUnsigned(
	env->isolate(),
	entry.details.flags)).IsJust()) {
	return MaybeLocal<Object>();
	}

	return obj;
	}

	// Marks the end of a GC cycle
	void MarkGarbageCollectionEnd(
	Isolate* isolate,
	GCType type,
	GCCallbackFlags flags,
	void* data) {
	Environment* env = static_cast<Environment*>(data);
	PerformanceState* state = env->performance_state();
	if (type != state->current_gc_type) {
	return;
	}
	env->performance_state()->current_gc_type = 0;
	// If no one is listening to gc performance entries, do not create them.
	if (LIKELY(!state->observers[NODE_PERFORMANCE_ENTRY_TYPE_GC]))
	return;

	double start_time =
	(state->performance_last_gc_start_mark - env->time_origin()) /
	NANOS_PER_MILLIS;
	double duration = (PERFORMANCE_NOW() / NANOS_PER_MILLIS) -
	(state->performance_last_gc_start_mark / NANOS_PER_MILLIS);

	std::unique_ptr<GCPerformanceEntry> entry =
	std::make_unique<GCPerformanceEntry>(
	"gc",
	start_time,
	duration,
	GCPerformanceEntry::Details(static_cast<PerformanceGCKind>(type),
	static_cast<PerformanceGCFlags>(flags)));

	env->SetImmediate([entry = std::move(entry)](Environment* env) {
	entry->Notify(env);
	}, CallbackFlags::kUnrefed);
	}

	void GarbageCollectionCleanupHook(void* data) {
	Environment* env = static_cast<Environment*>(data);
	// Reset current_gc_type to 0
	env->performance_state()->current_gc_type = 0;
	env->isolate()->RemoveGCPrologueCallback(MarkGarbageCollectionStart, data);
	env->isolate()->RemoveGCEpilogueCallback(MarkGarbageCollectionEnd, data);
	}

	static void InstallGarbageCollectionTracking(
	const FunctionCallbackInfo<Value>& args) {
	Environment* env = Environment::GetCurrent(args);
	// Reset current_gc_type to 0
	env->performance_state()->current_gc_type = 0;
	env->isolate()->AddGCPrologueCallback(MarkGarbageCollectionStart,
	static_cast<void*>(env));
	env->isolate()->AddGCEpilogueCallback(MarkGarbageCollectionEnd,
	static_cast<void*>(env));
	env->AddCleanupHook(GarbageCollectionCleanupHook, env);
	}

	static void RemoveGarbageCollectionTracking(
	const FunctionCallbackInfo<Value> &args) {
	Environment* env = Environment::GetCurrent(args);

	env->RemoveCleanupHook(GarbageCollectionCleanupHook, env);
	GarbageCollectionCleanupHook(env);
	}

	// Notify a custom PerformanceEntry to observers
	void Notify(const FunctionCallbackInfo<Value>& args) {
	Environment* env = Environment::GetCurrent(args);
	Utf8Value type(env->isolate(), args[0]);
	Local<Value> entry = args[1];
	PerformanceEntryType entry_type = ToPerformanceEntryTypeEnum(*type);
	AliasedUint32Array& observers = env->performance_state()->observers;
	if (entry_type != NODE_PERFORMANCE_ENTRY_TYPE_INVALID &&
	observers[entry_type]) {
	USE(env->performance_entry_callback()->
	Call(env->context(), Undefined(env->isolate()), 1, &entry));
	}
	}

	// Return idle time of the event loop
	void LoopIdleTime(const FunctionCallbackInfo<Value>& args) {
	Environment* env = Environment::GetCurrent(args);
	uint64_t idle_time = uv_metrics_idle_time(env->event_loop());
	args.GetReturnValue().Set(1.0 * idle_time / NANOS_PER_MILLIS);
	}

	void CreateELDHistogram(const FunctionCallbackInfo<Value>& args) {
	Environment* env = Environment::GetCurrent(args);
	int64_t interval = args[0].As<Integer>()->Value();
	CHECK_GT(interval, 0);
	BaseObjectPtr<IntervalHistogram> histogram =
	IntervalHistogram::Create(env, interval, [](Histogram& histogram) {
	uint64_t delta = histogram.RecordDelta();
	TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
	"delay", delta);
	TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
	"min", histogram.Min());
	TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
	"max", histogram.Max());
	TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
	"mean", histogram.Mean());
	TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
	"stddev", histogram.Stddev());
	}, Histogram::Options { 1000 });
	args.GetReturnValue().Set(histogram->object());
	}

	void MarkBootstrapComplete(const FunctionCallbackInfo<Value>& args) {
	Realm* realm = Realm::GetCurrent(args);
	CHECK_EQ(realm->kind(), Realm::Kind::kPrincipal);
	realm->env()->performance_state()->Mark(
	performance::NODE_PERFORMANCE_MILESTONE_BOOTSTRAP_COMPLETE);
	}

	static double PerformanceNowImpl() {
	return static_cast<double>(uv_hrtime() - performance_process_start) /
	NANOS_PER_MILLIS;
	}

	static double FastPerformanceNow(v8::Local<v8::Value> receiver) {
	return PerformanceNowImpl();
	}

	static void SlowPerformanceNow(const FunctionCallbackInfo<Value>& args) {
	args.GetReturnValue().Set(PerformanceNowImpl());
	}

	static v8::CFunction fast_performance_now(
	v8::CFunction::Make(FastPerformanceNow));

	static void CreatePerIsolateProperties(IsolateData* isolate_data,
	Local<ObjectTemplate> target) {
	Isolate* isolate = isolate_data->isolate();

	HistogramBase::Initialize(isolate_data, target);

	SetMethod(isolate, target, "setupObservers", SetupPerformanceObservers);
	SetMethod(isolate,
	target,
	"installGarbageCollectionTracking",
	InstallGarbageCollectionTracking);
	SetMethod(isolate,
	target,
	"removeGarbageCollectionTracking",
	RemoveGarbageCollectionTracking);
	SetMethod(isolate, target, "notify", Notify);
	SetMethod(isolate, target, "loopIdleTime", LoopIdleTime);
	SetMethod(isolate, target, "createELDHistogram", CreateELDHistogram);
	SetMethod(isolate, target, "markBootstrapComplete", MarkBootstrapComplete);
	SetFastMethodNoSideEffect(
	isolate, target, "now", SlowPerformanceNow, &fast_performance_now);
	}

	void CreatePerContextProperties(Local<Object> target,
	Local<Value> unused,
	Local<Context> context,
	void* priv) {
	Environment* env = Environment::GetCurrent(context);
	Isolate* isolate = env->isolate();
	PerformanceState* state = env->performance_state();

	target->Set(context,
	FIXED_ONE_BYTE_STRING(isolate, "observerCounts"),
	state->observers.GetJSArray()).Check();
	target->Set(context,
	FIXED_ONE_BYTE_STRING(isolate, "milestones"),
	state->milestones.GetJSArray()).Check();

	Local<Object> constants = Object::New(isolate);

	NODE_DEFINE_CONSTANT(constants, NODE_PERFORMANCE_GC_MAJOR);
	NODE_DEFINE_CONSTANT(constants, NODE_PERFORMANCE_GC_MINOR);
	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)
	#undef V

	#define V(name, _) \
	NODE_DEFINE_HIDDEN_CONSTANT(constants, NODE_PERFORMANCE_MILESTONE_##name);
	NODE_PERFORMANCE_MILESTONES(V)
	#undef V

	PropertyAttribute attr =
	static_cast<PropertyAttribute>(ReadOnly \| DontDelete);

	target->DefineOwnProperty(context, env->constants_string(), constants, attr)
	.ToChecked();
	}

	void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
	registry->Register(SetupPerformanceObservers);
	registry->Register(InstallGarbageCollectionTracking);
	registry->Register(RemoveGarbageCollectionTracking);
	registry->Register(Notify);
	registry->Register(LoopIdleTime);
	registry->Register(CreateELDHistogram);
	registry->Register(MarkBootstrapComplete);
	registry->Register(SlowPerformanceNow);
	registry->Register(FastPerformanceNow);
	registry->Register(fast_performance_now.GetTypeInfo());
	HistogramBase::RegisterExternalReferences(registry);
	IntervalHistogram::RegisterExternalReferences(registry);
	}
	} // namespace performance
	} // namespace node

	NODE_BINDING_CONTEXT_AWARE_INTERNAL(
	performance, node::performance::CreatePerContextProperties)
	NODE_BINDING_PER_ISOLATE_INIT(performance,
	node::performance::CreatePerIsolateProperties)
	NODE_BINDING_EXTERNAL_REFERENCE(performance,
	node::performance::RegisterExternalReferences)