v8
V8 is Google’s open source high-performance JavaScript and WebAssembly engine, written in C++.
Loading...
Searching...
No Matches
trace-event-no-perfetto.h
Go to the documentation of this file.
1// Copyright 2024 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 V8_TRACING_TRACE_EVENT_NO_PERFETTO_H_
6#define V8_TRACING_TRACE_EVENT_NO_PERFETTO_H_
7
8// This is the legacy implementation of tracing macros. There have been two
9// concurrent implementations within chromium after perfetto was introduced.
10// As of 2024-05, V8 is the only remaining customer of the legacy implementation
11// and moved the legacy part from its previous location at
12// chromium/src/base/trace_event/common/trace_event_common.h into V8 directly.
13
14// New projects wishing to enable tracing should use the Perfetto SDK. See
15// https://perfetto.dev/docs/instrumentation/tracing-sdk for details.
16
17// Check that nobody includes this file directly. Clients are supposed to
18// include the surrounding "trace_event.h" of their project instead.
19#if defined(TRACE_EVENT0)
20#error "Another copy of this file has already been included."
21#endif
22
23// This will mark the trace event as disabled by default. The user will need
24// to explicitly enable the event.
25#define TRACE_DISABLED_BY_DEFAULT(name) "disabled-by-default-" name
26
27// Records a pair of begin and end events called "name" for the current
28// scope, with 0, 1 or 2 associated arguments. If the category is not
29// enabled, then this does nothing.
30// - category and name strings must have application lifetime (statics or
31// literals). They may not include " chars.
32#define TRACE_EVENT0(category_group, name) \
33 INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name)
34#define TRACE_EVENT_WITH_FLOW0(category_group, name, bind_id, flow_flags) \
35 INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
36 flow_flags)
37#define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \
38 INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val)
39#define TRACE_EVENT_WITH_FLOW1(category_group, name, bind_id, flow_flags, \
40 arg1_name, arg1_val) \
41 INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
42 flow_flags, arg1_name, arg1_val)
43#define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, \
44 arg2_val) \
45 INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val, \
46 arg2_name, arg2_val)
47#define TRACE_EVENT_WITH_FLOW2(category_group, name, bind_id, flow_flags, \
48 arg1_name, arg1_val, arg2_name, arg2_val) \
49 INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
50 flow_flags, arg1_name, arg1_val, \
51 arg2_name, arg2_val)
52
53// Records a single event called "name" immediately, with 0, 1 or 2
54// associated arguments. If the category is not enabled, then this
55// does nothing.
56// - category and name strings must have application lifetime (statics or
57// literals). They may not include " chars.
58#define TRACE_EVENT_INSTANT0(category_group, name, scope) \
59 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
60 TRACE_EVENT_FLAG_NONE | scope)
61#define TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val) \
62 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
63 TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val)
64#define TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, \
65 arg2_name, arg2_val) \
66 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
67 TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val, \
68 arg2_name, arg2_val)
69#define TRACE_EVENT_COPY_INSTANT0(category_group, name, scope) \
70 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
71 TRACE_EVENT_FLAG_COPY | scope)
72#define TRACE_EVENT_COPY_INSTANT1(category_group, name, scope, arg1_name, \
73 arg1_val) \
74 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
75 TRACE_EVENT_FLAG_COPY | scope, arg1_name, arg1_val)
76#define TRACE_EVENT_COPY_INSTANT2(category_group, name, scope, arg1_name, \
77 arg1_val, arg2_name, arg2_val) \
78 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
79 TRACE_EVENT_FLAG_COPY | scope, arg1_name, arg1_val, \
80 arg2_name, arg2_val)
81#define TRACE_EVENT_INSTANT_WITH_FLAGS0(category_group, name, scope_and_flags) \
82 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
83 scope_and_flags)
84#define TRACE_EVENT_INSTANT_WITH_FLAGS1(category_group, name, scope_and_flags, \
85 arg1_name, arg1_val) \
86 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
87 scope_and_flags, arg1_name, arg1_val)
88
89#define TRACE_EVENT_INSTANT_WITH_TIMESTAMP0(category_group, name, scope, \
90 timestamp) \
91 INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
92 TRACE_EVENT_PHASE_INSTANT, category_group, name, timestamp, \
93 TRACE_EVENT_FLAG_NONE | scope)
94
95#define TRACE_EVENT_INSTANT_WITH_TIMESTAMP1(category_group, name, scope, \
96 timestamp, arg_name, arg_val) \
97 INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
98 TRACE_EVENT_PHASE_INSTANT, category_group, name, timestamp, \
99 TRACE_EVENT_FLAG_NONE | scope, arg_name, arg_val)
100
101// Records a single BEGIN event called "name" immediately, with 0, 1 or 2
102// associated arguments. If the category is not enabled, then this
103// does nothing.
104// - category and name strings must have application lifetime (statics or
105// literals). They may not include " chars.
106#define TRACE_EVENT_BEGIN0(category_group, name) \
107 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
108 TRACE_EVENT_FLAG_NONE)
109#define TRACE_EVENT_BEGIN1(category_group, name, arg1_name, arg1_val) \
110 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
111 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
112#define TRACE_EVENT_BEGIN2(category_group, name, arg1_name, arg1_val, \
113 arg2_name, arg2_val) \
114 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
115 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, \
116 arg2_name, arg2_val)
117#define TRACE_EVENT_BEGIN_WITH_FLAGS0(category_group, name, flags) \
118 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, flags)
119#define TRACE_EVENT_BEGIN_WITH_FLAGS1(category_group, name, flags, arg1_name, \
120 arg1_val) \
121 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
122 flags, arg1_name, arg1_val)
123#define TRACE_EVENT_COPY_BEGIN2(category_group, name, arg1_name, arg1_val, \
124 arg2_name, arg2_val) \
125 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
126 TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
127 arg2_name, arg2_val)
128
129// Similar to TRACE_EVENT_BEGINx but with a custom |timestamp| provided.
130// - |id| is used to match the _BEGIN event with the _END event.
131// Events are considered to match if their category_group, name and id values
132// all match. |id| must either be a pointer or an integer value up to 64 bits.
133// If it's a pointer, the bits will be xored with a hash of the process ID so
134// that the same pointer on two different processes will not collide.
135// - |timestamp| must be non-null or it crashes. Use DCHECK(timestamp) before
136// calling this to detect an invalid timestamp even when tracing is not
137// enabled, as the commit queue doesn't run all tests with tracing enabled.
138// Note: This legacy macro is deprecated. It should not be used in new code.
139// If thread_id is different from current thread id, it will result into
140// DCHECK failure. This note is also applicable to `_COPY` and `_END`
141// variant of this macro.
142#define TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(category_group, name, id, \
143 thread_id, timestamp) \
144 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
145 TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
146 timestamp, TRACE_EVENT_FLAG_NONE)
147#define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0( \
148 category_group, name, id, thread_id, timestamp) \
149 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
150 TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
151 timestamp, TRACE_EVENT_FLAG_COPY)
152#define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP1( \
153 category_group, name, id, thread_id, timestamp, arg1_name, arg1_val) \
154 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
155 TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
156 timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
157#define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP2( \
158 category_group, name, id, thread_id, timestamp, arg1_name, arg1_val, \
159 arg2_name, arg2_val) \
160 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
161 TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
162 timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, \
163 arg2_val)
164
165// Records a single END event for "name" immediately. If the category
166// is not enabled, then this does nothing.
167// - category and name strings must have application lifetime (statics or
168// literals). They may not include " chars.
169#define TRACE_EVENT_END0(category_group, name) \
170 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
171 TRACE_EVENT_FLAG_NONE)
172#define TRACE_EVENT_END1(category_group, name, arg1_name, arg1_val) \
173 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
174 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
175#define TRACE_EVENT_END2(category_group, name, arg1_name, arg1_val, arg2_name, \
176 arg2_val) \
177 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
178 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, \
179 arg2_name, arg2_val)
180#define TRACE_EVENT_END_WITH_FLAGS0(category_group, name, flags) \
181 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, flags)
182#define TRACE_EVENT_END_WITH_FLAGS1(category_group, name, flags, arg1_name, \
183 arg1_val) \
184 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, flags, \
185 arg1_name, arg1_val)
186#define TRACE_EVENT_COPY_END2(category_group, name, arg1_name, arg1_val, \
187 arg2_name, arg2_val) \
188 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
189 TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
190 arg2_name, arg2_val)
191
192// Adds a trace event with the given |name| and |timestamp|. |timestamp| must be
193// non-null or it crashes. Use DCHECK(timestamp) before calling this to detect
194// an invalid timestamp even when tracing is not enabled, as the commit queue
195// doesn't run all tests with tracing enabled.
196#define TRACE_EVENT_MARK_WITH_TIMESTAMP0(category_group, name, timestamp) \
197 INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
198 TRACE_EVENT_PHASE_MARK, category_group, name, timestamp, \
199 TRACE_EVENT_FLAG_NONE)
200
201#define TRACE_EVENT_MARK_WITH_TIMESTAMP1(category_group, name, timestamp, \
202 arg1_name, arg1_val) \
203 INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
204 TRACE_EVENT_PHASE_MARK, category_group, name, timestamp, \
205 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
206
207#define TRACE_EVENT_MARK_WITH_TIMESTAMP2( \
208 category_group, name, timestamp, arg1_name, arg1_val, arg2_name, arg2_val) \
209 INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
210 TRACE_EVENT_PHASE_MARK, category_group, name, timestamp, \
211 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
212
213#define TRACE_EVENT_COPY_MARK(category_group, name) \
214 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_MARK, category_group, name, \
215 TRACE_EVENT_FLAG_COPY)
216
217#define TRACE_EVENT_COPY_MARK1(category_group, name, arg1_name, arg1_val) \
218 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_MARK, category_group, name, \
219 TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
220
221#define TRACE_EVENT_COPY_MARK_WITH_TIMESTAMP(category_group, name, timestamp) \
222 INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
223 TRACE_EVENT_PHASE_MARK, category_group, name, timestamp, \
224 TRACE_EVENT_FLAG_COPY)
225
226// Similar to TRACE_EVENT_ENDx but with a custom |timestamp| provided.
227// - |id| is used to match the _BEGIN event with the _END event.
228// Events are considered to match if their category_group, name and id values
229// all match. |id| must either be a pointer or an integer value up to 64 bits.
230// If it's a pointer, the bits will be xored with a hash of the process ID so
231// that the same pointer on two different processes will not collide.
232// - |timestamp| must be non-null or it crashes. Use DCHECK(timestamp) before
233// calling this to detect an invalid timestamp even when tracing is not
234// enabled, as the commit queue doesn't run all tests with tracing enabled.
235#define TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0(category_group, name, id, \
236 thread_id, timestamp) \
237 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
238 TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
239 timestamp, TRACE_EVENT_FLAG_NONE)
240#define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0( \
241 category_group, name, id, thread_id, timestamp) \
242 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
243 TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
244 timestamp, TRACE_EVENT_FLAG_COPY)
245#define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP1( \
246 category_group, name, id, thread_id, timestamp, arg1_name, arg1_val) \
247 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
248 TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
249 timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
250#define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP2( \
251 category_group, name, id, thread_id, timestamp, arg1_name, arg1_val, \
252 arg2_name, arg2_val) \
253 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
254 TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
255 timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, \
256 arg2_val)
257
258// Records the value of a counter called "name" immediately. Value
259// must be representable as a 32 bit integer.
260// - category and name strings must have application lifetime (statics or
261// literals). They may not include " chars.
262#define TRACE_COUNTER1(category_group, name, value) \
263 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
264 TRACE_EVENT_FLAG_NONE, "value", \
265 static_cast<int>(value))
266#define TRACE_COUNTER_WITH_FLAG1(category_group, name, flag, value) \
267 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
268 flag, "value", static_cast<int>(value))
269#define TRACE_COPY_COUNTER1(category_group, name, value) \
270 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
271 TRACE_EVENT_FLAG_COPY, "value", \
272 static_cast<int>(value))
273
274// Records the values of a multi-parted counter called "name" immediately.
275// The UI will treat value1 and value2 as parts of a whole, displaying their
276// values as a stacked-bar chart.
277// - category and name strings must have application lifetime (statics or
278// literals). They may not include " chars.
279#define TRACE_COUNTER2(category_group, name, value1_name, value1_val, \
280 value2_name, value2_val) \
281 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
282 TRACE_EVENT_FLAG_NONE, value1_name, \
283 static_cast<int>(value1_val), value2_name, \
284 static_cast<int>(value2_val))
285#define TRACE_COPY_COUNTER2(category_group, name, value1_name, value1_val, \
286 value2_name, value2_val) \
287 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
288 TRACE_EVENT_FLAG_COPY, value1_name, \
289 static_cast<int>(value1_val), value2_name, \
290 static_cast<int>(value2_val))
291
292// Similar to TRACE_COUNTERx, but with a custom |timestamp| provided.
293// - |timestamp| must be non-null or it crashes. Use DCHECK(timestamp) before
294// calling this to detect an invalid timestamp even when tracing is not
295// enabled, as the commit queue doesn't run all tests with tracing enabled.
296#define TRACE_COUNTER_WITH_TIMESTAMP1(category_group, name, timestamp, value) \
297 INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
298 TRACE_EVENT_PHASE_COUNTER, category_group, name, timestamp, \
299 TRACE_EVENT_FLAG_NONE, "value", static_cast<int>(value))
300
301#define TRACE_COUNTER_WITH_TIMESTAMP2(category_group, name, timestamp, \
302 value1_name, value1_val, value2_name, \
303 value2_val) \
304 INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
305 TRACE_EVENT_PHASE_COUNTER, category_group, name, timestamp, \
306 TRACE_EVENT_FLAG_NONE, value1_name, static_cast<int>(value1_val), \
307 value2_name, static_cast<int>(value2_val))
308
309// Records the value of a counter called "name" immediately. Value
310// must be representable as a 32 bit integer.
311// - category and name strings must have application lifetime (statics or
312// literals). They may not include " chars.
313// - |id| is used to disambiguate counters with the same name. It must either
314// be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
315// will be xored with a hash of the process ID so that the same pointer on
316// two different processes will not collide.
317#define TRACE_COUNTER_ID1(category_group, name, id, value) \
318 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
319 name, id, TRACE_EVENT_FLAG_NONE, "value", \
320 static_cast<int>(value))
321#define TRACE_COPY_COUNTER_ID1(category_group, name, id, value) \
322 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
323 name, id, TRACE_EVENT_FLAG_COPY, "value", \
324 static_cast<int>(value))
325
326// Records the values of a multi-parted counter called "name" immediately.
327// The UI will treat value1 and value2 as parts of a whole, displaying their
328// values as a stacked-bar chart.
329// - category and name strings must have application lifetime (statics or
330// literals). They may not include " chars.
331// - |id| is used to disambiguate counters with the same name. It must either
332// be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
333// will be xored with a hash of the process ID so that the same pointer on
334// two different processes will not collide.
335#define TRACE_COUNTER_ID2(category_group, name, id, value1_name, value1_val, \
336 value2_name, value2_val) \
337 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
338 name, id, TRACE_EVENT_FLAG_NONE, \
339 value1_name, static_cast<int>(value1_val), \
340 value2_name, static_cast<int>(value2_val))
341#define TRACE_COPY_COUNTER_ID2(category_group, name, id, value1_name, \
342 value1_val, value2_name, value2_val) \
343 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
344 name, id, TRACE_EVENT_FLAG_COPY, \
345 value1_name, static_cast<int>(value1_val), \
346 value2_name, static_cast<int>(value2_val))
347
348#define TRACE_EVENT_SAMPLE_WITH_ID1(category_group, name, id, arg1_name, \
349 arg1_val) \
350 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_SAMPLE, category_group, \
351 name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
352 arg1_val)
353
354// -- TRACE_EVENT_ASYNC is DEPRECATED! --
355//
356// TRACE_EVENT_ASYNC_* APIs should be only used by legacy code. New code should
357// use TRACE_EVENT_NESTABLE_ASYNC_* APIs instead.
358//
359// Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
360// associated arguments. If the category is not enabled, then this
361// does nothing.
362// - category and name strings must have application lifetime (statics or
363// literals). They may not include " chars.
364// - |id| is used to match the ASYNC_BEGIN event with the ASYNC_END event. ASYNC
365// events are considered to match if their category_group, name and id values
366// all match. |id| must either be a pointer or an integer value up to 64 bits.
367// If it's a pointer, the bits will be xored with a hash of the process ID so
368// that the same pointer on two different processes will not collide.
369//
370// An asynchronous operation can consist of multiple phases. The first phase is
371// defined by the ASYNC_BEGIN calls. Additional phases can be defined using the
372// ASYNC_STEP_INTO or ASYNC_STEP_PAST macros. The ASYNC_STEP_INTO macro will
373// annotate the block following the call. The ASYNC_STEP_PAST macro will
374// annotate the block prior to the call. Note that any particular event must use
375// only STEP_INTO or STEP_PAST macros; they can not mix and match. When the
376// operation completes, call ASYNC_END.
377//
378// An ASYNC trace typically occurs on a single thread (if not, they will only be
379// drawn on the thread defined in the ASYNC_BEGIN event), but all events in that
380// operation must use the same |name| and |id|. Each step can have its own
381// args.
382#define TRACE_EVENT_ASYNC_BEGIN0(category_group, name, id) \
383 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
384 category_group, name, id, \
385 TRACE_EVENT_FLAG_NONE)
386#define TRACE_EVENT_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
387 arg1_val) \
388 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
389 category_group, name, id, \
390 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
391#define TRACE_EVENT_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
392 arg1_val, arg2_name, arg2_val) \
393 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
394 TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
395 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
396#define TRACE_EVENT_COPY_ASYNC_BEGIN0(category_group, name, id) \
397 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
398 category_group, name, id, \
399 TRACE_EVENT_FLAG_COPY)
400#define TRACE_EVENT_COPY_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
401 arg1_val) \
402 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
403 category_group, name, id, \
404 TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
405#define TRACE_EVENT_COPY_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
406 arg1_val, arg2_name, arg2_val) \
407 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
408 TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
409 TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
410
411// Similar to TRACE_EVENT_ASYNC_BEGINx but with a custom |at| timestamp
412// provided.
413#define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, id, \
414 timestamp) \
415 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
416 TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
417 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
418#define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP1( \
419 category_group, name, id, timestamp, arg1_name, arg1_val) \
420 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
421 TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
422 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
423 arg1_name, arg1_val)
424#define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP2(category_group, name, id, \
425 timestamp, arg1_name, \
426 arg1_val, arg2_name, arg2_val) \
427 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
428 TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
429 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
430 arg1_name, arg1_val, arg2_name, arg2_val)
431#define TRACE_EVENT_COPY_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, id, \
432 timestamp) \
433 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
434 TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
435 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
436
437// Records a single ASYNC_STEP_INTO event for |step| immediately. If the
438// category is not enabled, then this does nothing. The |name| and |id| must
439// match the ASYNC_BEGIN event above. The |step| param identifies this step
440// within the async event. This should be called at the beginning of the next
441// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
442// ASYNC_STEP_PAST events.
443#define TRACE_EVENT_ASYNC_STEP_INTO0(category_group, name, id, step) \
444 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_INTO, \
445 category_group, name, id, \
446 TRACE_EVENT_FLAG_NONE, "step", step)
447#define TRACE_EVENT_ASYNC_STEP_INTO1(category_group, name, id, step, \
448 arg1_name, arg1_val) \
449 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
450 TRACE_EVENT_PHASE_ASYNC_STEP_INTO, category_group, name, id, \
451 TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
452
453// Similar to TRACE_EVENT_ASYNC_STEP_INTOx but with a custom |at| timestamp
454// provided.
455#define TRACE_EVENT_ASYNC_STEP_INTO_WITH_TIMESTAMP0(category_group, name, id, \
456 step, timestamp) \
457 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
458 TRACE_EVENT_PHASE_ASYNC_STEP_INTO, category_group, name, id, \
459 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
460 "step", step)
461
462// Records a single ASYNC_STEP_PAST event for |step| immediately. If the
463// category is not enabled, then this does nothing. The |name| and |id| must
464// match the ASYNC_BEGIN event above. The |step| param identifies this step
465// within the async event. This should be called at the beginning of the next
466// phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
467// ASYNC_STEP_INTO events.
468#define TRACE_EVENT_ASYNC_STEP_PAST0(category_group, name, id, step) \
469 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_PAST, \
470 category_group, name, id, \
471 TRACE_EVENT_FLAG_NONE, "step", step)
472#define TRACE_EVENT_ASYNC_STEP_PAST1(category_group, name, id, step, \
473 arg1_name, arg1_val) \
474 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
475 TRACE_EVENT_PHASE_ASYNC_STEP_PAST, category_group, name, id, \
476 TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
477
478// Records a single ASYNC_END event for "name" immediately. If the category
479// is not enabled, then this does nothing.
480#define TRACE_EVENT_ASYNC_END0(category_group, name, id) \
481 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
482 category_group, name, id, \
483 TRACE_EVENT_FLAG_NONE)
484#define TRACE_EVENT_ASYNC_END1(category_group, name, id, arg1_name, arg1_val) \
485 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
486 category_group, name, id, \
487 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
488#define TRACE_EVENT_ASYNC_END2(category_group, name, id, arg1_name, arg1_val, \
489 arg2_name, arg2_val) \
490 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
491 TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
492 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
493#define TRACE_EVENT_COPY_ASYNC_END0(category_group, name, id) \
494 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
495 category_group, name, id, \
496 TRACE_EVENT_FLAG_COPY)
497#define TRACE_EVENT_COPY_ASYNC_END1(category_group, name, id, arg1_name, \
498 arg1_val) \
499 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
500 category_group, name, id, \
501 TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
502#define TRACE_EVENT_COPY_ASYNC_END2(category_group, name, id, arg1_name, \
503 arg1_val, arg2_name, arg2_val) \
504 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
505 TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
506 TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
507
508// Similar to TRACE_EVENT_ASYNC_ENDx but with a custom |at| timestamp provided.
509#define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP0(category_group, name, id, \
510 timestamp) \
511 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
512 TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
513 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
514#define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP1(category_group, name, id, \
515 timestamp, arg1_name, arg1_val) \
516 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
517 TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
518 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
519 arg1_name, arg1_val)
520#define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP2(category_group, name, id, \
521 timestamp, arg1_name, arg1_val, \
522 arg2_name, arg2_val) \
523 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
524 TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
525 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
526 arg1_name, arg1_val, arg2_name, arg2_val)
527#define TRACE_EVENT_COPY_ASYNC_END_WITH_TIMESTAMP0(category_group, name, id, \
528 timestamp) \
529 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
530 TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
531 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
532
533// NESTABLE_ASYNC_* APIs are used to describe an async operation, which can
534// be nested within a NESTABLE_ASYNC event and/or have inner NESTABLE_ASYNC
535// events.
536// - category and name strings must have application lifetime (statics or
537// literals). They may not include " chars.
538// - A pair of NESTABLE_ASYNC_BEGIN event and NESTABLE_ASYNC_END event is
539// considered as a match if their category_group, name and id all match.
540// - |id| must either be a pointer or an integer value up to 64 bits.
541// If it's a pointer, the bits will be xored with a hash of the process ID so
542// that the same pointer on two different processes will not collide.
543// - |id| is used to match a child NESTABLE_ASYNC event with its parent
544// NESTABLE_ASYNC event. Therefore, events in the same nested event tree must
545// be logged using the same id and category_group.
546//
547// Unmatched NESTABLE_ASYNC_END event will be parsed as an event that starts
548// at the first NESTABLE_ASYNC event of that id, and unmatched
549// NESTABLE_ASYNC_BEGIN event will be parsed as an event that ends at the last
550// NESTABLE_ASYNC event of that id. Corresponding warning messages for
551// unmatched events will be shown in the analysis view.
552
553// Records a single NESTABLE_ASYNC_BEGIN event called "name" immediately, with
554// 0, 1 or 2 associated arguments. If the category is not enabled, then this
555// does nothing.
556#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(category_group, name, id) \
557 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
558 category_group, name, id, \
559 TRACE_EVENT_FLAG_NONE)
560#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
561 arg1_val) \
562 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
563 category_group, name, id, \
564 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
565#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
566 arg1_val, arg2_name, arg2_val) \
567 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
568 TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
569 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
570#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_FLAGS0(category_group, name, id, \
571 flags) \
572 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
573 category_group, name, id, flags)
574// Records a single NESTABLE_ASYNC_END event called "name" immediately, with 0
575// or 2 associated arguments. If the category is not enabled, then this does
576// nothing.
577#define TRACE_EVENT_NESTABLE_ASYNC_END0(category_group, name, id) \
578 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
579 category_group, name, id, \
580 TRACE_EVENT_FLAG_NONE)
581// Records a single NESTABLE_ASYNC_END event called "name" immediately, with 1
582// associated argument. If the category is not enabled, then this does nothing.
583#define TRACE_EVENT_NESTABLE_ASYNC_END1(category_group, name, id, arg1_name, \
584 arg1_val) \
585 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
586 category_group, name, id, \
587 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
588#define TRACE_EVENT_NESTABLE_ASYNC_END2(category_group, name, id, arg1_name, \
589 arg1_val, arg2_name, arg2_val) \
590 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
591 TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
592 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
593#define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_FLAGS0(category_group, name, id, \
594 flags) \
595 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
596 category_group, name, id, flags)
597
598// Records a single NESTABLE_ASYNC_INSTANT event called "name" immediately,
599// with none, one or two associated argument. If the category is not enabled,
600// then this does nothing.
601#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT0(category_group, name, id) \
602 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, \
603 category_group, name, id, \
604 TRACE_EVENT_FLAG_NONE)
605
606#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT1(category_group, name, id, \
607 arg1_name, arg1_val) \
608 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, \
609 category_group, name, id, \
610 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
611
612#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT2( \
613 category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
614 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
615 TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, category_group, name, id, \
616 TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
617
618#define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TTS2( \
619 category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
620 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
621 TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
622 TRACE_EVENT_FLAG_ASYNC_TTS | TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
623 arg2_name, arg2_val)
624#define TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TTS2( \
625 category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
626 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
627 TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
628 TRACE_EVENT_FLAG_ASYNC_TTS | TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
629 arg2_name, arg2_val)
630
631// Similar to TRACE_EVENT_NESTABLE_ASYNC_{BEGIN,END}x but with a custom
632// |timestamp| provided.
633#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, \
634 id, timestamp) \
635 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
636 TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
637 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
638#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP1( \
639 category_group, name, id, timestamp, arg1_name, arg1_val) \
640 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
641 TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
642 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
643 arg1_name, arg1_val)
644#define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP_AND_FLAGS0( \
645 category_group, name, id, timestamp, flags) \
646 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
647 TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
648 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, flags)
649#define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0(category_group, name, \
650 id, timestamp) \
651 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
652 TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
653 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
654#define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP1( \
655 category_group, name, id, timestamp, arg1_name, arg1_val) \
656 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
657 TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
658 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
659 arg1_name, arg1_val)
660#define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP2( \
661 category_group, name, id, timestamp, arg1_name, arg1_val, arg2_name, \
662 arg2_val) \
663 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
664 TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
665 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
666 arg1_name, arg1_val, arg2_name, arg2_val)
667#define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP_AND_FLAGS0( \
668 category_group, name, id, timestamp, flags) \
669 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
670 TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
671 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, flags)
672#define TRACE_EVENT_NESTABLE_ASYNC_INSTANT_WITH_TIMESTAMP0( \
673 category_group, name, id, timestamp) \
674 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
675 TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, category_group, name, id, \
676 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
677#define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN0(category_group, name, id) \
678 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
679 category_group, name, id, \
680 TRACE_EVENT_FLAG_COPY)
681#define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN1(category_group, name, id, \
682 arg1_name, arg1_val) \
683 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
684 category_group, name, id, \
685 TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
686#define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN2( \
687 category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
688 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
689 TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
690 TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
691#define TRACE_EVENT_COPY_NESTABLE_ASYNC_END0(category_group, name, id) \
692 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
693 category_group, name, id, \
694 TRACE_EVENT_FLAG_COPY)
695#define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0( \
696 category_group, name, id, timestamp) \
697 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
698 TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
699 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
700#define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP1( \
701 category_group, name, id, timestamp, arg1_name, arg1_val) \
702 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
703 TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
704 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY, \
705 arg1_name, arg1_val)
706#define TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( \
707 category_group, name, id, timestamp) \
708 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
709 TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
710 TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
711#define TRACE_EVENT_COPY_NESTABLE_ASYNC_END1(category_group, name, id, \
712 arg1_name, arg1_val) \
713 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
714 category_group, name, id, \
715 TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
716
717// TRACE_EVENT_METADATA* events are information related to other
718// injected events, not events in their own right.
719#define TRACE_EVENT_METADATA1(category_group, name, arg1_name, arg1_val) \
720 INTERNAL_TRACE_EVENT_METADATA_ADD(category_group, name, arg1_name, arg1_val)
721
722// Records a clock sync event.
723#define TRACE_EVENT_CLOCK_SYNC_RECEIVER(sync_id) \
724 INTERNAL_TRACE_EVENT_ADD( \
725 TRACE_EVENT_PHASE_CLOCK_SYNC, "__metadata", "clock_sync", \
726 TRACE_EVENT_FLAG_NONE, "sync_id", sync_id)
727#define TRACE_EVENT_CLOCK_SYNC_ISSUER(sync_id, issue_ts, issue_end_ts) \
728 INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
729 TRACE_EVENT_PHASE_CLOCK_SYNC, "__metadata", "clock_sync", \
730 issue_end_ts, TRACE_EVENT_FLAG_NONE, \
731 "sync_id", sync_id, "issue_ts", issue_ts)
732
733// Macros to track the life time and value of arbitrary client objects.
734// See also TraceTrackableObject.
735#define TRACE_EVENT_OBJECT_CREATED_WITH_ID(category_group, name, id) \
736 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
737 TRACE_EVENT_PHASE_CREATE_OBJECT, category_group, name, id, \
738 TRACE_EVENT_FLAG_NONE)
739
740#define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(category_group, name, id, \
741 snapshot) \
742 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
743 TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name, \
744 id, TRACE_EVENT_FLAG_NONE, "snapshot", snapshot)
745
746#define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID_AND_TIMESTAMP( \
747 category_group, name, id, timestamp, snapshot) \
748 INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
749 TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name, \
750 id, TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
751 "snapshot", snapshot)
752
753#define TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group, name, id) \
754 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
755 TRACE_EVENT_PHASE_DELETE_OBJECT, category_group, name, id, \
756 TRACE_EVENT_FLAG_NONE)
757
758// Macro to efficiently determine if a given category group is enabled.
759#define TRACE_EVENT_CATEGORY_GROUP_ENABLED(category_group, ret) \
760 do { \
761 INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
762 if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
763 *ret = true; \
764 } else { \
765 *ret = false; \
766 } \
767 } while (0)
768
769// Macro to efficiently determine, through polling, if a new trace has begun.
770#define TRACE_EVENT_IS_NEW_TRACE(ret) \
771 do { \
772 static int INTERNAL_TRACE_EVENT_UID(lastRecordingNumber) = 0; \
773 int num_traces_recorded = TRACE_EVENT_API_GET_NUM_TRACES_RECORDED(); \
774 if (num_traces_recorded != -1 && \
775 num_traces_recorded != \
776 INTERNAL_TRACE_EVENT_UID(lastRecordingNumber)) { \
777 INTERNAL_TRACE_EVENT_UID(lastRecordingNumber) = num_traces_recorded; \
778 *ret = true; \
779 } else { \
780 *ret = false; \
781 } \
782 } while (0)
783
784// Macro for getting the real base::TimeTicks::Now() which can be overridden in
785// headless when VirtualTime is enabled.
786#define TRACE_TIME_TICKS_NOW() INTERNAL_TRACE_TIME_TICKS_NOW()
787
788// Macro for getting the real base::Time::Now() which can be overridden in
789// headless when VirtualTime is enabled.
790#define TRACE_TIME_NOW() INTERNAL_TRACE_TIME_NOW()
791
792// Notes regarding the following definitions:
793// New values can be added and propagated to third party libraries, but existing
794// definitions must never be changed, because third party libraries may use old
795// definitions.
796
797// Phase indicates the nature of an event entry. E.g. part of a begin/end pair.
798#define TRACE_EVENT_PHASE_BEGIN ('B')
799#define TRACE_EVENT_PHASE_END ('E')
800#define TRACE_EVENT_PHASE_COMPLETE ('X')
801#define TRACE_EVENT_PHASE_INSTANT ('I')
802#define TRACE_EVENT_PHASE_ASYNC_BEGIN ('S')
803#define TRACE_EVENT_PHASE_ASYNC_STEP_INTO ('T')
804#define TRACE_EVENT_PHASE_ASYNC_STEP_PAST ('p')
805#define TRACE_EVENT_PHASE_ASYNC_END ('F')
806#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN ('b')
807#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_END ('e')
808#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT ('n')
809#define TRACE_EVENT_PHASE_FLOW_BEGIN ('s')
810#define TRACE_EVENT_PHASE_FLOW_STEP ('t')
811#define TRACE_EVENT_PHASE_FLOW_END ('f')
812#define TRACE_EVENT_PHASE_METADATA ('M')
813#define TRACE_EVENT_PHASE_COUNTER ('C')
814#define TRACE_EVENT_PHASE_SAMPLE ('P')
815#define TRACE_EVENT_PHASE_CREATE_OBJECT ('N')
816#define TRACE_EVENT_PHASE_SNAPSHOT_OBJECT ('O')
817#define TRACE_EVENT_PHASE_DELETE_OBJECT ('D')
818#define TRACE_EVENT_PHASE_MEMORY_DUMP ('v')
819#define TRACE_EVENT_PHASE_MARK ('R')
820#define TRACE_EVENT_PHASE_CLOCK_SYNC ('c')
821
822// Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
823#define TRACE_EVENT_FLAG_NONE (static_cast<unsigned int>(0))
824
825// Should not be used outside this file or
826// except `trace_event_impl.cc` (implementation details).
827// If used, it will result in CHECK failure in SDK build.
828#define TRACE_EVENT_FLAG_COPY (static_cast<unsigned int>(1 << 0))
829
830#define TRACE_EVENT_FLAG_HAS_ID (static_cast<unsigned int>(1 << 1))
831#define TRACE_EVENT_FLAG_SCOPE_OFFSET (static_cast<unsigned int>(1 << 2))
832#define TRACE_EVENT_FLAG_SCOPE_EXTRA (static_cast<unsigned int>(1 << 3))
833#define TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP (static_cast<unsigned int>(1 << 4))
834#define TRACE_EVENT_FLAG_ASYNC_TTS (static_cast<unsigned int>(1 << 5))
835#define TRACE_EVENT_FLAG_BIND_TO_ENCLOSING (static_cast<unsigned int>(1 << 6))
836#define TRACE_EVENT_FLAG_FLOW_IN (static_cast<unsigned int>(1 << 7))
837#define TRACE_EVENT_FLAG_FLOW_OUT (static_cast<unsigned int>(1 << 8))
838#define TRACE_EVENT_FLAG_HAS_CONTEXT_ID (static_cast<unsigned int>(1 << 9))
839#define TRACE_EVENT_FLAG_HAS_PROCESS_ID (static_cast<unsigned int>(1 << 10))
840#define TRACE_EVENT_FLAG_HAS_LOCAL_ID (static_cast<unsigned int>(1 << 11))
841#define TRACE_EVENT_FLAG_HAS_GLOBAL_ID (static_cast<unsigned int>(1 << 12))
842#define TRACE_EVENT_FLAG_JAVA_STRING_LITERALS \
843 (static_cast<unsigned int>(1 << 16))
844
845#define TRACE_EVENT_FLAG_SCOPE_MASK \
846 (static_cast<unsigned int>(TRACE_EVENT_FLAG_SCOPE_OFFSET | \
847 TRACE_EVENT_FLAG_SCOPE_EXTRA))
848
849// Type values for identifying types in the TraceValue union.
850#define TRACE_VALUE_TYPE_BOOL (static_cast<unsigned char>(1))
851#define TRACE_VALUE_TYPE_UINT (static_cast<unsigned char>(2))
852#define TRACE_VALUE_TYPE_INT (static_cast<unsigned char>(3))
853#define TRACE_VALUE_TYPE_DOUBLE (static_cast<unsigned char>(4))
854#define TRACE_VALUE_TYPE_POINTER (static_cast<unsigned char>(5))
855#define TRACE_VALUE_TYPE_STRING (static_cast<unsigned char>(6))
856#define TRACE_VALUE_TYPE_COPY_STRING (static_cast<unsigned char>(7))
857#define TRACE_VALUE_TYPE_CONVERTABLE (static_cast<unsigned char>(8))
858#define TRACE_VALUE_TYPE_PROTO (static_cast<unsigned char>(9))
859
860// Enum reflecting the scope of an INSTANT event. Must fit within
861// TRACE_EVENT_FLAG_SCOPE_MASK.
862#define TRACE_EVENT_SCOPE_GLOBAL (static_cast<unsigned char>(0 << 2))
863#define TRACE_EVENT_SCOPE_PROCESS (static_cast<unsigned char>(1 << 2))
864#define TRACE_EVENT_SCOPE_THREAD (static_cast<unsigned char>(2 << 2))
865
866#define TRACE_EVENT_SCOPE_NAME_GLOBAL ('g')
867#define TRACE_EVENT_SCOPE_NAME_PROCESS ('p')
868#define TRACE_EVENT_SCOPE_NAME_THREAD ('t')
869
870#endif // V8_TRACING_TRACE_EVENT_NO_PERFETTO_H_