GCC Code Coverage Report
Directory: ../ Exec Total Coverage
File: /home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/tracing/trace_event.h Lines: 59 63 93.7 %
Date: 2019-10-06 22:30:00 Branches: 75 132 56.8 %

Line Branch Exec Source
1
// Copyright 2015 the V8 project authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style license that can be
3
// found in the LICENSE file.
4
5
#ifndef SRC_TRACING_TRACE_EVENT_H_
6
#define SRC_TRACING_TRACE_EVENT_H_
7
8
#include "node_platform.h"
9
#include "v8-platform.h"
10
#include "trace_event_common.h"
11
#include <atomic>
12
13
// This header file defines implementation details of how the trace macros in
14
// trace_event_common.h collect and store trace events. Anything not
15
// implementation-specific should go in trace_macros_common.h instead of here.
16
17
18
// The pointer returned from GetCategoryGroupEnabled() points to a
19
// value with zero or more of the following bits. Used in this class only.
20
// The TRACE_EVENT macros should only use the value as a bool.
21
// These values must be in sync with macro values in trace_log.h in
22
// chromium.
23
enum CategoryGroupEnabledFlags {
24
  // Category group enabled for the recording mode.
25
  kEnabledForRecording_CategoryGroupEnabledFlags = 1 << 0,
26
  // Category group enabled by SetEventCallbackEnabled().
27
  kEnabledForEventCallback_CategoryGroupEnabledFlags = 1 << 2,
28
  // Category group enabled to export events to ETW.
29
  kEnabledForETWExport_CategoryGroupEnabledFlags = 1 << 3,
30
};
31
32
// By default, const char* argument values are assumed to have long-lived scope
33
// and will not be copied. Use this macro to force a const char* to be copied.
34
#define TRACE_STR_COPY(str) node::tracing::TraceStringWithCopy(str)
35
36
// By default, uint64 ID argument values are not mangled with the Process ID in
37
// TRACE_EVENT_ASYNC macros. Use this macro to force Process ID mangling.
38
#define TRACE_ID_MANGLE(id) node::tracing::TraceID::ForceMangle(id)
39
40
// By default, pointers are mangled with the Process ID in TRACE_EVENT_ASYNC
41
// macros. Use this macro to prevent Process ID mangling.
42
#define TRACE_ID_DONT_MANGLE(id) node::tracing::TraceID::DontMangle(id)
43
44
// By default, trace IDs are eventually converted to a single 64-bit number. Use
45
// this macro to add a scope string.
46
#define TRACE_ID_WITH_SCOPE(scope, id) \
47
  trace_event_internal::TraceID::WithScope(scope, id)
48
49
#define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
50
  *INTERNAL_TRACE_EVENT_UID(category_group_enabled) &                    \
51
      (kEnabledForRecording_CategoryGroupEnabledFlags |                  \
52
       kEnabledForEventCallback_CategoryGroupEnabledFlags)
53
54
// The following macro has no implementation, but it needs to exist since
55
// it gets called from scoped trace events. It cannot call UNIMPLEMENTED()
56
// since an empty implementation is a valid one.
57
#define INTERNAL_TRACE_MEMORY(category, name)
58
59
////////////////////////////////////////////////////////////////////////////////
60
// Implementation specific tracing API definitions.
61
62
// Get a pointer to the enabled state of the given trace category. Only
63
// long-lived literal strings should be given as the category group. The
64
// returned pointer can be held permanently in a local static for example. If
65
// the unsigned char is non-zero, tracing is enabled. If tracing is enabled,
66
// TRACE_EVENT_API_ADD_TRACE_EVENT can be called. It's OK if tracing is disabled
67
// between the load of the tracing state and the call to
68
// TRACE_EVENT_API_ADD_TRACE_EVENT, because this flag only provides an early out
69
// for best performance when tracing is disabled.
70
// const uint8_t*
71
//     TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(const char* category_group)
72
#define TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED              \
73
  node::tracing::TraceEventHelper::GetTracingController()       \
74
      ->GetCategoryGroupEnabled
