trace_event_common.h 65 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135
  1. // Copyright 2015 The Chromium 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. #ifndef BASE_TRACE_EVENT_COMMON_TRACE_EVENT_COMMON_H_
  5. #define BASE_TRACE_EVENT_COMMON_TRACE_EVENT_COMMON_H_
  6. // Trace events are for tracking application performance and resource usage.
  7. // Macros are provided to track:
  8. // Begin and end of function calls
  9. // Counters
  10. //
  11. // Events are issued against categories. Whereas LOG's
  12. // categories are statically defined, TRACE categories are created
  13. // implicitly with a string. For example:
  14. // TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent",
  15. // TRACE_EVENT_SCOPE_THREAD)
  16. //
  17. // It is often the case that one trace may belong in multiple categories at the
  18. // same time. The first argument to the trace can be a comma-separated list of
  19. // categories, forming a category group, like:
  20. //
  21. // TRACE_EVENT_INSTANT0("input,views", "OnMouseOver", TRACE_EVENT_SCOPE_THREAD)
  22. //
  23. // We can enable/disable tracing of OnMouseOver by enabling/disabling either
  24. // category.
  25. //
  26. // Events can be INSTANT, or can be pairs of BEGIN and END in the same scope:
  27. // TRACE_EVENT_BEGIN0("MY_SUBSYSTEM", "SomethingCostly")
  28. // doSomethingCostly()
  29. // TRACE_EVENT_END0("MY_SUBSYSTEM", "SomethingCostly")
  30. // Note: our tools can't always determine the correct BEGIN/END pairs unless
  31. // these are used in the same scope. Use ASYNC_BEGIN/ASYNC_END macros if you
  32. // need them to be in separate scopes.
  33. //
  34. // A common use case is to trace entire function scopes. This
  35. // issues a trace BEGIN and END automatically:
  36. // void doSomethingCostly() {
  37. // TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly");
  38. // ...
  39. // }
  40. //
  41. // Additional parameters can be associated with an event:
  42. // void doSomethingCostly2(int howMuch) {
  43. // TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly",
  44. // "howMuch", howMuch);
  45. // ...
  46. // }
  47. //
  48. // The trace system will automatically add to this information the
  49. // current process id, thread id, and a timestamp in microseconds.
  50. //
  51. // To trace an asynchronous procedure such as an IPC send/receive, use
  52. // NESTABLE_ASYNC_BEGIN and NESTABLE_ASYNC_END:
  53. // [single threaded sender code]
  54. // static int send_count = 0;
  55. // ++send_count;
  56. // TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(
  57. // "ipc", "message", TRACE_ID_WITH_SCOPE("message", send_count));
  58. // Send(new MyMessage(send_count));
  59. // [receive code]
  60. // void OnMyMessage(send_count) {
  61. // TRACE_NESTABLE_EVENT_ASYNC_END0(
  62. // "ipc", "message", TRACE_ID_WITH_SCOPE("message", send_count));
  63. // }
  64. // The third parameter is a unique ID to match NESTABLE_ASYNC_BEGIN/ASYNC_END
  65. // pairs. NESTABLE_ASYNC_BEGIN and ASYNC_END can occur on any thread of any
  66. // traced process. // Pointers can be used for the ID parameter, and they will
  67. // be annotated internally so that the same pointer on two different processes
  68. // will not match. For example:
  69. // class MyTracedClass {
  70. // public:
  71. // MyTracedClass() {
  72. // TRACE_EVENT_NESTABLE_ASYNC_BEGIN0("category", "MyTracedClass",
  73. // TRACE_ID_LOCAL(this));
  74. // }
  75. // ~MyTracedClass() {
  76. // TRACE_EVENT_NESTABLE_ASYNC_END0("category", "MyTracedClass",
  77. // TRACE_ID_LOCAL(this));
  78. // }
  79. // }
  80. //
  81. // Trace event also supports counters, which is a way to track a quantity
  82. // as it varies over time. Counters are created with the following macro:
  83. // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue);
  84. //
  85. // Counters are process-specific. The macro itself can be issued from any
  86. // thread, however.
  87. //
  88. // Sometimes, you want to track two counters at once. You can do this with two
  89. // counter macros:
  90. // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]);
  91. // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]);
  92. // Or you can do it with a combined macro:
  93. // TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter",
  94. // "bytesPinned", g_myCounterValue[0],
  95. // "bytesAllocated", g_myCounterValue[1]);
  96. // This indicates to the tracing UI that these counters should be displayed
  97. // in a single graph, as a summed area chart.
  98. //
  99. // Since counters are in a global namespace, you may want to disambiguate with a
  100. // unique ID, by using the TRACE_COUNTER_ID* variations.
  101. //
  102. // By default, trace collection is compiled in, but turned off at runtime.
  103. // Collecting trace data is the responsibility of the embedding
  104. // application. In Chrome's case, navigating to about:tracing will turn on
  105. // tracing and display data collected across all active processes.
  106. //
  107. //
  108. // Memory scoping note:
  109. // Tracing copies the pointers, not the string content, of the strings passed
  110. // in for category_group, name, and arg_names. Thus, the following code will
  111. // cause problems:
  112. // char* str = strdup("importantName");
  113. // TRACE_EVENT_INSTANT0("SUBSYSTEM", str); // BAD!
  114. // free(str); // Trace system now has dangling pointer
  115. //
  116. // To avoid this issue with the |name| and |arg_name| parameters, use the
  117. // TRACE_EVENT_COPY_XXX overloads of the macros at additional runtime overhead.
  118. // Notes: The category must always be in a long-lived char* (i.e. static const).
  119. // The |arg_values|, when used, are always deep copied with the _COPY
  120. // macros.
  121. //
  122. // When are string argument values copied:
  123. // const char* arg_values are only referenced by default:
  124. // TRACE_EVENT1("category", "name",
  125. // "arg1", "literal string is only referenced");
  126. // Use TRACE_STR_COPY to force copying of a const char*:
  127. // TRACE_EVENT1("category", "name",
  128. // "arg1", TRACE_STR_COPY("string will be copied"));
  129. // std::string arg_values are always copied:
  130. // TRACE_EVENT1("category", "name",
  131. // "arg1", std::string("string will be copied"));
  132. //
  133. //
  134. // Convertable notes:
  135. // Converting a large data type to a string can be costly. To help with this,
  136. // the trace framework provides an interface ConvertableToTraceFormat. If you
  137. // inherit from it and implement the AppendAsTraceFormat method the trace
  138. // framework will call back to your object to convert a trace output time. This
  139. // means, if the category for the event is disabled, the conversion will not
  140. // happen.
  141. //
  142. // class MyData : public base::trace_event::ConvertableToTraceFormat {
  143. // public:
  144. // MyData() {}
  145. //
  146. // MyData(const MyData&) = delete;
  147. // MyData& operator=(const MyData&) = delete;
  148. //
  149. // void AppendAsTraceFormat(std::string* out) const override {
  150. // out->append("{\"foo\":1}");
  151. // }
  152. // private:
  153. // ~MyData() override {}
  154. // };
  155. //
  156. // TRACE_EVENT1("foo", "bar", "data",
  157. // std::unique_ptr<ConvertableToTraceFormat>(new MyData()));
  158. //
  159. // The trace framework will take ownership if the passed pointer and it will
  160. // be free'd when the trace buffer is flushed.
  161. //
  162. // Note, we only do the conversion when the buffer is flushed, so the provided
  163. // data object should not be modified after it's passed to the trace framework.
  164. //
  165. //
  166. // Thread Safety:
  167. // A thread safe singleton and mutex are used for thread safety. Category
  168. // enabled flags are used to limit the performance impact when the system
  169. // is not enabled.
  170. //
  171. // TRACE_EVENT macros first cache a pointer to a category. The categories are
  172. // statically allocated and safe at all times, even after exit. Fetching a
  173. // category is protected by the TraceLog::lock_. Multiple threads initializing
  174. // the static variable is safe, as they will be serialized by the lock and
  175. // multiple calls will return the same pointer to the category.
  176. //
  177. // Then the category_group_enabled flag is checked. This is a unsigned char, and
  178. // not intended to be multithread safe. It optimizes access to AddTraceEvent
  179. // which is threadsafe internally via TraceLog::lock_. The enabled flag may
  180. // cause some threads to incorrectly call or skip calling AddTraceEvent near
  181. // the time of the system being enabled or disabled. This is acceptable as
  182. // we tolerate some data loss while the system is being enabled/disabled and
  183. // because AddTraceEvent is threadsafe internally and checks the enabled state
  184. // again under lock.
  185. //
  186. // Without the use of these static category pointers and enabled flags all
  187. // trace points would carry a significant performance cost of acquiring a lock
  188. // and resolving the category.
  189. // There are currently two implementations of the tracing macros. Firstly,
  190. // Perfetto (https://perfetto.dev/) implements a compatible set of macros which
  191. // we are migrating to. The Perfetto implementation is enabled through the
  192. // use_perfetto_client_library GN arg. If that flag is disabled, we fall back to
  193. // the legacy implementation in the latter half of this file (and
  194. // trace_event.h).
  195. // TODO(skyostil): Remove the legacy macro implementation.
  196. // Normally we'd use BUILDFLAG(USE_PERFETTO_CLIENT_LIBRARY) for this, but
  197. // because v8 includes trace_event_common.h directly (in non-Perfetto mode), we
  198. // can't depend on any other header files here.
  199. #if defined(BASE_USE_PERFETTO_CLIENT_LIBRARY)
  200. ////////////////////////////////////////////////////////////////////////////////
  201. // Perfetto trace macros
  202. #include "base/threading/platform_thread.h"
  203. #include "base/time/time.h"
  204. #include "build/build_config.h"
  205. // Export Perfetto symbols in the same way as //base symbols.
  206. #define PERFETTO_COMPONENT_EXPORT BASE_EXPORT
  207. // Enable legacy trace event macros (e.g., TRACE_EVENT{0,1,2}).
  208. #define PERFETTO_ENABLE_LEGACY_TRACE_EVENTS 1
  209. // Macros for reading the current trace time (bypassing any virtual time
  210. // overrides).
  211. #define TRACE_TIME_TICKS_NOW() ::base::subtle::TimeTicksNowIgnoringOverride()
  212. #define TRACE_TIME_NOW() ::base::subtle::TimeNowIgnoringOverride()
  213. // Implementation detail: trace event macros create temporary variables
  214. // to keep instrumentation overhead low. These macros give each temporary
  215. // variable a unique name based on the line number to prevent name collisions.
  216. #define INTERNAL_TRACE_EVENT_UID(name_prefix) PERFETTO_UID(name_prefix)
  217. // Special trace event macro to trace log messages.
  218. // TODO(skyostil): Convert this into a regular typed trace event.
  219. #define TRACE_LOG_MESSAGE(file, message, line) \
  220. INTERNAL_TRACE_LOG_MESSAGE(file, message, line)
  221. // Declare debug annotation converters for base time types, so they can be
  222. // passed as trace event arguments.
  223. // TODO(skyostil): Serialize timestamps using perfetto::TracedValue instead.
  224. namespace perfetto {
  225. namespace protos {
  226. namespace pbzero {
  227. class DebugAnnotation;
  228. } // namespace pbzero
  229. } // namespace protos
  230. namespace internal {
  231. void BASE_EXPORT
  232. WriteDebugAnnotation(protos::pbzero::DebugAnnotation* annotation,
  233. ::base::TimeTicks);
  234. void BASE_EXPORT
  235. WriteDebugAnnotation(protos::pbzero::DebugAnnotation* annotation, ::base::Time);
  236. } // namespace internal
  237. } // namespace perfetto
  238. // Pull in the tracing macro definitions from Perfetto.
  239. #include "third_party/perfetto/include/perfetto/tracing.h"
  240. namespace perfetto {
  241. namespace legacy {
  242. template <>
  243. perfetto::ThreadTrack BASE_EXPORT
  244. ConvertThreadId(const ::base::PlatformThreadId& thread);
  245. #if BUILDFLAG(IS_WIN)
  246. template <>
  247. perfetto::ThreadTrack BASE_EXPORT ConvertThreadId(const int& thread);
  248. #endif // BUILDFLAG(IS_WIN)
  249. } // namespace legacy
  250. template <>
  251. struct BASE_EXPORT TraceTimestampTraits<::base::TimeTicks> {
  252. static TraceTimestamp ConvertTimestampToTraceTimeNs(
  253. const ::base::TimeTicks& ticks);
  254. };
  255. } // namespace perfetto
  256. #else // !defined(BASE_USE_PERFETTO_CLIENT_LIBRARY)
  257. ////////////////////////////////////////////////////////////////////////////////
  258. // Legacy trace macros
  259. // What follows is the legacy TRACE_EVENT macro implementation, which is being
  260. // replaced by the Perfetto-based implementation above. New projects wishing to
  261. // enable tracing should use the Perfetto SDK. See
  262. // https://perfetto.dev/docs/instrumentation/tracing-sdk.
  263. // Check that nobody includes this file directly. Clients are supposed to
  264. // include the surrounding "trace_event.h" of their project instead.
  265. #if defined(TRACE_EVENT0)
  266. #error "Another copy of this file has already been included."
  267. #endif
  268. // This will mark the trace event as disabled by default. The user will need
  269. // to explicitly enable the event.
  270. #define TRACE_DISABLED_BY_DEFAULT(name) "disabled-by-default-" name
  271. // Records a pair of begin and end events called "name" for the current
  272. // scope, with 0, 1 or 2 associated arguments. If the category is not
  273. // enabled, then this does nothing.
  274. // - category and name strings must have application lifetime (statics or
  275. // literals). They may not include " chars.
  276. #define TRACE_EVENT0(category_group, name) \
  277. INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name)
  278. #define TRACE_EVENT_WITH_FLOW0(category_group, name, bind_id, flow_flags) \
  279. INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
  280. flow_flags)
  281. #define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \
  282. INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val)
  283. #define TRACE_EVENT_WITH_FLOW1(category_group, name, bind_id, flow_flags, \
  284. arg1_name, arg1_val) \
  285. INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
  286. flow_flags, arg1_name, arg1_val)
  287. #define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, \
  288. arg2_val) \
  289. INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val, \
  290. arg2_name, arg2_val)
  291. #define TRACE_EVENT_WITH_FLOW2(category_group, name, bind_id, flow_flags, \
  292. arg1_name, arg1_val, arg2_name, arg2_val) \
  293. INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, bind_id, \
  294. flow_flags, arg1_name, arg1_val, \
  295. arg2_name, arg2_val)
  296. // Records a single event called "name" immediately, with 0, 1 or 2
  297. // associated arguments. If the category is not enabled, then this
  298. // does nothing.
  299. // - category and name strings must have application lifetime (statics or
  300. // literals). They may not include " chars.
  301. #define TRACE_EVENT_INSTANT0(category_group, name, scope) \
  302. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
  303. TRACE_EVENT_FLAG_NONE | scope)
  304. #define TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val) \
  305. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
  306. TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val)
  307. #define TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, \
  308. arg2_name, arg2_val) \
  309. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
  310. TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val, \
  311. arg2_name, arg2_val)
  312. #define TRACE_EVENT_COPY_INSTANT0(category_group, name, scope) \
  313. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
  314. TRACE_EVENT_FLAG_COPY | scope)
  315. #define TRACE_EVENT_COPY_INSTANT1(category_group, name, scope, arg1_name, \
  316. arg1_val) \
  317. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
  318. TRACE_EVENT_FLAG_COPY | scope, arg1_name, arg1_val)
  319. #define TRACE_EVENT_COPY_INSTANT2(category_group, name, scope, arg1_name, \
  320. arg1_val, arg2_name, arg2_val) \
  321. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
  322. TRACE_EVENT_FLAG_COPY | scope, arg1_name, arg1_val, \
  323. arg2_name, arg2_val)
  324. #define TRACE_EVENT_INSTANT_WITH_FLAGS0(category_group, name, scope_and_flags) \
  325. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
  326. scope_and_flags)
  327. #define TRACE_EVENT_INSTANT_WITH_FLAGS1(category_group, name, scope_and_flags, \
  328. arg1_name, arg1_val) \
  329. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
  330. scope_and_flags, arg1_name, arg1_val)
  331. #define TRACE_EVENT_INSTANT_WITH_TIMESTAMP0(category_group, name, scope, \
  332. timestamp) \
  333. INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
  334. TRACE_EVENT_PHASE_INSTANT, category_group, name, timestamp, \
  335. TRACE_EVENT_FLAG_NONE | scope)
  336. #define TRACE_EVENT_INSTANT_WITH_TIMESTAMP1(category_group, name, scope, \
  337. timestamp, arg_name, arg_val) \
  338. INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
  339. TRACE_EVENT_PHASE_INSTANT, category_group, name, timestamp, \
  340. TRACE_EVENT_FLAG_NONE | scope, arg_name, arg_val)
  341. // Records a single BEGIN event called "name" immediately, with 0, 1 or 2
  342. // associated arguments. If the category is not enabled, then this
  343. // does nothing.
  344. // - category and name strings must have application lifetime (statics or
  345. // literals). They may not include " chars.
  346. #define TRACE_EVENT_BEGIN0(category_group, name) \
  347. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
  348. TRACE_EVENT_FLAG_NONE)
  349. #define TRACE_EVENT_BEGIN1(category_group, name, arg1_name, arg1_val) \
  350. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
  351. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
  352. #define TRACE_EVENT_BEGIN2(category_group, name, arg1_name, arg1_val, \
  353. arg2_name, arg2_val) \
  354. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
  355. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, \
  356. arg2_name, arg2_val)
  357. #define TRACE_EVENT_BEGIN_WITH_FLAGS0(category_group, name, flags) \
  358. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, flags)
  359. #define TRACE_EVENT_BEGIN_WITH_FLAGS1(category_group, name, flags, arg1_name, \
  360. arg1_val) \
  361. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
  362. flags, arg1_name, arg1_val)
  363. #define TRACE_EVENT_COPY_BEGIN2(category_group, name, arg1_name, arg1_val, \
  364. arg2_name, arg2_val) \
  365. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category_group, name, \
  366. TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
  367. arg2_name, arg2_val)
  368. // Similar to TRACE_EVENT_BEGINx but with a custom |timestamp| provided.
  369. // - |id| is used to match the _BEGIN event with the _END event.
  370. // Events are considered to match if their category_group, name and id values
  371. // all match. |id| must either be a pointer or an integer value up to 64 bits.
  372. // If it's a pointer, the bits will be xored with a hash of the process ID so
  373. // that the same pointer on two different processes will not collide.
  374. // - |timestamp| must be non-null or it crashes. Use DCHECK(timestamp) before
  375. // calling this to detect an invalid timestamp even when tracing is not
  376. // enabled, as the commit queue doesn't run all tests with tracing enabled.
  377. #define TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(category_group, name, id, \
  378. thread_id, timestamp) \
  379. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  380. TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
  381. timestamp, TRACE_EVENT_FLAG_NONE)
  382. #define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0( \
  383. category_group, name, id, thread_id, timestamp) \
  384. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  385. TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
  386. timestamp, TRACE_EVENT_FLAG_COPY)
  387. #define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP1( \
  388. category_group, name, id, thread_id, timestamp, arg1_name, arg1_val) \
  389. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  390. TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
  391. timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
  392. #define TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP2( \
  393. category_group, name, id, thread_id, timestamp, arg1_name, arg1_val, \
  394. arg2_name, arg2_val) \
  395. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  396. TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, thread_id, \
  397. timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, \
  398. arg2_val)
  399. // Records a single END event for "name" immediately. If the category
  400. // is not enabled, then this does nothing.
  401. // - category and name strings must have application lifetime (statics or
  402. // literals). They may not include " chars.
  403. #define TRACE_EVENT_END0(category_group, name) \
  404. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
  405. TRACE_EVENT_FLAG_NONE)
  406. #define TRACE_EVENT_END1(category_group, name, arg1_name, arg1_val) \
  407. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
  408. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
  409. #define TRACE_EVENT_END2(category_group, name, arg1_name, arg1_val, arg2_name, \
  410. arg2_val) \
  411. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
  412. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, \
  413. arg2_name, arg2_val)
  414. #define TRACE_EVENT_END_WITH_FLAGS0(category_group, name, flags) \
  415. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, flags)
  416. #define TRACE_EVENT_END_WITH_FLAGS1(category_group, name, flags, arg1_name, \
  417. arg1_val) \
  418. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, flags, \
  419. arg1_name, arg1_val)
  420. #define TRACE_EVENT_COPY_END2(category_group, name, arg1_name, arg1_val, \
  421. arg2_name, arg2_val) \
  422. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category_group, name, \
  423. TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
  424. arg2_name, arg2_val)
  425. // Adds a trace event with the given |name| and |timestamp|. |timestamp| must be
  426. // non-null or it crashes. Use DCHECK(timestamp) before calling this to detect
  427. // an invalid timestamp even when tracing is not enabled, as the commit queue
  428. // doesn't run all tests with tracing enabled.
  429. #define TRACE_EVENT_MARK_WITH_TIMESTAMP0(category_group, name, timestamp) \
  430. INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
  431. TRACE_EVENT_PHASE_MARK, category_group, name, timestamp, \
  432. TRACE_EVENT_FLAG_NONE)
  433. #define TRACE_EVENT_MARK_WITH_TIMESTAMP1(category_group, name, timestamp, \
  434. arg1_name, arg1_val) \
  435. INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
  436. TRACE_EVENT_PHASE_MARK, category_group, name, timestamp, \
  437. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
  438. #define TRACE_EVENT_MARK_WITH_TIMESTAMP2( \
  439. category_group, name, timestamp, arg1_name, arg1_val, arg2_name, arg2_val) \
  440. INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
  441. TRACE_EVENT_PHASE_MARK, category_group, name, timestamp, \
  442. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
  443. #define TRACE_EVENT_COPY_MARK(category_group, name) \
  444. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_MARK, category_group, name, \
  445. TRACE_EVENT_FLAG_COPY)
  446. #define TRACE_EVENT_COPY_MARK1(category_group, name, arg1_name, arg1_val) \
  447. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_MARK, category_group, name, \
  448. TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
  449. #define TRACE_EVENT_COPY_MARK_WITH_TIMESTAMP(category_group, name, timestamp) \
  450. INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
  451. TRACE_EVENT_PHASE_MARK, category_group, name, timestamp, \
  452. TRACE_EVENT_FLAG_COPY)
  453. // Similar to TRACE_EVENT_ENDx but with a custom |timestamp| provided.
  454. // - |id| is used to match the _BEGIN event with the _END event.
  455. // Events are considered to match if their category_group, name and id values
  456. // all match. |id| must either be a pointer or an integer value up to 64 bits.
  457. // If it's a pointer, the bits will be xored with a hash of the process ID so
  458. // that the same pointer on two different processes will not collide.
  459. // - |timestamp| must be non-null or it crashes. Use DCHECK(timestamp) before
  460. // calling this to detect an invalid timestamp even when tracing is not
  461. // enabled, as the commit queue doesn't run all tests with tracing enabled.
  462. #define TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0(category_group, name, id, \
  463. thread_id, timestamp) \
  464. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  465. TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
  466. timestamp, TRACE_EVENT_FLAG_NONE)
  467. #define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0( \
  468. category_group, name, id, thread_id, timestamp) \
  469. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  470. TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
  471. timestamp, TRACE_EVENT_FLAG_COPY)
  472. #define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP1( \
  473. category_group, name, id, thread_id, timestamp, arg1_name, arg1_val) \
  474. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  475. TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
  476. timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
  477. #define TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP2( \
  478. category_group, name, id, thread_id, timestamp, arg1_name, arg1_val, \
  479. arg2_name, arg2_val) \
  480. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  481. TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, thread_id, \
  482. timestamp, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, \
  483. arg2_val)
  484. // Records the value of a counter called "name" immediately. Value
  485. // must be representable as a 32 bit integer.
  486. // - category and name strings must have application lifetime (statics or
  487. // literals). They may not include " chars.
  488. #define TRACE_COUNTER1(category_group, name, value) \
  489. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
  490. TRACE_EVENT_FLAG_NONE, "value", \
  491. static_cast<int>(value))
  492. #define TRACE_COUNTER_WITH_FLAG1(category_group, name, flag, value) \
  493. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
  494. flag, "value", static_cast<int>(value))
  495. #define TRACE_COPY_COUNTER1(category_group, name, value) \
  496. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
  497. TRACE_EVENT_FLAG_COPY, "value", \
  498. static_cast<int>(value))
  499. // Records the values of a multi-parted counter called "name" immediately.
  500. // The UI will treat value1 and value2 as parts of a whole, displaying their
  501. // values as a stacked-bar chart.
  502. // - category and name strings must have application lifetime (statics or
  503. // literals). They may not include " chars.
  504. #define TRACE_COUNTER2(category_group, name, value1_name, value1_val, \
  505. value2_name, value2_val) \
  506. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
  507. TRACE_EVENT_FLAG_NONE, value1_name, \
  508. static_cast<int>(value1_val), value2_name, \
  509. static_cast<int>(value2_val))
  510. #define TRACE_COPY_COUNTER2(category_group, name, value1_name, value1_val, \
  511. value2_name, value2_val) \
  512. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
  513. TRACE_EVENT_FLAG_COPY, value1_name, \
  514. static_cast<int>(value1_val), value2_name, \
  515. static_cast<int>(value2_val))
  516. // Similar to TRACE_COUNTERx, but with a custom |timestamp| provided.
  517. // - |timestamp| must be non-null or it crashes. Use DCHECK(timestamp) before
  518. // calling this to detect an invalid timestamp even when tracing is not
  519. // enabled, as the commit queue doesn't run all tests with tracing enabled.
  520. #define TRACE_COUNTER_WITH_TIMESTAMP1(category_group, name, timestamp, value) \
  521. INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
  522. TRACE_EVENT_PHASE_COUNTER, category_group, name, timestamp, \
  523. TRACE_EVENT_FLAG_NONE, "value", static_cast<int>(value))
  524. #define TRACE_COUNTER_WITH_TIMESTAMP2(category_group, name, timestamp, \
  525. value1_name, value1_val, value2_name, \
  526. value2_val) \
  527. INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
  528. TRACE_EVENT_PHASE_COUNTER, category_group, name, timestamp, \
  529. TRACE_EVENT_FLAG_NONE, value1_name, static_cast<int>(value1_val), \
  530. value2_name, static_cast<int>(value2_val))
  531. // Records the value of a counter called "name" immediately. Value
  532. // must be representable as a 32 bit integer.
  533. // - category and name strings must have application lifetime (statics or
  534. // literals). They may not include " chars.
  535. // - |id| is used to disambiguate counters with the same name. It must either
  536. // be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
  537. // will be xored with a hash of the process ID so that the same pointer on
  538. // two different processes will not collide.
  539. #define TRACE_COUNTER_ID1(category_group, name, id, value) \
  540. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
  541. name, id, TRACE_EVENT_FLAG_NONE, "value", \
  542. static_cast<int>(value))
  543. #define TRACE_COPY_COUNTER_ID1(category_group, name, id, value) \
  544. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
  545. name, id, TRACE_EVENT_FLAG_COPY, "value", \
  546. static_cast<int>(value))
  547. // Records the values of a multi-parted counter called "name" immediately.
  548. // The UI will treat value1 and value2 as parts of a whole, displaying their
  549. // values as a stacked-bar chart.
  550. // - category and name strings must have application lifetime (statics or
  551. // literals). They may not include " chars.
  552. // - |id| is used to disambiguate counters with the same name. It must either
  553. // be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
  554. // will be xored with a hash of the process ID so that the same pointer on
  555. // two different processes will not collide.
  556. #define TRACE_COUNTER_ID2(category_group, name, id, value1_name, value1_val, \
  557. value2_name, value2_val) \
  558. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
  559. name, id, TRACE_EVENT_FLAG_NONE, \
  560. value1_name, static_cast<int>(value1_val), \
  561. value2_name, static_cast<int>(value2_val))
  562. #define TRACE_COPY_COUNTER_ID2(category_group, name, id, value1_name, \
  563. value1_val, value2_name, value2_val) \
  564. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category_group, \
  565. name, id, TRACE_EVENT_FLAG_COPY, \
  566. value1_name, static_cast<int>(value1_val), \
  567. value2_name, static_cast<int>(value2_val))
  568. #define TRACE_EVENT_SAMPLE_WITH_ID1(category_group, name, id, arg1_name, \
  569. arg1_val) \
  570. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_SAMPLE, category_group, \
  571. name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
  572. arg1_val)
  573. // -- TRACE_EVENT_ASYNC is DEPRECATED! --
  574. //
  575. // TRACE_EVENT_ASYNC_* APIs should be only used by legacy code. New code should
  576. // use TRACE_EVENT_NESTABLE_ASYNC_* APIs instead.
  577. //
  578. // Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
  579. // associated arguments. If the category is not enabled, then this
  580. // does nothing.
  581. // - category and name strings must have application lifetime (statics or
  582. // literals). They may not include " chars.
  583. // - |id| is used to match the ASYNC_BEGIN event with the ASYNC_END event. ASYNC
  584. // events are considered to match if their category_group, name and id values
  585. // all match. |id| must either be a pointer or an integer value up to 64 bits.
  586. // If it's a pointer, the bits will be xored with a hash of the process ID so
  587. // that the same pointer on two different processes will not collide.
  588. //
  589. // An asynchronous operation can consist of multiple phases. The first phase is
  590. // defined by the ASYNC_BEGIN calls. Additional phases can be defined using the
  591. // ASYNC_STEP_INTO or ASYNC_STEP_PAST macros. The ASYNC_STEP_INTO macro will
  592. // annotate the block following the call. The ASYNC_STEP_PAST macro will
  593. // annotate the block prior to the call. Note that any particular event must use
  594. // only STEP_INTO or STEP_PAST macros; they can not mix and match. When the
  595. // operation completes, call ASYNC_END.
  596. //
  597. // An ASYNC trace typically occurs on a single thread (if not, they will only be
  598. // drawn on the thread defined in the ASYNC_BEGIN event), but all events in that
  599. // operation must use the same |name| and |id|. Each step can have its own
  600. // args.
  601. #define TRACE_EVENT_ASYNC_BEGIN0(category_group, name, id) \
  602. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
  603. category_group, name, id, \
  604. TRACE_EVENT_FLAG_NONE)
  605. #define TRACE_EVENT_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
  606. arg1_val) \
  607. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
  608. category_group, name, id, \
  609. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
  610. #define TRACE_EVENT_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
  611. arg1_val, arg2_name, arg2_val) \
  612. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  613. TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
  614. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
  615. #define TRACE_EVENT_COPY_ASYNC_BEGIN0(category_group, name, id) \
  616. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
  617. category_group, name, id, \
  618. TRACE_EVENT_FLAG_COPY)
  619. #define TRACE_EVENT_COPY_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
  620. arg1_val) \
  621. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
  622. category_group, name, id, \
  623. TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
  624. #define TRACE_EVENT_COPY_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
  625. arg1_val, arg2_name, arg2_val) \
  626. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  627. TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
  628. TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
  629. // Similar to TRACE_EVENT_ASYNC_BEGINx but with a custom |at| timestamp
  630. // provided.
  631. #define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, id, \
  632. timestamp) \
  633. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  634. TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
  635. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
  636. #define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP1( \
  637. category_group, name, id, timestamp, arg1_name, arg1_val) \
  638. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  639. TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
  640. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
  641. arg1_name, arg1_val)
  642. #define TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP2(category_group, name, id, \
  643. timestamp, arg1_name, \
  644. arg1_val, arg2_name, arg2_val) \
  645. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  646. TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
  647. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
  648. arg1_name, arg1_val, arg2_name, arg2_val)
  649. #define TRACE_EVENT_COPY_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, id, \
  650. timestamp) \
  651. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  652. TRACE_EVENT_PHASE_ASYNC_BEGIN, category_group, name, id, \
  653. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
  654. // Records a single ASYNC_STEP_INTO event for |step| immediately. If the
  655. // category is not enabled, then this does nothing. The |name| and |id| must
  656. // match the ASYNC_BEGIN event above. The |step| param identifies this step
  657. // within the async event. This should be called at the beginning of the next
  658. // phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
  659. // ASYNC_STEP_PAST events.
  660. #define TRACE_EVENT_ASYNC_STEP_INTO0(category_group, name, id, step) \
  661. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_INTO, \
  662. category_group, name, id, \
  663. TRACE_EVENT_FLAG_NONE, "step", step)
  664. #define TRACE_EVENT_ASYNC_STEP_INTO1(category_group, name, id, step, \
  665. arg1_name, arg1_val) \
  666. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  667. TRACE_EVENT_PHASE_ASYNC_STEP_INTO, category_group, name, id, \
  668. TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
  669. // Similar to TRACE_EVENT_ASYNC_STEP_INTOx but with a custom |at| timestamp
  670. // provided.
  671. #define TRACE_EVENT_ASYNC_STEP_INTO_WITH_TIMESTAMP0(category_group, name, id, \
  672. step, timestamp) \
  673. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  674. TRACE_EVENT_PHASE_ASYNC_STEP_INTO, category_group, name, id, \
  675. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
  676. "step", step)
  677. // Records a single ASYNC_STEP_PAST event for |step| immediately. If the
  678. // category is not enabled, then this does nothing. The |name| and |id| must
  679. // match the ASYNC_BEGIN event above. The |step| param identifies this step
  680. // within the async event. This should be called at the beginning of the next
  681. // phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
  682. // ASYNC_STEP_INTO events.
  683. #define TRACE_EVENT_ASYNC_STEP_PAST0(category_group, name, id, step) \
  684. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_PAST, \
  685. category_group, name, id, \
  686. TRACE_EVENT_FLAG_NONE, "step", step)
  687. #define TRACE_EVENT_ASYNC_STEP_PAST1(category_group, name, id, step, \
  688. arg1_name, arg1_val) \
  689. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  690. TRACE_EVENT_PHASE_ASYNC_STEP_PAST, category_group, name, id, \
  691. TRACE_EVENT_FLAG_NONE, "step", step, arg1_name, arg1_val)
  692. // Records a single ASYNC_END event for "name" immediately. If the category
  693. // is not enabled, then this does nothing.
  694. #define TRACE_EVENT_ASYNC_END0(category_group, name, id) \
  695. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
  696. category_group, name, id, \
  697. TRACE_EVENT_FLAG_NONE)
  698. #define TRACE_EVENT_ASYNC_END1(category_group, name, id, arg1_name, arg1_val) \
  699. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
  700. category_group, name, id, \
  701. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
  702. #define TRACE_EVENT_ASYNC_END2(category_group, name, id, arg1_name, arg1_val, \
  703. arg2_name, arg2_val) \
  704. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  705. TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
  706. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
  707. #define TRACE_EVENT_COPY_ASYNC_END0(category_group, name, id) \
  708. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
  709. category_group, name, id, \
  710. TRACE_EVENT_FLAG_COPY)
  711. #define TRACE_EVENT_COPY_ASYNC_END1(category_group, name, id, arg1_name, \
  712. arg1_val) \
  713. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
  714. category_group, name, id, \
  715. TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
  716. #define TRACE_EVENT_COPY_ASYNC_END2(category_group, name, id, arg1_name, \
  717. arg1_val, arg2_name, arg2_val) \
  718. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  719. TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
  720. TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
  721. // Similar to TRACE_EVENT_ASYNC_ENDx but with a custom |at| timestamp provided.
  722. #define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP0(category_group, name, id, \
  723. timestamp) \
  724. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  725. TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
  726. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
  727. #define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP1(category_group, name, id, \
  728. timestamp, arg1_name, arg1_val) \
  729. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  730. TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
  731. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
  732. arg1_name, arg1_val)
  733. #define TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP2(category_group, name, id, \
  734. timestamp, arg1_name, arg1_val, \
  735. arg2_name, arg2_val) \
  736. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  737. TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
  738. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
  739. arg1_name, arg1_val, arg2_name, arg2_val)
  740. #define TRACE_EVENT_COPY_ASYNC_END_WITH_TIMESTAMP0(category_group, name, id, \
  741. timestamp) \
  742. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  743. TRACE_EVENT_PHASE_ASYNC_END, category_group, name, id, \
  744. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
  745. // NESTABLE_ASYNC_* APIs are used to describe an async operation, which can
  746. // be nested within a NESTABLE_ASYNC event and/or have inner NESTABLE_ASYNC
  747. // events.
  748. // - category and name strings must have application lifetime (statics or
  749. // literals). They may not include " chars.
  750. // - A pair of NESTABLE_ASYNC_BEGIN event and NESTABLE_ASYNC_END event is
  751. // considered as a match if their category_group, name and id all match.
  752. // - |id| must either be a pointer or an integer value up to 64 bits.
  753. // If it's a pointer, the bits will be xored with a hash of the process ID so
  754. // that the same pointer on two different processes will not collide.
  755. // - |id| is used to match a child NESTABLE_ASYNC event with its parent
  756. // NESTABLE_ASYNC event. Therefore, events in the same nested event tree must
  757. // be logged using the same id and category_group.
  758. //
  759. // Unmatched NESTABLE_ASYNC_END event will be parsed as an event that starts
  760. // at the first NESTABLE_ASYNC event of that id, and unmatched
  761. // NESTABLE_ASYNC_BEGIN event will be parsed as an event that ends at the last
  762. // NESTABLE_ASYNC event of that id. Corresponding warning messages for
  763. // unmatched events will be shown in the analysis view.
  764. // Records a single NESTABLE_ASYNC_BEGIN event called "name" immediately, with
  765. // 0, 1 or 2 associated arguments. If the category is not enabled, then this
  766. // does nothing.
  767. #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(category_group, name, id) \
  768. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
  769. category_group, name, id, \
  770. TRACE_EVENT_FLAG_NONE)
  771. #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(category_group, name, id, arg1_name, \
  772. arg1_val) \
  773. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
  774. category_group, name, id, \
  775. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
  776. #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(category_group, name, id, arg1_name, \
  777. arg1_val, arg2_name, arg2_val) \
  778. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  779. TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
  780. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
  781. #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_FLAGS0(category_group, name, id, \
  782. flags) \
  783. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
  784. category_group, name, id, flags)
  785. // Records a single NESTABLE_ASYNC_END event called "name" immediately, with 0
  786. // or 2 associated arguments. If the category is not enabled, then this does
  787. // nothing.
  788. #define TRACE_EVENT_NESTABLE_ASYNC_END0(category_group, name, id) \
  789. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
  790. category_group, name, id, \
  791. TRACE_EVENT_FLAG_NONE)
  792. // Records a single NESTABLE_ASYNC_END event called "name" immediately, with 1
  793. // associated argument. If the category is not enabled, then this does nothing.
  794. #define TRACE_EVENT_NESTABLE_ASYNC_END1(category_group, name, id, arg1_name, \
  795. arg1_val) \
  796. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
  797. category_group, name, id, \
  798. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
  799. #define TRACE_EVENT_NESTABLE_ASYNC_END2(category_group, name, id, arg1_name, \
  800. arg1_val, arg2_name, arg2_val) \
  801. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  802. TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
  803. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
  804. #define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_FLAGS0(category_group, name, id, \
  805. flags) \
  806. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
  807. category_group, name, id, flags)
  808. // Records a single NESTABLE_ASYNC_INSTANT event called "name" immediately,
  809. // with none, one or two associated argument. If the category is not enabled,
  810. // then this does nothing.
  811. #define TRACE_EVENT_NESTABLE_ASYNC_INSTANT0(category_group, name, id) \
  812. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, \
  813. category_group, name, id, \
  814. TRACE_EVENT_FLAG_NONE)
  815. #define TRACE_EVENT_NESTABLE_ASYNC_INSTANT1(category_group, name, id, \
  816. arg1_name, arg1_val) \
  817. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, \
  818. category_group, name, id, \
  819. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
  820. #define TRACE_EVENT_NESTABLE_ASYNC_INSTANT2( \
  821. category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
  822. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  823. TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, category_group, name, id, \
  824. TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
  825. #define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TTS2( \
  826. category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
  827. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  828. TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
  829. TRACE_EVENT_FLAG_ASYNC_TTS | TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
  830. arg2_name, arg2_val)
  831. #define TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TTS2( \
  832. category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
  833. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  834. TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
  835. TRACE_EVENT_FLAG_ASYNC_TTS | TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
  836. arg2_name, arg2_val)
  837. // Similar to TRACE_EVENT_NESTABLE_ASYNC_{BEGIN,END}x but with a custom
  838. // |timestamp| provided.
  839. #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0(category_group, name, \
  840. id, timestamp) \
  841. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  842. TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
  843. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
  844. #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP1( \
  845. category_group, name, id, timestamp, arg1_name, arg1_val) \
  846. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  847. TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
  848. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
  849. arg1_name, arg1_val)
  850. #define TRACE_EVENT_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP_AND_FLAGS0( \
  851. category_group, name, id, timestamp, flags) \
  852. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  853. TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
  854. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, flags)
  855. #define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP0(category_group, name, \
  856. id, timestamp) \
  857. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  858. TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
  859. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
  860. #define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP1( \
  861. category_group, name, id, timestamp, arg1_name, arg1_val) \
  862. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  863. TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
  864. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
  865. arg1_name, arg1_val)
  866. #define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP2( \
  867. category_group, name, id, timestamp, arg1_name, arg1_val, arg2_name, \
  868. arg2_val) \
  869. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  870. TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
  871. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
  872. arg1_name, arg1_val, arg2_name, arg2_val)
  873. #define TRACE_EVENT_NESTABLE_ASYNC_END_WITH_TIMESTAMP_AND_FLAGS0( \
  874. category_group, name, id, timestamp, flags) \
  875. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  876. TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
  877. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, flags)
  878. #define TRACE_EVENT_NESTABLE_ASYNC_INSTANT_WITH_TIMESTAMP0( \
  879. category_group, name, id, timestamp) \
  880. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  881. TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT, category_group, name, id, \
  882. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE)
  883. #define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN0(category_group, name, id) \
  884. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
  885. category_group, name, id, \
  886. TRACE_EVENT_FLAG_COPY)
  887. #define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN1(category_group, name, id, \
  888. arg1_name, arg1_val) \
  889. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, \
  890. category_group, name, id, \
  891. TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
  892. #define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN2( \
  893. category_group, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
  894. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  895. TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
  896. TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, arg2_name, arg2_val)
  897. #define TRACE_EVENT_COPY_NESTABLE_ASYNC_END0(category_group, name, id) \
  898. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
  899. category_group, name, id, \
  900. TRACE_EVENT_FLAG_COPY)
  901. #define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP0( \
  902. category_group, name, id, timestamp) \
  903. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  904. TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
  905. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
  906. #define TRACE_EVENT_COPY_NESTABLE_ASYNC_BEGIN_WITH_TIMESTAMP1( \
  907. category_group, name, id, timestamp, arg1_name, arg1_val) \
  908. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  909. TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN, category_group, name, id, \
  910. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY, \
  911. arg1_name, arg1_val)
  912. #define TRACE_EVENT_COPY_NESTABLE_ASYNC_END_WITH_TIMESTAMP0( \
  913. category_group, name, id, timestamp) \
  914. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  915. TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, category_group, name, id, \
  916. TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_COPY)
  917. #define TRACE_EVENT_COPY_NESTABLE_ASYNC_END1(category_group, name, id, \
  918. arg1_name, arg1_val) \
  919. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_NESTABLE_ASYNC_END, \
  920. category_group, name, id, \
  921. TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
  922. // Special trace event macro to trace log messages.
  923. #define TRACE_LOG_MESSAGE(file, message, line) \
  924. INTERNAL_TRACE_LOG_MESSAGE(file, message, line)
  925. // TRACE_EVENT_METADATA* events are information related to other
  926. // injected events, not events in their own right.
  927. #define TRACE_EVENT_METADATA1(category_group, name, arg1_name, arg1_val) \
  928. INTERNAL_TRACE_EVENT_METADATA_ADD(category_group, name, arg1_name, arg1_val)
  929. // Records a clock sync event.
  930. #define TRACE_EVENT_CLOCK_SYNC_RECEIVER(sync_id) \
  931. INTERNAL_TRACE_EVENT_ADD( \
  932. TRACE_EVENT_PHASE_CLOCK_SYNC, "__metadata", "clock_sync", \
  933. TRACE_EVENT_FLAG_NONE, "sync_id", sync_id)
  934. #define TRACE_EVENT_CLOCK_SYNC_ISSUER(sync_id, issue_ts, issue_end_ts) \
  935. INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP( \
  936. TRACE_EVENT_PHASE_CLOCK_SYNC, "__metadata", "clock_sync", \
  937. issue_end_ts, TRACE_EVENT_FLAG_NONE, \
  938. "sync_id", sync_id, "issue_ts", issue_ts)
  939. // Macros to track the life time and value of arbitrary client objects.
  940. // See also TraceTrackableObject.
  941. #define TRACE_EVENT_OBJECT_CREATED_WITH_ID(category_group, name, id) \
  942. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  943. TRACE_EVENT_PHASE_CREATE_OBJECT, category_group, name, id, \
  944. TRACE_EVENT_FLAG_NONE)
  945. #define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(category_group, name, id, \
  946. snapshot) \
  947. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  948. TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name, \
  949. id, TRACE_EVENT_FLAG_NONE, "snapshot", snapshot)
  950. #define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID_AND_TIMESTAMP( \
  951. category_group, name, id, timestamp, snapshot) \
  952. INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
  953. TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name, \
  954. id, TRACE_EVENT_API_CURRENT_THREAD_ID, timestamp, TRACE_EVENT_FLAG_NONE, \
  955. "snapshot", snapshot)
  956. #define TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group, name, id) \
  957. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  958. TRACE_EVENT_PHASE_DELETE_OBJECT, category_group, name, id, \
  959. TRACE_EVENT_FLAG_NONE)
  960. // Macro to efficiently determine if a given category group is enabled.
  961. #define TRACE_EVENT_CATEGORY_GROUP_ENABLED(category_group, ret) \
  962. do { \
  963. INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
  964. if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
  965. *ret = true; \
  966. } else { \
  967. *ret = false; \
  968. } \
  969. } while (0)
  970. // Macro to efficiently determine, through polling, if a new trace has begun.
  971. #define TRACE_EVENT_IS_NEW_TRACE(ret) \
  972. do { \
  973. static int INTERNAL_TRACE_EVENT_UID(lastRecordingNumber) = 0; \
  974. int num_traces_recorded = TRACE_EVENT_API_GET_NUM_TRACES_RECORDED(); \
  975. if (num_traces_recorded != -1 && \
  976. num_traces_recorded != \
  977. INTERNAL_TRACE_EVENT_UID(lastRecordingNumber)) { \
  978. INTERNAL_TRACE_EVENT_UID(lastRecordingNumber) = num_traces_recorded; \
  979. *ret = true; \
  980. } else { \
  981. *ret = false; \
  982. } \
  983. } while (0)
  984. // Macro for getting the real base::TimeTicks::Now() which can be overridden in
  985. // headless when VirtualTime is enabled.
  986. #define TRACE_TIME_TICKS_NOW() INTERNAL_TRACE_TIME_TICKS_NOW()
  987. // Macro for getting the real base::Time::Now() which can be overridden in
  988. // headless when VirtualTime is enabled.
  989. #define TRACE_TIME_NOW() INTERNAL_TRACE_TIME_NOW()
  990. // Notes regarding the following definitions:
  991. // New values can be added and propagated to third party libraries, but existing
  992. // definitions must never be changed, because third party libraries may use old
  993. // definitions.
  994. // Phase indicates the nature of an event entry. E.g. part of a begin/end pair.
  995. #define TRACE_EVENT_PHASE_BEGIN ('B')
  996. #define TRACE_EVENT_PHASE_END ('E')
  997. #define TRACE_EVENT_PHASE_COMPLETE ('X')
  998. #define TRACE_EVENT_PHASE_INSTANT ('I')
  999. #define TRACE_EVENT_PHASE_ASYNC_BEGIN ('S')
  1000. #define TRACE_EVENT_PHASE_ASYNC_STEP_INTO ('T')
  1001. #define TRACE_EVENT_PHASE_ASYNC_STEP_PAST ('p')
  1002. #define TRACE_EVENT_PHASE_ASYNC_END ('F')
  1003. #define TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN ('b')
  1004. #define TRACE_EVENT_PHASE_NESTABLE_ASYNC_END ('e')
  1005. #define TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT ('n')
  1006. #define TRACE_EVENT_PHASE_FLOW_BEGIN ('s')
  1007. #define TRACE_EVENT_PHASE_FLOW_STEP ('t')
  1008. #define TRACE_EVENT_PHASE_FLOW_END ('f')
  1009. #define TRACE_EVENT_PHASE_METADATA ('M')
  1010. #define TRACE_EVENT_PHASE_COUNTER ('C')
  1011. #define TRACE_EVENT_PHASE_SAMPLE ('P')
  1012. #define TRACE_EVENT_PHASE_CREATE_OBJECT ('N')
  1013. #define TRACE_EVENT_PHASE_SNAPSHOT_OBJECT ('O')
  1014. #define TRACE_EVENT_PHASE_DELETE_OBJECT ('D')
  1015. #define TRACE_EVENT_PHASE_MEMORY_DUMP ('v')
  1016. #define TRACE_EVENT_PHASE_MARK ('R')
  1017. #define TRACE_EVENT_PHASE_CLOCK_SYNC ('c')
  1018. // Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
  1019. #define TRACE_EVENT_FLAG_NONE (static_cast<unsigned int>(0))
  1020. #define TRACE_EVENT_FLAG_COPY (static_cast<unsigned int>(1 << 0))
  1021. #define TRACE_EVENT_FLAG_HAS_ID (static_cast<unsigned int>(1 << 1))
  1022. #define TRACE_EVENT_FLAG_SCOPE_OFFSET (static_cast<unsigned int>(1 << 2))
  1023. #define TRACE_EVENT_FLAG_SCOPE_EXTRA (static_cast<unsigned int>(1 << 3))
  1024. #define TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP (static_cast<unsigned int>(1 << 4))
  1025. #define TRACE_EVENT_FLAG_ASYNC_TTS (static_cast<unsigned int>(1 << 5))
  1026. #define TRACE_EVENT_FLAG_BIND_TO_ENCLOSING (static_cast<unsigned int>(1 << 6))
  1027. #define TRACE_EVENT_FLAG_FLOW_IN (static_cast<unsigned int>(1 << 7))
  1028. #define TRACE_EVENT_FLAG_FLOW_OUT (static_cast<unsigned int>(1 << 8))
  1029. #define TRACE_EVENT_FLAG_HAS_CONTEXT_ID (static_cast<unsigned int>(1 << 9))
  1030. #define TRACE_EVENT_FLAG_HAS_PROCESS_ID (static_cast<unsigned int>(1 << 10))
  1031. #define TRACE_EVENT_FLAG_HAS_LOCAL_ID (static_cast<unsigned int>(1 << 11))
  1032. #define TRACE_EVENT_FLAG_HAS_GLOBAL_ID (static_cast<unsigned int>(1 << 12))
  1033. #define TRACE_EVENT_FLAG_JAVA_STRING_LITERALS \
  1034. (static_cast<unsigned int>(1 << 16))
  1035. #define TRACE_EVENT_FLAG_SCOPE_MASK \
  1036. (static_cast<unsigned int>(TRACE_EVENT_FLAG_SCOPE_OFFSET | \
  1037. TRACE_EVENT_FLAG_SCOPE_EXTRA))
  1038. // Type values for identifying types in the TraceValue union.
  1039. #define TRACE_VALUE_TYPE_BOOL (static_cast<unsigned char>(1))
  1040. #define TRACE_VALUE_TYPE_UINT (static_cast<unsigned char>(2))
  1041. #define TRACE_VALUE_TYPE_INT (static_cast<unsigned char>(3))
  1042. #define TRACE_VALUE_TYPE_DOUBLE (static_cast<unsigned char>(4))
  1043. #define TRACE_VALUE_TYPE_POINTER (static_cast<unsigned char>(5))
  1044. #define TRACE_VALUE_TYPE_STRING (static_cast<unsigned char>(6))
  1045. #define TRACE_VALUE_TYPE_COPY_STRING (static_cast<unsigned char>(7))
  1046. #define TRACE_VALUE_TYPE_CONVERTABLE (static_cast<unsigned char>(8))
  1047. #define TRACE_VALUE_TYPE_PROTO (static_cast<unsigned char>(9))
  1048. // Enum reflecting the scope of an INSTANT event. Must fit within
  1049. // TRACE_EVENT_FLAG_SCOPE_MASK.
  1050. #define TRACE_EVENT_SCOPE_GLOBAL (static_cast<unsigned char>(0 << 2))
  1051. #define TRACE_EVENT_SCOPE_PROCESS (static_cast<unsigned char>(1 << 2))
  1052. #define TRACE_EVENT_SCOPE_THREAD (static_cast<unsigned char>(2 << 2))
  1053. #define TRACE_EVENT_SCOPE_NAME_GLOBAL ('g')
  1054. #define TRACE_EVENT_SCOPE_NAME_PROCESS ('p')
  1055. #define TRACE_EVENT_SCOPE_NAME_THREAD ('t')
  1056. #endif // !defined(BASE_USE_PERFETTO_CLIENT_LIBRARY)
  1057. #endif // BASE_TRACE_EVENT_COMMON_TRACE_EVENT_COMMON_H_