GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: node_perf.cc Lines: 159 177 89.8 %
Date: 2022-08-02 04:16:51 Branches: 34 52 65.4 %

Line Branch Exec Source
1
#include "node_perf.h"
2
#include "aliased_buffer.h"
3
#include "env-inl.h"
4
#include "histogram-inl.h"
5
#include "memory_tracker-inl.h"
6
#include "node_buffer.h"
7
#include "node_external_reference.h"
8
#include "node_internals.h"
9
#include "node_process-inl.h"
10
#include "util-inl.h"
11
12
#include <cinttypes>
13
14
namespace node {
15
namespace performance {
16
17
using v8::Context;
18
using v8::DontDelete;
19
using v8::Function;
20
using v8::FunctionCallbackInfo;
21
using v8::FunctionTemplate;
22
using v8::GCCallbackFlags;
23
using v8::GCType;
24
using v8::Int32;
25
using v8::Integer;
26
using v8::Isolate;
27
using v8::Local;
28
using v8::MaybeLocal;
29
using v8::Number;
30
using v8::Object;
31
using v8::PropertyAttribute;
32
using v8::ReadOnly;
33
using v8::String;
34
using v8::Value;
35
36
// Microseconds in a millisecond, as a float.
37
#define MICROS_PER_MILLIS 1e3
38
// Nanoseconds in a millisecond, as a float.
39
#define NANOS_PER_MILLIS 1e6
40
41
uint64_t performance_v8_start;
42
43
6597
PerformanceState::PerformanceState(Isolate* isolate,
44
6597
                                   const PerformanceState::SerializeInfo* info)
45
    : root(isolate,
46
           sizeof(performance_state_internal),
47
           MAYBE_FIELD_PTR(info, root)),
48
      milestones(isolate,
49
                 offsetof(performance_state_internal, milestones),
50
                 NODE_PERFORMANCE_MILESTONE_INVALID,
51
6597
                 root,
52
                 MAYBE_FIELD_PTR(info, milestones)),
53
      observers(isolate,
54
                offsetof(performance_state_internal, observers),
55
                NODE_PERFORMANCE_ENTRY_TYPE_INVALID,
56
6597
                root,
57

6597
                MAYBE_FIELD_PTR(info, observers)) {
58
6597
  if (info == nullptr) {
59
9121
    for (size_t i = 0; i < milestones.Length(); i++) milestones[i] = -1.;
60
  }
61
6597
}
62
63
6
PerformanceState::SerializeInfo PerformanceState::Serialize(
64
    v8::Local<v8::Context> context, v8::SnapshotCreator* creator) {
65
6
  SerializeInfo info{root.Serialize(context, creator),
66
6
                     milestones.Serialize(context, creator),
67
6
                     observers.Serialize(context, creator)};
68
6
  return info;
69
}
70
71
5294
void PerformanceState::Deserialize(v8::Local<v8::Context> context) {
72
5294
  root.Deserialize(context);
73
  // This is just done to set up the pointers, we will actually reset
74
  // all the milestones after deserialization.
75
5294
  milestones.Deserialize(context);
76
5294
  observers.Deserialize(context);
77
5294
}
78
79
6
std::ostream& operator<<(std::ostream& o,
80
                         const PerformanceState::SerializeInfo& i) {
81
  o << "{\n"
82
6
    << "  " << i.root << ",  // root\n"
83
6
    << "  " << i.milestones << ",  // milestones\n"
84
6
    << "  " << i.observers << ",  // observers\n"
85
6
    << "}";
86
6
  return o;
87
}
88
89
38588
void PerformanceState::Mark(PerformanceMilestone milestone, uint64_t ts) {
90
38588
  this->milestones[milestone] = static_cast<double>(ts);
91

43898
  TRACE_EVENT_INSTANT_WITH_TIMESTAMP0(
92
      TRACING_CATEGORY_NODE1(bootstrap),
93
      GetPerformanceMilestoneName(milestone),
94
      TRACE_EVENT_SCOPE_THREAD, ts / 1000);
95
38588
}
96
97
// Allows specific Node.js lifecycle milestones to be set from JavaScript
98
void MarkMilestone(const FunctionCallbackInfo<Value>& args) {
99
  Environment* env = Environment::GetCurrent(args);
100
  PerformanceMilestone milestone =
101
      static_cast<PerformanceMilestone>(args[0].As<Int32>()->Value());
102
  if (milestone != NODE_PERFORMANCE_MILESTONE_INVALID)
103
    env->performance_state()->Mark(milestone);
104
}
105
106
1303
void SetupPerformanceObservers(const FunctionCallbackInfo<Value>& args) {
107
1303
  Environment* env = Environment::GetCurrent(args);
108
1303
  CHECK(args[0]->IsFunction());
109
2606
  env->set_performance_entry_callback(args[0].As<Function>());
110
1303
}
111
112
// Marks the start of a GC cycle
113
1
void MarkGarbageCollectionStart(
114
    Isolate* isolate,
115
    GCType type,
116
    GCCallbackFlags flags,
117
    void* data) {
118
1
  Environment* env = static_cast<Environment*>(data);
119
1
  env->performance_state()->performance_last_gc_start_mark = PERFORMANCE_NOW();
120
1
}
121
122
1
MaybeLocal<Object> GCPerformanceEntryTraits::GetDetails(
123
    Environment* env,
124
    const GCPerformanceEntry& entry) {
125
1
  Local<Object> obj = Object::New(env->isolate());
126
127
2
  if (!obj->Set(
128
          env->context(),
129
          env->kind_string(),
130
          Integer::NewFromUnsigned(
131
              env->isolate(),
132
4
              entry.details.kind)).IsJust()) {
133
    return MaybeLocal<Object>();
134
  }
135
136
2
  if (!obj->Set(
137
          env->context(),
138
          env->flags_string(),
139
          Integer::NewFromUnsigned(
140
              env->isolate(),
141
4
              entry.details.flags)).IsJust()) {
142
    return MaybeLocal<Object>();
143
  }
144
145
1
  return obj;
146
}
147
148
// Marks the end of a GC cycle
149
1
void MarkGarbageCollectionEnd(
150
    Isolate* isolate,
151
    GCType type,
152
    GCCallbackFlags flags,
153
    void* data) {
154
1
  Environment* env = static_cast<Environment*>(data);
155
1
  PerformanceState* state = env->performance_state();
156
  // If no one is listening to gc performance entries, do not create them.
157
1
  if (LIKELY(!state->observers[NODE_PERFORMANCE_ENTRY_TYPE_GC]))
158
    return;
159
160
  double start_time =
161
1
      (state->performance_last_gc_start_mark - env->time_origin()) /
162
1
      NANOS_PER_MILLIS;
163
1
  double duration = (PERFORMANCE_NOW() / NANOS_PER_MILLIS) -
164
2
                    (state->performance_last_gc_start_mark / NANOS_PER_MILLIS);
165
166
  std::unique_ptr<GCPerformanceEntry> entry =
167
      std::make_unique<GCPerformanceEntry>(
168
          "gc",
169
          start_time,
170
          duration,
171
1
          GCPerformanceEntry::Details(static_cast<PerformanceGCKind>(type),
172
1
                                      static_cast<PerformanceGCFlags>(flags)));
173
174
1
  env->SetImmediate([entry = std::move(entry)](Environment* env) {
175
1
    entry->Notify(env);
176
1
  }, CallbackFlags::kUnrefed);
177
}
178
179
4
void GarbageCollectionCleanupHook(void* data) {
180
4
  Environment* env = static_cast<Environment*>(data);
181
4
  env->isolate()->RemoveGCPrologueCallback(MarkGarbageCollectionStart, data);
182
4
  env->isolate()->RemoveGCEpilogueCallback(MarkGarbageCollectionEnd, data);
183
4
}
184
185
4
static void InstallGarbageCollectionTracking(
186
    const FunctionCallbackInfo<Value>& args) {
187
4
  Environment* env = Environment::GetCurrent(args);
188
189
4
  env->isolate()->AddGCPrologueCallback(MarkGarbageCollectionStart,
190
                                        static_cast<void*>(env));
191
4
  env->isolate()->AddGCEpilogueCallback(MarkGarbageCollectionEnd,
192
                                        static_cast<void*>(env));
193
4
  env->AddCleanupHook(GarbageCollectionCleanupHook, env);
194
4
}
195
196
3
static void RemoveGarbageCollectionTracking(
197
  const FunctionCallbackInfo<Value> &args) {
198
3
  Environment* env = Environment::GetCurrent(args);
199
200
3
  env->RemoveCleanupHook(GarbageCollectionCleanupHook, env);
201
3
  GarbageCollectionCleanupHook(env);
202
3
}
203
204
// Gets the name of a function
205
inline Local<Value> GetName(Local<Function> fn) {
206
  Local<Value> val = fn->GetDebugName();
207
  if (val.IsEmpty() || val->IsUndefined()) {
208
    Local<Value> boundFunction = fn->GetBoundFunction();
209
    if (!boundFunction.IsEmpty() && !boundFunction->IsUndefined()) {
210
      val = GetName(boundFunction.As<Function>());
211
    }
212
  }
213
  return val;
214
}
215
216
// Notify a custom PerformanceEntry to observers
217
void Notify(const FunctionCallbackInfo<Value>& args) {
218
  Environment* env = Environment::GetCurrent(args);
219
  Utf8Value type(env->isolate(), args[0]);
220
  Local<Value> entry = args[1];
221
  PerformanceEntryType entry_type = ToPerformanceEntryTypeEnum(*type);
222
  AliasedUint32Array& observers = env->performance_state()->observers;
223
  if (entry_type != NODE_PERFORMANCE_ENTRY_TYPE_INVALID &&
224
      observers[entry_type]) {
225
    USE(env->performance_entry_callback()->
226
      Call(env->context(), Undefined(env->isolate()), 1, &entry));
227
  }
228
}
229
230
// Return idle time of the event loop
231
60
void LoopIdleTime(const FunctionCallbackInfo<Value>& args) {
232
60
  Environment* env = Environment::GetCurrent(args);
233
60
  uint64_t idle_time = uv_metrics_idle_time(env->event_loop());
234
60
  args.GetReturnValue().Set(1.0 * idle_time / 1e6);
235
60
}
236
237
3
void CreateELDHistogram(const FunctionCallbackInfo<Value>& args) {
238
3
  Environment* env = Environment::GetCurrent(args);
239
6
  int64_t interval = args[0].As<Integer>()->Value();
240
3
  CHECK_GT(interval, 0);
241
  BaseObjectPtr<IntervalHistogram> histogram =
242
1756
      IntervalHistogram::Create(env, interval, [](Histogram& histogram) {
243
1756
        uint64_t delta = histogram.RecordDelta();
244

1758
        TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
245
                        "delay", delta);
246

1758
        TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
247
                      "min", histogram.Min());
248

1758
        TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
249
                      "max", histogram.Max());
250

1758
        TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
251
                      "mean", histogram.Mean());
252

1758
        TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
253
                      "stddev", histogram.Stddev());