75
76
// Get the number of times traces have been recorded. This is used to implement
77
// the TRACE_EVENT_IS_NEW_TRACE facility.
78
// unsigned int TRACE_EVENT_API_GET_NUM_TRACES_RECORDED()
79
#define TRACE_EVENT_API_GET_NUM_TRACES_RECORDED UNIMPLEMENTED()
80
81
// Add a trace event to the platform tracing system.
82
// uint64_t TRACE_EVENT_API_ADD_TRACE_EVENT(
83
//                    char phase,
84
//                    const uint8_t* category_group_enabled,
85
//                    const char* name,
86
//                    const char* scope,
87
//                    uint64_t id,
88
//                    uint64_t bind_id,
89
//                    int num_args,
90
//                    const char** arg_names,
91
//                    const uint8_t* arg_types,
92
//                    const uint64_t* arg_values,
93
//                    unsigned int flags)
94
#define TRACE_EVENT_API_ADD_TRACE_EVENT node::tracing::AddTraceEventImpl
95
96
// Add a trace event to the platform tracing system.
97
// uint64_t TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_TIMESTAMP(
98
//                    char phase,
99
//                    const uint8_t* category_group_enabled,
100
//                    const char* name,
101
//                    const char* scope,
102
//                    uint64_t id,
103
//                    uint64_t bind_id,
104
//                    int num_args,
105
//                    const char** arg_names,
106
//                    const uint8_t* arg_types,
107
//                    const uint64_t* arg_values,
108
//                    unsigned int flags,
109
//                    int64_t timestamp)
110
#define TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_TIMESTAMP \
111
  node::tracing::AddTraceEventWithTimestampImpl
112
113
// Set the duration field of a COMPLETE trace event.
114
// void TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
115
//     const uint8_t* category_group_enabled,
116
//     const char* name,
117
//     uint64_t id)
118
#define TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION             \
119
  node::tracing::TraceEventHelper::GetTracingController()       \
120
      ->UpdateTraceEventDuration
121
122
// Adds a metadata event to the trace log. The |AppendValueAsTraceFormat| method
123
// on the convertable value will be called at flush time.
124
// TRACE_EVENT_API_ADD_METADATA_EVENT(
125
//     const unsigned char* category_group_enabled,
126
//     const char* event_name,
127
//     const char* arg_name,
128
//     std::unique_ptr<ConvertableToTraceFormat> arg_value)
129
#define TRACE_EVENT_API_ADD_METADATA_EVENT node::tracing::AddMetadataEvent
130
131
// Defines atomic operations used internally by the tracing system.
132
#define TRACE_EVENT_API_ATOMIC_WORD std::atomic<intptr_t>
133
#define TRACE_EVENT_API_ATOMIC_WORD_VALUE intptr_t
134
#define TRACE_EVENT_API_ATOMIC_LOAD(var) (var).load()
135
#define TRACE_EVENT_API_ATOMIC_STORE(var, value) (var).store(value)
136
137
////////////////////////////////////////////////////////////////////////////////
138
139
// Implementation detail: trace event macros create temporary variables
140
// to keep instrumentation overhead low. These macros give each temporary
141
// variable a unique name based on the line number to prevent name collisions.
142
#define INTERNAL_TRACE_EVENT_UID3(a, b) trace_event_unique_##a##b
143
#define INTERNAL_TRACE_EVENT_UID2(a, b) INTERNAL_TRACE_EVENT_UID3(a, b)
144
#define INTERNAL_TRACE_EVENT_UID(name_prefix) \
145
  INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__)
146
147
// Implementation detail: internal macro to create static category.
148
// No barriers are needed, because this code is designed to operate safely
149
// even when the unsigned char* points to garbage data (which may be the case
150
// on processors without cache coherency).
151
// TODO(fmeawad): This implementation contradicts that we can have a different
152
// configuration for each isolate,
153
// https://code.google.com/p/v8/issues/detail?id=4563
154
#define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES(             \
155
    category_group, atomic, category_group_enabled)                          \
156
  category_group_enabled =                                                   \
157
      reinterpret_cast<const uint8_t*>(TRACE_EVENT_API_ATOMIC_LOAD(atomic)); \
158
  if (!category_group_enabled) {                                             \
159
    category_group_enabled =                                                 \
160
        TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category_group);          \
161
    TRACE_EVENT_API_ATOMIC_STORE(                                            \
162
        atomic, reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD_VALUE>(         \
163
                    category_group_enabled));                                \
164
  }
165
166
#define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group)             \
167
  static TRACE_EVENT_API_ATOMIC_WORD INTERNAL_TRACE_EVENT_UID(atomic) {0}; \
168
  const uint8_t* INTERNAL_TRACE_EVENT_UID(category_group_enabled);         \
169
  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES(                 \
170
      category_group, INTERNAL_TRACE_EVENT_UID(atomic),                    \
171
      INTERNAL_TRACE_EVENT_UID(category_group_enabled));
