Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	node_perf.h	Lines:	22	31	71.0 %
Date:	2022-10-14 05:16:24	Branches:	18	43	41.9 %


#ifndef SRC_NODE_PERF_H_
#define SRC_NODE_PERF_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "base_object-inl.h"
#include "histogram.h"
#include "node.h"
#include "node_internals.h"
#include "node_perf_common.h"

#include "v8.h"
#include "uv.h"

#include <string>

namespace node {

class Environment;
class ExternalReferenceRegistry;

namespace performance {

inline const char* GetPerformanceMilestoneName(
    PerformanceMilestone milestone) {
  switch (milestone) {
#define V(name, label) case NODE_PERFORMANCE_MILESTONE_##name: return label;
  NODE_PERFORMANCE_MILESTONES(V)
#undef V
    default:
      UNREACHABLE();
  }
}

inline PerformanceMilestone ToPerformanceMilestoneEnum(const char* str) {
#define V(name, label)                                                        \
  if (strcmp(str, label) == 0) return NODE_PERFORMANCE_MILESTONE_##name;
  NODE_PERFORMANCE_MILESTONES(V)
#undef V
  return NODE_PERFORMANCE_MILESTONE_INVALID;
}

inline const char* GetPerformanceEntryTypeName(
    PerformanceEntryType type) {
  switch (type) {
#define V(name, label) case NODE_PERFORMANCE_ENTRY_TYPE_##name: return label;
  NODE_PERFORMANCE_ENTRY_TYPES(V)
#undef V
    default:
      UNREACHABLE();
  }
}

inline PerformanceEntryType ToPerformanceEntryTypeEnum(
    const char* type) {
#define V(name, label)                                                        \
  if (strcmp(type, label) == 0) return NODE_PERFORMANCE_ENTRY_TYPE_##name;
  NODE_PERFORMANCE_ENTRY_TYPES(V)
#undef V
  return NODE_PERFORMANCE_ENTRY_TYPE_INVALID;
}

enum PerformanceGCKind {
  NODE_PERFORMANCE_GC_MAJOR = v8::GCType::kGCTypeMarkSweepCompact,
  NODE_PERFORMANCE_GC_MINOR = v8::GCType::kGCTypeScavenge,
  NODE_PERFORMANCE_GC_INCREMENTAL = v8::GCType::kGCTypeIncrementalMarking,
  NODE_PERFORMANCE_GC_WEAKCB = v8::GCType::kGCTypeProcessWeakCallbacks
};

enum PerformanceGCFlags {
  NODE_PERFORMANCE_GC_FLAGS_NO =
    v8::GCCallbackFlags::kNoGCCallbackFlags,
  NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED =
    v8::GCCallbackFlags::kGCCallbackFlagConstructRetainedObjectInfos,
  NODE_PERFORMANCE_GC_FLAGS_FORCED =
    v8::GCCallbackFlags::kGCCallbackFlagForced,
  NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING =
    v8::GCCallbackFlags::kGCCallbackFlagSynchronousPhantomCallbackProcessing,
  NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE =
    v8::GCCallbackFlags::kGCCallbackFlagCollectAllAvailableGarbage,
  NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY =
    v8::GCCallbackFlags::kGCCallbackFlagCollectAllExternalMemory,
  NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE =
    v8::GCCallbackFlags::kGCCallbackScheduleIdleGarbageCollection
};

template <typename Traits>
struct PerformanceEntry {
  using Details = typename Traits::Details;
  std::string name;
  double start_time;
  double duration;
  Details details;

  PerformanceEntry(
    const std::string& name_,
    double start_time_,
    double duration_,
    const Details& details_)
    : name(name_),
      start_time(start_time_),
      duration(duration_),
      details(details_) {}

  static v8::MaybeLocal<v8::Object> GetDetails(
      Environment* env,
      const PerformanceEntry<Traits>& entry) {
    return Traits::GetDetails(env, entry);
  }