254
6
      }, Histogram::Options { 1000 });
255
6
  args.GetReturnValue().Set(histogram->object());
256
3
}
257
258
7866
void GetTimeOrigin(const FunctionCallbackInfo<Value>& args) {
259
7866
  Environment* env = Environment::GetCurrent(args);
260
7866
  args.GetReturnValue().Set(
261
7866
      Number::New(args.GetIsolate(), env->time_origin() / 1e6));
262
7866
}
263
264
7866
void GetTimeOriginTimeStamp(const FunctionCallbackInfo<Value>& args) {
265
7866
  Environment* env = Environment::GetCurrent(args);
266
7866
  args.GetReturnValue().Set(Number::New(
267
7866
      args.GetIsolate(), env->time_origin_timestamp() / MICROS_PER_MILLIS));
268
7866
}
269
270
1303
void Initialize(Local<Object> target,
271
                Local<Value> unused,
272
                Local<Context> context,
273
                void* priv) {
274
1303
  Environment* env = Environment::GetCurrent(context);
275
1303
  Isolate* isolate = env->isolate();
276
1303
  PerformanceState* state = env->performance_state();
277
278
1303
  target->Set(context,
279
              FIXED_ONE_BYTE_STRING(isolate, "observerCounts"),
280
5212
              state->observers.GetJSArray()).Check();
281
1303
  target->Set(context,
282
              FIXED_ONE_BYTE_STRING(isolate, "milestones"),
283
3909
              state->milestones.GetJSArray()).Check();
284
285
  Local<String> performanceEntryString =
286
1303
      FIXED_ONE_BYTE_STRING(isolate, "PerformanceEntry");
287
288
1303
  Local<FunctionTemplate> pe = FunctionTemplate::New(isolate);
289
1303
  pe->SetClassName(performanceEntryString);
290
2606
  Local<Function> fn = pe->GetFunction(context).ToLocalChecked();
291
1303
  target->Set(context, performanceEntryString, fn).Check();
292
1303
  env->set_performance_entry_template(fn);
293
294
1303
  SetMethod(context, target, "markMilestone", MarkMilestone);
295
1303
  SetMethod(context, target, "setupObservers", SetupPerformanceObservers);
296
1303
  SetMethod(context,
297
            target,
298
            "installGarbageCollectionTracking",
299
            InstallGarbageCollectionTracking);
300
1303
  SetMethod(context,
301
            target,
302
            "removeGarbageCollectionTracking",
303
            RemoveGarbageCollectionTracking);
304
1303
  SetMethod(context, target, "notify", Notify);
305
1303
  SetMethod(context, target, "loopIdleTime", LoopIdleTime);
306
1303
  SetMethod(context, target, "getTimeOrigin", GetTimeOrigin);
307
1303
  SetMethod(context, target, "getTimeOriginTimestamp", GetTimeOriginTimeStamp);
308
1303
  SetMethod(context, target, "createELDHistogram", CreateELDHistogram);
309
310
1303
  Local<Object> constants = Object::New(isolate);
311
312
3909
  NODE_DEFINE_CONSTANT(constants, NODE_PERFORMANCE_GC_MAJOR);
313
3909
  NODE_DEFINE_CONSTANT(constants, NODE_PERFORMANCE_GC_MINOR);
314
3909
  NODE_DEFINE_CONSTANT(constants, NODE_PERFORMANCE_GC_INCREMENTAL);
315
3909
  NODE_DEFINE_CONSTANT(constants, NODE_PERFORMANCE_GC_WEAKCB);
316
317
3909
  NODE_DEFINE_CONSTANT(
318
    constants, NODE_PERFORMANCE_GC_FLAGS_NO);
319
3909
  NODE_DEFINE_CONSTANT(
320
    constants, NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED);
321
3909
  NODE_DEFINE_CONSTANT(
322
    constants, NODE_PERFORMANCE_GC_FLAGS_FORCED);
323
3909
  NODE_DEFINE_CONSTANT(
324
    constants, NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING);
325
3909
  NODE_DEFINE_CONSTANT(
326
    constants, NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE);
327
3909
  NODE_DEFINE_CONSTANT(
328
    constants, NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY);
329
3909
  NODE_DEFINE_CONSTANT(
330
    constants, NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE);
331
332
#define V(name, _)                                                            \
333
  NODE_DEFINE_HIDDEN_CONSTANT(constants, NODE_PERFORMANCE_ENTRY_TYPE_##name);
334
14333
  NODE_PERFORMANCE_ENTRY_TYPES(V)
335
#undef V
336
337
#define V(name, _)                                                            \
338
  NODE_DEFINE_HIDDEN_CONSTANT(constants, NODE_PERFORMANCE_MILESTONE_##name);
339
15636
  NODE_PERFORMANCE_MILESTONES(V)
340
#undef V
341
342
1303
  PropertyAttribute attr =
343
      static_cast<PropertyAttribute>(ReadOnly | DontDelete);
344
345
1303
  target->DefineOwnProperty(context,
346
                            env->constants_string(),
347
                            constants,
348
2606
                            attr).ToChecked();
349
350
1303
  HistogramBase::Initialize(env, target);
351
1303
}
352
353
5300
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
354
5300
  registry->Register(MarkMilestone);
355
5300
  registry->Register(SetupPerformanceObservers);
356
5300
  registry->Register(InstallGarbageCollectionTracking);
357
5300
  registry->Register(RemoveGarbageCollectionTracking);
358
5300
  registry->Register(Notify);
359
5300
  registry->Register(LoopIdleTime);
360
5300
  registry->Register(GetTimeOrigin);
361
5300
  registry->Register(GetTimeOriginTimeStamp);
362
5300
  registry->Register(CreateELDHistogram);
363
5300
  HistogramBase::RegisterExternalReferences(registry);
364
5300
  IntervalHistogram::RegisterExternalReferences(registry);
365
5300
}
366
}  // namespace performance
367
}  // namespace node
368
369
5368
NODE_MODULE_CONTEXT_AWARE_INTERNAL(performance, node::performance::Initialize)
370
5300
NODE_MODULE_EXTERNAL_REFERENCE(performance,
371
                               node::performance::RegisterExternalReferences)