172
173
// Implementation detail: internal macro to create static category and add
174
// event if the category is enabled.
175
#define INTERNAL_TRACE_EVENT_ADD(phase, category_group, name, flags, ...)    \
176
  do {                                                                       \
177
    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                  \
178
    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {  \
179
      node::tracing::AddTraceEvent(                                          \
180
          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,     \
181
          node::tracing::kGlobalScope, node::tracing::kNoId,                 \
182
          node::tracing::kNoId, flags, ##__VA_ARGS__);                       \
183
    }                                                                        \
184
  } while (0)
185
186
// Implementation detail: internal macro to create static category and add begin
187
// event if the category is enabled. Also adds the end event when the scope
188
// ends.
189
#define INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, ...)           \
190
  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                    \
191
  node::tracing::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer);              \
192
  if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {    \
193
    uint64_t h = node::tracing::AddTraceEvent(                               \
194
        TRACE_EVENT_PHASE_COMPLETE,                                          \
195
        INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,              \
196
        node::tracing::kGlobalScope, node::tracing::kNoId,                   \
197
        node::tracing::kNoId, TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__);         \
198
    INTERNAL_TRACE_EVENT_UID(tracer)                                         \
199
        .Initialize(INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,  \
200
                    h);                                                      \
201
  }
202
203
#define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name,     \
204
                                                  bind_id, flow_flags, ...) \
205
  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                   \
206
  node::tracing::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer);             \
207
  if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {   \
208
    unsigned int trace_event_flags = flow_flags;                            \
209
    node::tracing::TraceID trace_event_bind_id(bind_id,                     \
210
                                               &trace_event_flags);         \
211
    uint64_t h = node::tracing::AddTraceEvent(                              \
212
        TRACE_EVENT_PHASE_COMPLETE,                                         \
213
        INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,             \
214
        node::tracing::kGlobalScope, node::tracing::kNoId,                  \
215
        trace_event_bind_id.raw_id(), trace_event_flags, ##__VA_ARGS__);    \
216
    INTERNAL_TRACE_EVENT_UID(tracer)                                        \
217
        .Initialize(INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
218
                    h);                                                     \
219
  }
220
221
// Implementation detail: internal macro to create static category and add
222
// event if the category is enabled.
223
#define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category_group, name, id,      \
224
                                         flags, ...)                           \
225
  do {                                                                         \
226
    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                    \
227
    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {    \
228
      unsigned int trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID;        \
229
      node::tracing::TraceID trace_event_trace_id(id,                          \
230
                                                  &trace_event_flags);         \
231
      node::tracing::AddTraceEvent(                                            \
232
          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,       \
233
          trace_event_trace_id.scope(), trace_event_trace_id.raw_id(),         \
234
          node::tracing::kNoId, trace_event_flags, ##__VA_ARGS__);             \
235
    }                                                                          \
236
  } while (0)
237
238
// Adds a trace event with a given timestamp.
239
#define INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(phase, category_group, name, \
240
                                                timestamp, flags, ...)       \
241
  do {                                                                       \
242
    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                  \
243
    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {  \
244
      node::tracing::AddTraceEventWithTimestamp(                     \
245
          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,     \
246
          node::tracing::kGlobalScope, node::tracing::kNoId, \
247
          node::tracing::kNoId, flags, timestamp, ##__VA_ARGS__);    \
248
    }                                                                        \
249
  } while (0)
250
251
// Adds a trace event with a given id and timestamp. Not Implemented.
252
#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_AND_TIMESTAMP(     \
253
    phase, category_group, name, id, timestamp, flags, ...) \
254
  UNIMPLEMENTED()
255
256
// Adds a trace event with a given id, thread_id, and timestamp. Not
257
// Implemented.
258
#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(                  \
259
    phase, category_group, name, id, thread_id, timestamp, flags, ...)       \