  void Notify(Environment* env) {
    v8::HandleScope handle_scope(env->isolate());
    v8::Context::Scope scope(env->context());
    AliasedUint32Array& observers = env->performance_state()->observers;
    if (env->performance_entry_callback().IsEmpty() ||
        !observers[Traits::kType]) {
      return;
    }

    v8::Local<v8::Object> detail;
    if (!Traits::GetDetails(env, *this).ToLocal(&detail)) {
      // TODO(@jasnell): Handle the error here
      return;
    }

    v8::Local<v8::Value> argv[] = {
      OneByteString(env->isolate(), name.c_str()),
      OneByteString(env->isolate(), GetPerformanceEntryTypeName(Traits::kType)),
      v8::Number::New(env->isolate(), start_time),
      v8::Number::New(env->isolate(), duration),
      detail
    };

    node::MakeSyncCallback(
        env->isolate(),
        env->context()->Global(),
        env->performance_entry_callback(),
        arraysize(argv),
        argv);
  }
};

struct GCPerformanceEntryTraits {
  static constexpr PerformanceEntryType kType =
      NODE_PERFORMANCE_ENTRY_TYPE_GC;
  struct Details {
    PerformanceGCKind kind;
    PerformanceGCFlags flags;

    Details(PerformanceGCKind kind_, PerformanceGCFlags flags_)
        : kind(kind_), flags(flags_) {}
  };

