rename IntervalHistogram to ELDHistogram

Author: pabloerhard

doc/api/perf_hooks.md

@@ -1713,11 +1713,11 @@ added: v11.10.0
     `uv_prepare_t`/`uv_check_t` hooks, so this value is ignored. It is still
     validated to preserve backward compatible error behavior. Must be greater
     than zero. **Default:** `10`.
-* Returns: {IntervalHistogram}
+* Returns: {ELDHistogram}
 
 _This property is an extension by Node.js. It is not available in Web browsers._
 
-Creates an `IntervalHistogram` object that samples and reports the event loop
+Creates an `ELDHistogram` object that samples and reports the event loop
 delay over time. The delays will be reported in nanoseconds.
 
 Samples are taken directly from the event loop using `uv_prepare_t` and
@@ -2000,9 +2000,10 @@ added: v11.10.0
 
 The standard deviation of the recorded event loop delays.
 
-## Class: `IntervalHistogram extends Histogram`
+## Class: `ELDHistogram extends Histogram`
 
-A `Histogram` that is periodically updated on a given interval.
+A `Histogram` that is updated on each event loop iteration via libuv
+`uv_prepare_t`/`uv_check_t` hooks to measure event loop delay.
 
 ### `histogram.disable()`
 
@@ -2012,7 +2013,7 @@ added: v11.10.0
 
 * Returns: {boolean}
 
-Disables the update interval timer. Returns `true` if the timer was
+Disables event loop delay sampling. Returns `true` if sampling was
 stopped, `false` if it was already stopped.
 
 ### `histogram.enable()`
@@ -2023,7 +2024,7 @@ added: v11.10.0
 
 * Returns: {boolean}
 
-Enables the update interval timer. Returns `true` if the timer was
+Enables event loop delay sampling. Returns `true` if sampling was
 started, `false` if it was already started.
 
 ### `histogram[Symbol.dispose]()`
@@ -2032,7 +2033,7 @@ started, `false` if it was already started.
 added: v24.2.0
 -->
 
-Disables the update interval timer when the histogram is disposed.
+Disables event loop delay sampling when the histogram is disposed.
 
 ```js
 const { monitorEventLoopDelay } = require('node:perf_hooks');
@@ -2043,9 +2044,9 @@ const { monitorEventLoopDelay } = require('node:perf_hooks');
 }
 ```
 
-### Cloning an `IntervalHistogram`
+### Cloning an `ELDHistogram`
 
-{IntervalHistogram} instances can be cloned via {MessagePort}. On the receiving
+{ELDHistogram} instances can be cloned via {MessagePort}. On the receiving
 end, the histogram is cloned as a plain {Histogram} object that does not
 implement the `enable()` and `disable()` methods.
 

src/env_properties.h

@@ -424,7 +424,7 @@
   V(http2stream_constructor_template, v8::ObjectTemplate)                      \
   V(http2ping_constructor_template, v8::ObjectTemplate)                        \
   V(i18n_converter_template, v8::ObjectTemplate)                               \
-  V(intervalhistogram_constructor_template, v8::FunctionTemplate)              \
+  V(eldhistogram_constructor_template, v8::FunctionTemplate)                   \
   V(iter_template, v8::DictionaryTemplate)                                     \
   V(js_transferable_constructor_template, v8::FunctionTemplate)                \
   V(libuv_stream_wrap_ctor_template, v8::FunctionTemplate)                     \

src/histogram.cc

@@ -64,10 +64,10 @@ CFunction HistogramBase::fast_record_(
     CFunction::Make(&HistogramBase::FastRecord));
 CFunction HistogramBase::fast_record_delta_(
     CFunction::Make(&HistogramBase::FastRecordDelta));