260
  do {                                                                       \
261
    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                  \
262
    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {  \
263
      unsigned int trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID;      \
264
      node::tracing::TraceID trace_event_trace_id(id,                        \
265
                                                  &trace_event_flags);       \
266
      node::tracing::AddTraceEventWithTimestamp(                             \
267
          phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,     \
268
          trace_event_trace_id.scope(), trace_event_trace_id.raw_id(),       \
269
          node::tracing::kNoId, trace_event_flags, timestamp, ##__VA_ARGS__);\
270
    }                                                                        \
271
  } while (0)
272
273
#define INTERNAL_TRACE_EVENT_METADATA_ADD(category_group, name, ...)  \
274
  do { \
275
    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
276
    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
277
      TRACE_EVENT_API_ADD_METADATA_EVENT( \
278
          INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
279
          ##__VA_ARGS__); \
280
    } \
281
  } while(0)
282
283
// Enter and leave a context based on the current scope.
284
#define INTERNAL_TRACE_EVENT_SCOPED_CONTEXT(category_group, name, context) \
285
  struct INTERNAL_TRACE_EVENT_UID(ScopedContext) {                         \
286
   public:                                                                 \
287
    INTERNAL_TRACE_EVENT_UID(ScopedContext)(uint64_t cid) : cid_(cid) {    \
288
      TRACE_EVENT_ENTER_CONTEXT(category_group, name, cid_);               \
289
    }                                                                      \
290
    ~INTERNAL_TRACE_EVENT_UID(ScopedContext)() {                           \
291
      TRACE_EVENT_LEAVE_CONTEXT(category_group, name, cid_);               \
292
    }                                                                      \
293
                                                                           \
294
   private:                                                                \
295
    /* Local class friendly DISALLOW_COPY_AND_ASSIGN */                    \
296
    INTERNAL_TRACE_EVENT_UID(ScopedContext)                                \
297
    (const INTERNAL_TRACE_EVENT_UID(ScopedContext)&) {}                    \
298
    void operator=(const INTERNAL_TRACE_EVENT_UID(ScopedContext)&) {}      \
299
    uint64_t cid_;                                                         \
300
  };                                                                       \
301
  INTERNAL_TRACE_EVENT_UID(ScopedContext)                                  \
302
  INTERNAL_TRACE_EVENT_UID(scoped_context)(context);
303
304
namespace node {
305
namespace tracing {
306
307
// Specify these values when the corresponding argument of AddTraceEvent is not
308
// used.
309
const int kZeroNumArgs = 0;
310
const decltype(nullptr) kGlobalScope = nullptr;
311
const uint64_t kNoId = 0;
312
313
// Extern (for now) because embedders need access to TraceEventHelper.
314
// Refs: https://github.com/nodejs/node/pull/28724
315
class NODE_EXTERN TraceEventHelper {
316
 public:
317
  static TracingController* GetTracingController();
318
  static Agent* GetAgent();
319
  static void SetAgent(Agent* agent);
320
};
321
322
// TraceID encapsulates an ID that can either be an integer or pointer. Pointers
323
// are by default mangled with the Process ID so that they are unlikely to
324
// collide when the same pointer is used on different processes.
325
class TraceID {
326
 public:
327
  class WithScope {
328
   public:
329
    WithScope(const char* scope, uint64_t raw_id)
330
        : scope_(scope), raw_id_(raw_id) {}
331
    uint64_t raw_id() const { return raw_id_; }
332
    const char* scope() const { return scope_; }
333
334
   private:
335
    const char* scope_ = nullptr;
336
    uint64_t raw_id_;
337
  };
338
339
  class DontMangle {
340
   public:
341
    explicit DontMangle(const void* raw_id)
342
        : raw_id_(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(raw_id))) {}
343
    explicit DontMangle(uint64_t raw_id) : raw_id_(raw_id) {}
344
    explicit DontMangle(unsigned int raw_id) : raw_id_(raw_id) {}
345
    explicit DontMangle(uint16_t raw_id) : raw_id_(raw_id) {}
346
    explicit DontMangle(unsigned char raw_id) : raw_id_(raw_id) {}
347
    explicit DontMangle(int64_t raw_id)
348
        : raw_id_(static_cast<uint64_t>(raw_id)) {}
349
    explicit DontMangle(int raw_id) : raw_id_(static_cast<uint64_t>(raw_id)) {}
350
    explicit DontMangle(int16_t raw_id)
351
        : raw_id_(static_cast<uint64_t>(raw_id)) {}
352
    explicit DontMangle(signed char raw_id)
353
        : raw_id_(static_cast<uint64_t>(raw_id)) {}
354
    explicit DontMangle(WithScope scoped_id)
355
        : scope_(scoped_id.scope()), raw_id_(scoped_id.raw_id()) {}
356
    const char* scope() const { return scope_; }
357
    uint64_t raw_id() const { return raw_id_; }
358
359
   private:
360
    const char* scope_ = nullptr;
361
    uint64_t raw_id_;
362
  };
363
364
  class ForceMangle {
365
   public:
366
    explicit ForceMangle(uint64_t raw_id) : raw_id_(raw_id) {}
367
    explicit ForceMangle(unsigned int raw_id) : raw_id_(raw_id) {}
368
    explicit ForceMangle(uint16_t raw_id) : raw_id_(raw_id) {}
369
    explicit ForceMangle(unsigned char raw_id) : raw_id_(raw_id) {}
370
    explicit ForceMangle(int64_t raw_id)
371
        : raw_id_(static_cast<uint64_t>(raw_id)) {}
372
    explicit ForceMangle(int raw_id) : raw_id_(static_cast<uint64_t>(raw_id)) {}
373
    explicit ForceMangle(int16_t raw_id)
374
        : raw_id_(static_cast<uint64_t>(raw_id)) {}
375
    explicit ForceMangle(signed char raw_id)
376
        : raw_id_(static_cast<uint64_t>(raw_id)) {}
377
    uint64_t raw_id() const { return raw_id_; }
378
379
   private:
380
    uint64_t raw_id_;
381
  };
382
383
162
  TraceID(const void* raw_id, unsigned int* flags)
384
162
      : raw_id_(static_cast<uint64_t>(reinterpret_cast<uintptr_t>(raw_id))) {
385
162
    *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
386
162
  }
387
  TraceID(ForceMangle raw_id, unsigned int* flags) : raw_id_(raw_id.raw_id()) {
388
    *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
389
  }
390
  TraceID(DontMangle maybe_scoped_id, unsigned int* flags)
391
      : scope_(maybe_scoped_id.scope()), raw_id_(maybe_scoped_id.raw_id()) {}
392
  TraceID(uint64_t raw_id, unsigned int* flags) : raw_id_(raw_id) {
393
    (void)flags;
394
  }
395
  TraceID(unsigned int raw_id, unsigned int* flags) : raw_id_(raw_id) {
396
    (void)flags;
397
  }
398
  TraceID(uint16_t raw_id, unsigned int* flags) : raw_id_(raw_id) {
399
    (void)flags;
400
  }
401
  TraceID(unsigned char raw_id, unsigned int* flags) : raw_id_(raw_id) {
402
    (void)flags;
403
  }
404
74
  TraceID(int64_t raw_id, unsigned int* flags)
405
74
      : raw_id_(static_cast<uint64_t>(raw_id)) {
406
    (void)flags;
407
74
  }
408
  TraceID(int raw_id, unsigned int* flags)
409
      : raw_id_(static_cast<uint64_t>(raw_id)) {
410
    (void)flags;
411
  }
412
  TraceID(int16_t raw_id, unsigned int* flags)
413
      : raw_id_(static_cast<uint64_t>(raw_id)) {
414
    (void)flags;
415
  }
416
  TraceID(signed char raw_id, unsigned int* flags)
417
      : raw_id_(static_cast<uint64_t>(raw_id)) {
418
    (void)flags;
419
  }
420
  TraceID(WithScope scoped_id, unsigned int* flags)
421
      : scope_(scoped_id.scope()), raw_id_(scoped_id.raw_id()) {}
422
423
236
  uint64_t raw_id() const { return raw_id_; }
424
236
  const char* scope() const { return scope_; }
425
426
 private:
427
  const char* scope_ = nullptr;
428
  uint64_t raw_id_;
429
};
430
431
// Simple union to store various types as uint64_t.
432
union TraceValueUnion {
433
  bool as_bool;
434
  uint64_t as_uint;
435
  int64_t as_int;
436
  double as_double;
437
  const void* as_pointer;
438
  const char* as_string;
439
};
440
441
// Simple container for const char* that should be copied instead of retained.
442
class TraceStringWithCopy {
443
 public:
444
96
  explicit TraceStringWithCopy(const char* str) : str_(str) {}
445
96
  operator const char*() const { return str_; }
446
447
 private:
448
  const char* str_;
449
};
450
451
578
static inline uint64_t AddTraceEventImpl(
452
    char phase, const uint8_t* category_group_enabled, const char* name,
453
    const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
454
    const char** arg_names, const uint8_t* arg_types,
455
    const uint64_t* arg_values, unsigned int flags) {
456
1736
  std::unique_ptr<v8::ConvertableToTraceFormat> arg_convertibles[2];
457

578
  if (num_args > 0 && arg_types[0] == TRACE_VALUE_TYPE_CONVERTABLE) {
458
    arg_convertibles[0].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
459
25
        static_cast<intptr_t>(arg_values[0])));
460
  }
461

578
  if (num_args > 1 && arg_types[1] == TRACE_VALUE_TYPE_CONVERTABLE) {
462
    arg_convertibles[1].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
463
        static_cast<intptr_t>(arg_values[1])));