  static v8::MaybeLocal<v8::Object> GetDetails(
      Environment* env,
      const PerformanceEntry<GCPerformanceEntryTraits>& entry);
};

using GCPerformanceEntry = PerformanceEntry<GCPerformanceEntryTraits>;

}  // namespace performance
}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_NODE_PERF_H_


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#ifndef SRC_NODE_PERF_H_
2			#define SRC_NODE_PERF_H_
3
4			#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
5
6			#include "base_object-inl.h"
7			#include "histogram.h"
8			#include "node.h"
9			#include "node_internals.h"
10			#include "node_perf_common.h"
11
12			#include "v8.h"
13			#include "uv.h"
14
15			#include <string>
16
17			namespace node {
18
19			class Environment;
20			class ExternalReferenceRegistry;
21
22			namespace performance {
23
24		46	inline const char* GetPerformanceMilestoneName(
25			PerformanceMilestone milestone) {
26	✓✓✓✓ ✓✓✗	46	switch (milestone) {
27			#define V(name, label) case NODE_PERFORMANCE_MILESTONE_##name: return label;
28		8	NODE_PERFORMANCE_MILESTONES(V)
29			#undef V
30			default:
31			UNREACHABLE();
32			}
33			}
34
35			inline PerformanceMilestone ToPerformanceMilestoneEnum(const char* str) {
36			#define V(name, label) \
37			if (strcmp(str, label) == 0) return NODE_PERFORMANCE_MILESTONE_##name;
38			NODE_PERFORMANCE_MILESTONES(V)
39			#undef V
40			return NODE_PERFORMANCE_MILESTONE_INVALID;
41			}
42
43		16	inline const char* GetPerformanceEntryTypeName(
44			PerformanceEntryType type) {
45	✓✗✓✗ ✗✗	16	switch (type) {
46			#define V(name, label) case NODE_PERFORMANCE_ENTRY_TYPE_##name: return label;
47		1	NODE_PERFORMANCE_ENTRY_TYPES(V)
48			#undef V
49			default:
50			UNREACHABLE();
51			}
52			}
53
54			inline PerformanceEntryType ToPerformanceEntryTypeEnum(
55			const char* type) {
56			#define V(name, label) \
57			if (strcmp(type, label) == 0) return NODE_PERFORMANCE_ENTRY_TYPE_##name;
58			NODE_PERFORMANCE_ENTRY_TYPES(V)
59			#undef V
60			return NODE_PERFORMANCE_ENTRY_TYPE_INVALID;
61			}
62
63			enum PerformanceGCKind {
64			NODE_PERFORMANCE_GC_MAJOR = v8::GCType::kGCTypeMarkSweepCompact,
65			NODE_PERFORMANCE_GC_MINOR = v8::GCType::kGCTypeScavenge,
66			NODE_PERFORMANCE_GC_INCREMENTAL = v8::GCType::kGCTypeIncrementalMarking,
67			NODE_PERFORMANCE_GC_WEAKCB = v8::GCType::kGCTypeProcessWeakCallbacks
68			};
69
70			enum PerformanceGCFlags {
71			NODE_PERFORMANCE_GC_FLAGS_NO =
72			v8::GCCallbackFlags::kNoGCCallbackFlags,
73			NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED =
74			v8::GCCallbackFlags::kGCCallbackFlagConstructRetainedObjectInfos,
75			NODE_PERFORMANCE_GC_FLAGS_FORCED =
76			v8::GCCallbackFlags::kGCCallbackFlagForced,
77			NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING =
78			v8::GCCallbackFlags::kGCCallbackFlagSynchronousPhantomCallbackProcessing,
79			NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE =
80			v8::GCCallbackFlags::kGCCallbackFlagCollectAllAvailableGarbage,
81			NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY =
82			v8::GCCallbackFlags::kGCCallbackFlagCollectAllExternalMemory,
83			NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE =
84			v8::GCCallbackFlags::kGCCallbackScheduleIdleGarbageCollection
85			};
86
87			template <typename Traits>
88		17	struct PerformanceEntry {
89			using Details = typename Traits::Details;
90			std::string name;
91			double start_time;
92			double duration;
93			Details details;
94
95		17	PerformanceEntry(
96			const std::string& name_,
97			double start_time_,
98			double duration_,
99			const Details& details_)
100			: name(name_),
101			start_time(start_time_),
102			duration(duration_),
103		17	details(details_) {}
104
105			static v8::MaybeLocal<v8::Object> GetDetails(
106			Environment* env,
107			const PerformanceEntry<Traits>& entry) {
108			return Traits::GetDetails(env, entry);
109			}
110
111		16	void Notify(Environment* env) {
112		32	v8::HandleScope handle_scope(env->isolate());
113	✓✗✓✗	32	v8::Context::Scope scope(env->context());
114		16	AliasedUint32Array& observers = env->performance_state()->observers;
115	✓✗✗✓ ✗✓✓✗ ✗✓✗✓	64	if (env->performance_entry_callback().IsEmpty() \|\|
116		32	!observers[Traits::kType]) {
117			return;
118			}
119
120			v8::Local<v8::Object> detail;
121	✗✓✗✓	32	if (!Traits::GetDetails(env, *this).ToLocal(&detail)) {
122			// TODO(@jasnell): Handle the error here
123			return;
124			}
125
126		96	v8::Local<v8::Value> argv[] = {
127			OneByteString(env->isolate(), name.c_str()),
128			OneByteString(env->isolate(), GetPerformanceEntryTypeName(Traits::kType)),
129			v8::Number::New(env->isolate(), start_time),
130			v8::Number::New(env->isolate(), duration),
131			detail
132			};
133
134		32	node::MakeSyncCallback(
135			env->isolate(),
136		32	env->context()->Global(),
137			env->performance_entry_callback(),
138		16	arraysize(argv),
139			argv);
140			}
141			};
142
143			struct GCPerformanceEntryTraits {
144			static constexpr PerformanceEntryType kType =
145			NODE_PERFORMANCE_ENTRY_TYPE_GC;
146			struct Details {
147			PerformanceGCKind kind;
148			PerformanceGCFlags flags;
149
150		2	Details(PerformanceGCKind kind_, PerformanceGCFlags flags_)
151		2	: kind(kind_), flags(flags_) {}
152			};
153
154			static v8::MaybeLocal<v8::Object> GetDetails(
155			Environment* env,
156			const PerformanceEntry<GCPerformanceEntryTraits>& entry);
157			};
158
159			using GCPerformanceEntry = PerformanceEntry<GCPerformanceEntryTraits>;
160
161			} // namespace performance
162			} // namespace node
163
164			#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
165
166			#endif // SRC_NODE_PERF_H_