-CFunction IntervalHistogram::fast_start_(
-    CFunction::Make(&IntervalHistogram::FastStart));
-CFunction IntervalHistogram::fast_stop_(
-    CFunction::Make(&IntervalHistogram::FastStop));
+CFunction ELDHistogram::fast_start_(
+    CFunction::Make(&ELDHistogram::FastStart));
+CFunction ELDHistogram::fast_stop_(
+    CFunction::Make(&ELDHistogram::FastStop));
 
 void HistogramImpl::AddMethods(Isolate* isolate, Local<FunctionTemplate> tmpl) {
   // TODO(@jasnell): The bigint API variations do not yet support fast
@@ -319,25 +319,25 @@ void HistogramBase::HistogramTransferData::MemoryInfo(
   tracker->TrackField("histogram", histogram_);
 }
 
-Local<FunctionTemplate> IntervalHistogram::GetConstructorTemplate(
+Local<FunctionTemplate> ELDHistogram::GetConstructorTemplate(
     Environment* env) {
-  Local<FunctionTemplate> tmpl = env->intervalhistogram_constructor_template();
+  Local<FunctionTemplate> tmpl = env->eldhistogram_constructor_template();
   if (tmpl.IsEmpty()) {
     Isolate* isolate = env->isolate();
     tmpl = NewFunctionTemplate(isolate, nullptr);
     tmpl->Inherit(HandleWrap::GetConstructorTemplate(env));
     tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "Histogram"));
     auto instance = tmpl->InstanceTemplate();
-    instance->SetInternalFieldCount(IntervalHistogram::kInternalFieldCount);
+    instance->SetInternalFieldCount(ELDHistogram::kInternalFieldCount);
     HistogramImpl::AddMethods(isolate, tmpl);
     SetFastMethod(isolate, instance, "start", Start, &fast_start_);
     SetFastMethod(isolate, instance, "stop", Stop, &fast_stop_);
-    env->set_intervalhistogram_constructor_template(tmpl);
+    env->set_eldhistogram_constructor_template(tmpl);
   }
   return tmpl;
 }
 