464
  }
465
  // DCHECK(num_args, 2);
466
  v8::TracingController* controller =
467
578
      node::tracing::TraceEventHelper::GetTracingController();
468
  return controller->AddTraceEvent(phase, category_group_enabled, name, scope, id,
469
                                   bind_id, num_args, arg_names, arg_types,
470
1736
                                   arg_values, arg_convertibles, flags);
471
}
472
473
static V8_INLINE uint64_t AddTraceEventWithTimestampImpl(
474
    char phase, const uint8_t* category_group_enabled, const char* name,
475
    const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
476
    const char** arg_names, const uint8_t* arg_types,
477
    const uint64_t* arg_values, unsigned int flags, int64_t timestamp) {
478



195
  std::unique_ptr<v8::ConvertableToTraceFormat> arg_convertables[2];
479






65
  if (num_args > 0 && arg_types[0] == TRACE_VALUE_TYPE_CONVERTABLE) {
480
    arg_convertables[0].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
481
        static_cast<intptr_t>(arg_values[0])));
482
  }
483






65
  if (num_args > 1 && arg_types[1] == TRACE_VALUE_TYPE_CONVERTABLE) {
484
    arg_convertables[1].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
485
        static_cast<intptr_t>(arg_values[1])));
486
  }
487
  // DCHECK_LE(num_args, 2);
488
  v8::TracingController* controller =
489
65
      node::tracing::TraceEventHelper::GetTracingController();
490
  return controller->AddTraceEventWithTimestamp(
491
      phase, category_group_enabled, name, scope, id, bind_id, num_args,
492



65
      arg_names, arg_types, arg_values, arg_convertables, flags, timestamp);
493
}
494
495
static V8_INLINE void AddMetadataEventImpl(
496
    const uint8_t* category_group_enabled, const char* name, int32_t num_args,
497
    const char** arg_names, const uint8_t* arg_types,
498
    const uint64_t* arg_values, unsigned int flags) {
499


1870
  std::unique_ptr<v8::ConvertableToTraceFormat> arg_convertibles[2];
500




624
  if (num_args > 0 && arg_types[0] == TRACE_VALUE_TYPE_CONVERTABLE) {
501
    arg_convertibles[0].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
502
72
        static_cast<intptr_t>(arg_values[0])));
503
  }
504




623
  if (num_args > 1 && arg_types[1] == TRACE_VALUE_TYPE_CONVERTABLE) {
505
    arg_convertibles[1].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
506
        static_cast<intptr_t>(arg_values[1])));
507
  }
508
  node::tracing::TracingController* controller =
509
623
      node::tracing::TraceEventHelper::GetTracingController();
510
  return controller->AddMetadataEvent(
511
      category_group_enabled, name, num_args, arg_names, arg_types, arg_values,
512


624
      arg_convertibles, flags);
513
}
514
515
// Define SetTraceValue for each allowed type. It stores the type and
516
// value in the return arguments. This allows this API to avoid declaring any
517
// structures so that it is portable to third_party libraries.
518
#define INTERNAL_DECLARE_SET_TRACE_VALUE(actual_type, union_member,         \
519
                                         value_type_id)                     \
520
  static inline void SetTraceValue(actual_type arg, unsigned char* type,    \
521
                                   uint64_t* value) {                       \
522
    TraceValueUnion type_value;                                             \
523
    type_value.union_member = arg;                                          \
524
    *type = value_type_id;                                                  \
525
    *value = type_value.as_uint;                                            \
526
  }
527
// Simpler form for int types that can be safely casted.
528
#define INTERNAL_DECLARE_SET_TRACE_VALUE_INT(actual_type, value_type_id)    \
529
  static inline void SetTraceValue(actual_type arg, unsigned char* type,    \
530
                                   uint64_t* value) {                       \
531
    *type = value_type_id;                                                  \
532
    *value = static_cast<uint64_t>(arg);                                    \
533
  }
534
535
1
INTERNAL_DECLARE_SET_TRACE_VALUE_INT(uint64_t, TRACE_VALUE_TYPE_UINT)
536
1
INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned int, TRACE_VALUE_TYPE_UINT)
537
INTERNAL_DECLARE_SET_TRACE_VALUE_INT(uint16_t, TRACE_VALUE_TYPE_UINT)
538
INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned char, TRACE_VALUE_TYPE_UINT)
539
INTERNAL_DECLARE_SET_TRACE_VALUE_INT(int64_t, TRACE_VALUE_TYPE_INT)
540
40
INTERNAL_DECLARE_SET_TRACE_VALUE_INT(int, TRACE_VALUE_TYPE_INT)
541
INTERNAL_DECLARE_SET_TRACE_VALUE_INT(int16_t, TRACE_VALUE_TYPE_INT)
542
INTERNAL_DECLARE_SET_TRACE_VALUE_INT(signed char, TRACE_VALUE_TYPE_INT)
543
1
INTERNAL_DECLARE_SET_TRACE_VALUE(bool, as_bool, TRACE_VALUE_TYPE_BOOL)
544
INTERNAL_DECLARE_SET_TRACE_VALUE(double, as_double, TRACE_VALUE_TYPE_DOUBLE)
545
INTERNAL_DECLARE_SET_TRACE_VALUE(const void*, as_pointer,
546
                                 TRACE_VALUE_TYPE_POINTER)