-void IntervalHistogram::RegisterExternalReferences(
+void ELDHistogram::RegisterExternalReferences(
     ExternalReferenceRegistry* registry) {
   registry->Register(Start);
   registry->Register(Stop);
@@ -346,7 +346,7 @@ void IntervalHistogram::RegisterExternalReferences(
   HistogramImpl::RegisterExternalReferences(registry);
 }
 
-IntervalHistogram::IntervalHistogram(
+ELDHistogram::ELDHistogram(
     Environment* env,
     Local<Object> wrap,
     AsyncWrap::ProviderType type,
@@ -369,7 +369,7 @@ IntervalHistogram::IntervalHistogram(
   prepare_handle_.data = this;
 }
 
-BaseObjectPtr<IntervalHistogram> IntervalHistogram::Create(
+BaseObjectPtr<ELDHistogram> ELDHistogram::Create(
     Environment* env,
     const Histogram::Options& options) {
   Local<Object> obj;
@@ -379,23 +379,23 @@ BaseObjectPtr<IntervalHistogram> IntervalHistogram::Create(
     return nullptr;
   }
 
-  return MakeBaseObject<IntervalHistogram>(
+  return MakeBaseObject<ELDHistogram>(
       env,
       obj,
       AsyncWrap::PROVIDER_ELDHISTOGRAM,
       options);
 }
 
-void IntervalHistogram::PrepareCB(uv_prepare_t* handle) {
-  IntervalHistogram* self = static_cast<IntervalHistogram*>(handle->data);
+void ELDHistogram::PrepareCB(uv_prepare_t* handle) {
+  ELDHistogram* self = static_cast<ELDHistogram*>(handle->data);
   if (!self->enabled_) return;
   self->prepare_time_ = uv_hrtime();
   self->timeout_ = uv_backend_timeout(handle->loop);
 }
 
-void IntervalHistogram::CheckCB(uv_check_t* handle) {
-  IntervalHistogram* self =
-      ContainerOf(&IntervalHistogram::check_handle_, handle);
+void ELDHistogram::CheckCB(uv_check_t* handle) {
+  ELDHistogram* self =
+      ContainerOf(&ELDHistogram::check_handle_, handle);
   if (!self->enabled_) return;
 
   uint64_t check_time = uv_hrtime();
@@ -413,11 +413,11 @@ void IntervalHistogram::CheckCB(uv_check_t* handle) {
   self->check_time_ = check_time;
 }
 
-void IntervalHistogram::MemoryInfo(MemoryTracker* tracker) const {
+void ELDHistogram::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackField("histogram", histogram());
 }
 
-void IntervalHistogram::OnStart(StartFlags flags) {
+void ELDHistogram::OnStart(StartFlags flags) {
   if (enabled_ || IsHandleClosing()) return;
   enabled_ = true;
   if (flags == StartFlags::RESET)
@@ -431,20 +431,20 @@ void IntervalHistogram::OnStart(StartFlags flags) {
   uv_unref(reinterpret_cast<uv_handle_t*>(&prepare_handle_));
 }
 
-void IntervalHistogram::OnStop() {
+void ELDHistogram::OnStop() {
   if (!enabled_ || IsHandleClosing()) return;
   enabled_ = false;
   uv_check_stop(&check_handle_);
   uv_prepare_stop(&prepare_handle_);
 }
 
-void IntervalHistogram::PrepareCloseCB(uv_handle_t* handle) {
-  IntervalHistogram* self = static_cast<IntervalHistogram*>(handle->data);
+void ELDHistogram::PrepareCloseCB(uv_handle_t* handle) {
+  ELDHistogram* self = static_cast<ELDHistogram*>(handle->data);
   uv_close(reinterpret_cast<uv_handle_t*>(&self->check_handle_),
            HandleWrap::OnClose);
 }
 
-void IntervalHistogram::Close(Local<Value> close_callback) {
+void ELDHistogram::Close(Local<Value> close_callback) {
   if (IsHandleClosing()) return;
   OnStop();
   state_ = kClosing;
@@ -460,28 +460,28 @@ void IntervalHistogram::Close(Local<Value> close_callback) {
            PrepareCloseCB);
 }
 
-void IntervalHistogram::Start(const FunctionCallbackInfo<Value>& args) {
-  IntervalHistogram* histogram;
+void ELDHistogram::Start(const FunctionCallbackInfo<Value>& args) {
+  ELDHistogram* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, args.This());
   histogram->OnStart(args[0]->IsTrue() ? StartFlags::RESET : StartFlags::NONE);
 }
 
-void IntervalHistogram::FastStart(Local<Value> receiver, bool reset) {
+void ELDHistogram::FastStart(Local<Value> receiver, bool reset) {
   TRACK_V8_FAST_API_CALL("histogram.start");
-  IntervalHistogram* histogram;
+  ELDHistogram* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, receiver);
   histogram->OnStart(reset ? StartFlags::RESET : StartFlags::NONE);
 }
 
-void IntervalHistogram::Stop(const FunctionCallbackInfo<Value>& args) {
-  IntervalHistogram* histogram;
+void ELDHistogram::Stop(const FunctionCallbackInfo<Value>& args) {
+  ELDHistogram* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, args.This());
   histogram->OnStop();
 }
 
-void IntervalHistogram::FastStop(Local<Value> receiver) {
+void ELDHistogram::FastStop(Local<Value> receiver) {
   TRACK_V8_FAST_API_CALL("histogram.stop");
-  IntervalHistogram* histogram;
+  ELDHistogram* histogram;
   ASSIGN_OR_RETURN_UNWRAP(&histogram, receiver);
   histogram->OnStop();
 }
@@ -650,7 +650,7 @@ HistogramImpl* HistogramImpl::FromJSObject(Local<Value> value) {
 }
 
 std::unique_ptr<worker::TransferData>
-IntervalHistogram::CloneForMessaging() const {
+ELDHistogram::CloneForMessaging() const {
   return std::make_unique<HistogramBase::HistogramTransferData>(histogram());
 }
 

src/histogram.h

@@ -206,7 +206,7 @@ class HistogramBase final : public BaseObject, public HistogramImpl {
   static v8::CFunction fast_record_delta_;
 };
 
-class IntervalHistogram final : public HandleWrap, public HistogramImpl {
+class ELDHistogram final : public HandleWrap, public HistogramImpl {
  public:
   enum InternalFields {
     kInternalFieldCount = std::max<uint32_t>(
@@ -223,11 +223,11 @@ class IntervalHistogram final : public HandleWrap, public HistogramImpl {
   static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
       Environment* env);
 
-  static BaseObjectPtr<IntervalHistogram> Create(
+  static BaseObjectPtr<ELDHistogram> Create(
       Environment* env,
       const Histogram::Options& options);
 
-  IntervalHistogram(
+  ELDHistogram(
       Environment* env,
       v8::Local<v8::Object> wrap,
       AsyncWrap::ProviderType type,
@@ -248,8 +248,8 @@ class IntervalHistogram final : public HandleWrap, public HistogramImpl {
                  v8::Local<v8::Value>()) override;
 
   void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(IntervalHistogram)
-  SET_SELF_SIZE(IntervalHistogram)
+  SET_MEMORY_INFO_NAME(ELDHistogram)
+  SET_SELF_SIZE(ELDHistogram)
 
  private:
   static void PrepareCB(uv_prepare_t* handle);

src/node_perf.cc

@@ -280,8 +280,8 @@ void UvMetricsInfo(const FunctionCallbackInfo<Value>& args) {
 
 void CreateELDHistogram(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  BaseObjectPtr<IntervalHistogram> histogram =
-      IntervalHistogram::Create(env, Histogram::Options { 1 });
+  BaseObjectPtr<ELDHistogram> histogram =
+      ELDHistogram::Create(env, Histogram::Options { 1 });
   args.GetReturnValue().Set(histogram->object());
 }
 
@@ -398,7 +398,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(SlowPerformanceNow);
   registry->Register(fast_performance_now);
   HistogramBase::RegisterExternalReferences(registry);
-  IntervalHistogram::RegisterExternalReferences(registry);
+  ELDHistogram::RegisterExternalReferences(registry);
 }
 }  // namespace performance
 }  // namespace node