547
479
INTERNAL_DECLARE_SET_TRACE_VALUE(const char*, as_string,
548
                                 TRACE_VALUE_TYPE_STRING)
549
96
INTERNAL_DECLARE_SET_TRACE_VALUE(const TraceStringWithCopy&, as_string,
550
                                 TRACE_VALUE_TYPE_COPY_STRING)
551
552
#undef INTERNAL_DECLARE_SET_TRACE_VALUE
553
#undef INTERNAL_DECLARE_SET_TRACE_VALUE_INT
554
555
97
static inline void SetTraceValue(v8::ConvertableToTraceFormat* convertable_value,
556
                                    unsigned char* type, uint64_t* value) {
557
97
  *type = TRACE_VALUE_TYPE_CONVERTABLE;
558
97
  *value = static_cast<uint64_t>(reinterpret_cast<intptr_t>(convertable_value));
559
97
}
560
561
template <typename T>
562
static inline typename std::enable_if<
563
    std::is_convertible<T*, v8::ConvertableToTraceFormat*>::value>::type
564
97
SetTraceValue(std::unique_ptr<T> ptr, unsigned char* type, uint64_t* value) {
565
97
  SetTraceValue(ptr.release(), type, value);
566
97
}
567
568
// These AddTraceEvent template
569
// function is defined here instead of in the macro, because the arg_values
570
// could be temporary objects, such as std::string. In order to store
571
// pointers to the internal c_str and pass through to the tracing API,
572
// the arg_values must live throughout these procedures.
573
574
493
static inline uint64_t AddTraceEvent(char phase,
575
                                        const uint8_t* category_group_enabled,
576
                                        const char* name, const char* scope,
577
                                        uint64_t id, uint64_t bind_id,
578
                                        unsigned int flags) {
579
  return TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_group_enabled, name,
580
                                         scope, id, bind_id, kZeroNumArgs,
581
493
                                         nullptr, nullptr, nullptr, flags);
582
}
583
584
template <class ARG1_TYPE>
585
77
static inline uint64_t AddTraceEvent(
586
    char phase, const uint8_t* category_group_enabled, const char* name,
587
    const char* scope, uint64_t id, uint64_t bind_id, unsigned int flags,
588
    const char* arg1_name, ARG1_TYPE&& arg1_val) {
589
77
  const int num_args = 1;
590
  uint8_t arg_type;
591
  uint64_t arg_value;
592
77
  SetTraceValue(std::forward<ARG1_TYPE>(arg1_val), &arg_type, &arg_value);
593
  return TRACE_EVENT_API_ADD_TRACE_EVENT(
594
      phase, category_group_enabled, name, scope, id, bind_id, num_args,
595
77
      &arg1_name, &arg_type, &arg_value, flags);
596
}
597
598
template <class ARG1_TYPE, class ARG2_TYPE>
599
8
static inline uint64_t AddTraceEvent(
600
    char phase, const uint8_t* category_group_enabled, const char* name,
601
    const char* scope, uint64_t id, uint64_t bind_id, unsigned int flags,
602
    const char* arg1_name, ARG1_TYPE&& arg1_val, const char* arg2_name,
603
    ARG2_TYPE&& arg2_val) {
604
8
  const int num_args = 2;
605
8
  const char* arg_names[2] = {arg1_name, arg2_name};
606
  unsigned char arg_types[2];
607
  uint64_t arg_values[2];
608
12
  SetTraceValue(std::forward<ARG1_TYPE>(arg1_val), &arg_types[0],
609
4
                &arg_values[0]);
610
14
  SetTraceValue(std::forward<ARG2_TYPE>(arg2_val), &arg_types[1],
611
6
                &arg_values[1]);
612
  return TRACE_EVENT_API_ADD_TRACE_EVENT(
613
      phase, category_group_enabled, name, scope, id, bind_id, num_args,
614
8
      arg_names, arg_types, arg_values, flags);
615
}
616
617
static V8_INLINE uint64_t AddTraceEventWithTimestamp(
618
    char phase, const uint8_t* category_group_enabled, const char* name,
619
    const char* scope, uint64_t id, uint64_t bind_id, unsigned int flags,
620
    int64_t timestamp) {
621
  return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_TIMESTAMP(
622
      phase, category_group_enabled, name, scope, id, bind_id, kZeroNumArgs,
623
130
      nullptr, nullptr, nullptr, flags, timestamp);
624
}
625
626
template <class ARG1_TYPE>
627
static V8_INLINE uint64_t AddTraceEventWithTimestamp(
628
    char phase, const uint8_t* category_group_enabled, const char* name,
629
    const char* scope, uint64_t id, uint64_t bind_id, unsigned int flags,
630
    int64_t timestamp, const char* arg1_name, ARG1_TYPE&& arg1_val) {
631
  const int num_args = 1;
632
  uint8_t arg_type;
633
  uint64_t arg_value;
634
  SetTraceValue(std::forward<ARG1_TYPE>(arg1_val), &arg_type, &arg_value);
635
  return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_TIMESTAMP(
636
      phase, category_group_enabled, name, scope, id, bind_id, num_args,
637
      &arg1_name, &arg_type, &arg_value, flags, timestamp);
638
}
639
640
template <class ARG1_TYPE, class ARG2_TYPE>
641
static V8_INLINE uint64_t AddTraceEventWithTimestamp(
642
    char phase, const uint8_t* category_group_enabled, const char* name,
643
    const char* scope, uint64_t id, uint64_t bind_id, unsigned int flags,
644
    int64_t timestamp, const char* arg1_name, ARG1_TYPE&& arg1_val,
645
    const char* arg2_name, ARG2_TYPE&& arg2_val) {
646
  const int num_args = 2;
647
  const char* arg_names[2] = {arg1_name, arg2_name};
648
  unsigned char arg_types[2];
649
  uint64_t arg_values[2];
650
  SetTraceValue(std::forward<ARG1_TYPE>(arg1_val), &arg_types[0],
651
                &arg_values[0]);
652
  SetTraceValue(std::forward<ARG2_TYPE>(arg2_val), &arg_types[1],
653
                &arg_values[1]);
654
  return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_TIMESTAMP(
655
      phase, category_group_enabled, name, scope, id, bind_id, num_args,
656
      arg_names, arg_types, arg_values, flags, timestamp);
657
}
658
659
template <class ARG1_TYPE>
660
static V8_INLINE void AddMetadataEvent(
661
    const uint8_t* category_group_enabled, const char* name,
662
    const char* arg1_name, ARG1_TYPE&& arg1_val) {
663
621
  const int num_args = 1;
664
  uint8_t arg_type;
665
  uint64_t arg_value;
666
621
  SetTraceValue(std::forward<ARG1_TYPE>(arg1_val), &arg_type, &arg_value);
667
  AddMetadataEventImpl(
668
      category_group_enabled, name, num_args, &arg1_name, &arg_type, &arg_value,
669
      TRACE_EVENT_FLAG_NONE);
670
}
671
672
// Used by TRACE_EVENTx macros. Do not use directly.
673
class ScopedTracer {
674
 public:
675
  // Note: members of data_ intentionally left uninitialized. See Initialize.
676
  ScopedTracer() : p_data_(nullptr) {}
677
678
  ~ScopedTracer() {
679
    if (p_data_ && *data_.category_group_enabled)
680
      TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
681
          data_.category_group_enabled, data_.name, data_.event_handle);
682
  }
683
684
  void Initialize(const uint8_t* category_group_enabled, const char* name,
685
                  uint64_t event_handle) {
686
    data_.category_group_enabled = category_group_enabled;
687
    data_.name = name;
688
    data_.event_handle = event_handle;
689
    p_data_ = &data_;
690
  }
691
692
 private:
693
  // This Data struct workaround is to avoid initializing all the members
694
  // in Data during construction of this object, since this object is always
695
  // constructed, even when tracing is disabled. If the members of Data were
696
  // members of this class instead, compiler warnings occur about potential
697
  // uninitialized accesses.
698
  struct Data {
699
    const uint8_t* category_group_enabled;
700
    const char* name;
701
    uint64_t event_handle;
702
  };
703
  Data* p_data_;
704
  Data data_;
705
};
706
707
}  // namespace tracing
708
}  // namespace node
709
710
#endif  // SRC_TRACING_TRACE_EVENT_H_