SkTraceEventCommon.h 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291
  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 SkTraceEventCommon_DEFINED
  5. #define SkTraceEventCommon_DEFINED
  6. #include "include/core/SkTypes.h"
  7. #include "include/utils/SkTraceEventPhase.h"
  8. // Trace events are for tracking application performance and resource usage.
  9. // Macros are provided to track:
  10. // Duration of scoped regions
  11. // Instantaneous events
  12. // Counters
  13. //
  14. // The first two arguments to all TRACE macros are the category and name. Both are strings, and
  15. // must have application lifetime (statics or literals). The same applies to arg_names, and string
  16. // argument values. However, you can force a copy of a string argument value with TRACE_STR_COPY:
  17. // TRACE_EVENT1("category", "name", "arg1", "literal string is only referenced");
  18. // TRACE_EVENT1("category", "name", "arg1", TRACE_STR_COPY("string will be copied"));
  19. //
  20. //
  21. // Categories are used to group events, and
  22. // can be enabled or disabled by the tracing framework. The trace system will automatically add the
  23. // process id, thread id, and microsecond timestamp to all events.
  24. //
  25. //
  26. // The TRACE_EVENT[0-2] macros trace the duration of entire scopes:
  27. // void doSomethingCostly() {
  28. // TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly");
  29. // ...
  30. // }
  31. //
  32. // Additional parameters can be associated with an event:
  33. // void doSomethingCostly2(int howMuch) {
  34. // TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly", "howMuch", howMuch);
  35. // ...
  36. // }
  37. //
  38. //
  39. // Trace event also supports counters, which is a way to track a quantity as it varies over time.
  40. // Counters are created with the following macro:
  41. // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue);
  42. //
  43. // Counters are process-specific. The macro itself can be issued from any thread, however.
  44. //
  45. // Sometimes, you want to track two counters at once. You can do this with two counter macros:
  46. // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]);
  47. // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]);
  48. // Or you can do it with a combined macro:
  49. // TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter",
  50. // "bytesPinned", g_myCounterValue[0],
  51. // "bytesAllocated", g_myCounterValue[1]);
  52. // The tracing UI will show these counters in a single graph, as a summed area chart.
  53. #if defined(TRACE_EVENT0)
  54. #error "Another copy of this file has already been included."
  55. #endif
  56. #define TRACE_EMPTY do {} while (0)
  57. #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
  58. #include <cutils/trace.h>
  59. #include <stdarg.h>
  60. class SkAndroidFrameworkTraceUtil {
  61. public:
  62. SkAndroidFrameworkTraceUtil(const char* name) {
  63. if (CC_UNLIKELY(gEnableAndroidTracing)) {
  64. ATRACE_BEGIN(name);
  65. }
  66. }
  67. SkAndroidFrameworkTraceUtil(bool, const char* fmt, ...) {
  68. if (CC_LIKELY((!gEnableAndroidTracing) || (!ATRACE_ENABLED()))) return;
  69. const int BUFFER_SIZE = 256;
  70. va_list ap;
  71. char buf[BUFFER_SIZE];
  72. va_start(ap, fmt);
  73. vsnprintf(buf, BUFFER_SIZE, fmt, ap);
  74. va_end(ap);
  75. ATRACE_BEGIN(buf);
  76. }
  77. ~SkAndroidFrameworkTraceUtil() {
  78. if (CC_UNLIKELY(gEnableAndroidTracing)) {
  79. ATRACE_END();
  80. }
  81. }
  82. static void setEnableTracing(bool enableAndroidTracing) {
  83. gEnableAndroidTracing = enableAndroidTracing;
  84. }
  85. static bool getEnableTracing() {
  86. return gEnableAndroidTracing;
  87. }
  88. private:
  89. static bool gEnableAndroidTracing;
  90. };
  91. #define ATRACE_ANDROID_FRAMEWORK(fmt, ...) SkAndroidFrameworkTraceUtil __trace(true, fmt, ##__VA_ARGS__)
  92. // Records a pair of begin and end events called "name" for the current scope, with 0, 1 or 2
  93. // associated arguments. In the framework, the arguments are ignored.
  94. #define TRACE_EVENT0(category_group, name) \
  95. SkAndroidFrameworkTraceUtil __trace(name)
  96. #define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \
  97. SkAndroidFrameworkTraceUtil __trace(name)
  98. #define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val) \
  99. SkAndroidFrameworkTraceUtil __trace(name)
  100. // Records a single event called "name" immediately, with 0, 1 or 2 associated arguments. If the
  101. // category is not enabled, then this does nothing.
  102. #define TRACE_EVENT_INSTANT0(category_group, name, scope) \
  103. do { SkAndroidFrameworkTraceUtil __trace(name); } while(0)
  104. #define TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val) \
  105. do { SkAndroidFrameworkTraceUtil __trace(name); } while(0)
  106. #define TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, \
  107. arg2_name, arg2_val) \
  108. do { SkAndroidFrameworkTraceUtil __trace(name); } while(0)
  109. // Records the value of a counter called "name" immediately. Value
  110. // must be representable as a 32 bit integer.
  111. #define TRACE_COUNTER1(category_group, name, value) \
  112. if (CC_UNLIKELY(SkAndroidFrameworkTraceUtil::getEnableTracing())) { \
  113. ATRACE_INT(name, value); \
  114. }
  115. // Records the values of a multi-parted counter called "name" immediately.
  116. // In Chrome, this macro produces a stacked bar chart. ATrace doesn't support
  117. // that, so this just produces two separate counters.
  118. #define TRACE_COUNTER2(category_group, name, value1_name, value1_val, value2_name, value2_val) \
  119. do { \
  120. if (CC_UNLIKELY(SkAndroidFrameworkTraceUtil::getEnableTracing())) { \
  121. ATRACE_INT(name "-" value1_name, value1_val); \
  122. ATRACE_INT(name "-" value2_name, value2_val); \
  123. } \
  124. } while (0)
  125. // ATrace has no object tracking
  126. #define TRACE_EVENT_OBJECT_CREATED_WITH_ID(category_group, name, id) TRACE_EMPTY
  127. #define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(category_group, name, id, snapshot) TRACE_EMPTY
  128. #define TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group, name, id) TRACE_EMPTY
  129. // Macro to efficiently determine if a given category group is enabled.
  130. // This is only used for some shader text logging that isn't supported in ATrace anyway.
  131. #define TRACE_EVENT_CATEGORY_GROUP_ENABLED(category_group, ret) \
  132. do { *ret = false; } while (0)
  133. #else // !SK_BUILD_FOR_ANDROID_FRAMEWORK
  134. #define ATRACE_ANDROID_FRAMEWORK(fmt, ...) TRACE_EMPTY
  135. // Records a pair of begin and end events called "name" for the current scope, with 0, 1 or 2
  136. // associated arguments. If the category is not enabled, then this does nothing.
  137. #define TRACE_EVENT0(category_group, name) \
  138. INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name)
  139. #define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \
  140. INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val)
  141. #define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val) \
  142. INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val)
  143. // Records a single event called "name" immediately, with 0, 1 or 2 associated arguments. If the
  144. // category is not enabled, then this does nothing.
  145. #define TRACE_EVENT_INSTANT0(category_group, name, scope) \
  146. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
  147. TRACE_EVENT_FLAG_NONE | scope)
  148. #define TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val) \
  149. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
  150. TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val)
  151. #define TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, \
  152. arg2_name, arg2_val) \
  153. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
  154. TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val, \
  155. arg2_name, arg2_val)
  156. // Records the value of a counter called "name" immediately. Value
  157. // must be representable as a 32 bit integer.
  158. #define TRACE_COUNTER1(category_group, name, value) \
  159. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
  160. TRACE_EVENT_FLAG_NONE, "value", \
  161. static_cast<int>(value))
  162. // Records the values of a multi-parted counter called "name" immediately.
  163. // The UI will treat value1 and value2 as parts of a whole, displaying their
  164. // values as a stacked-bar chart.
  165. #define TRACE_COUNTER2(category_group, name, value1_name, value1_val, \
  166. value2_name, value2_val) \
  167. INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
  168. TRACE_EVENT_FLAG_NONE, value1_name, \
  169. static_cast<int>(value1_val), value2_name, \
  170. static_cast<int>(value2_val))
  171. #define TRACE_EVENT_ASYNC_BEGIN0(category, name, id) \
  172. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  173. TRACE_EVENT_PHASE_ASYNC_BEGIN, category, name, id, TRACE_EVENT_FLAG_NONE)
  174. #define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
  175. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
  176. category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
  177. #define TRACE_EVENT_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
  178. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
  179. category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
  180. #define TRACE_EVENT_ASYNC_END0(category, name, id) \
  181. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
  182. category, name, id, TRACE_EVENT_FLAG_NONE)
  183. #define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
  184. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
  185. category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
  186. #define TRACE_EVENT_ASYNC_END2(category, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \
  187. INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
  188. category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val)
  189. // Macros to track the life time and value of arbitrary client objects.
  190. #define TRACE_EVENT_OBJECT_CREATED_WITH_ID(category_group, name, id) \
  191. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  192. TRACE_EVENT_PHASE_CREATE_OBJECT, category_group, name, id, \
  193. TRACE_EVENT_FLAG_NONE)
  194. #define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(category_group, name, id, \
  195. snapshot) \
  196. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  197. TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name, \
  198. id, TRACE_EVENT_FLAG_NONE, "snapshot", snapshot)
  199. #define TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group, name, id) \
  200. INTERNAL_TRACE_EVENT_ADD_WITH_ID( \
  201. TRACE_EVENT_PHASE_DELETE_OBJECT, category_group, name, id, \
  202. TRACE_EVENT_FLAG_NONE)
  203. // Macro to efficiently determine if a given category group is enabled.
  204. #define TRACE_EVENT_CATEGORY_GROUP_ENABLED(category_group, ret) \
  205. do { \
  206. INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
  207. if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
  208. *ret = true; \
  209. } else { \
  210. *ret = false; \
  211. } \
  212. } while (0)
  213. #endif
  214. // Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
  215. #define TRACE_EVENT_FLAG_NONE (static_cast<unsigned int>(0))
  216. #define TRACE_EVENT_FLAG_COPY (static_cast<unsigned int>(1 << 0))
  217. #define TRACE_EVENT_FLAG_HAS_ID (static_cast<unsigned int>(1 << 1))
  218. #define TRACE_EVENT_FLAG_MANGLE_ID (static_cast<unsigned int>(1 << 2))
  219. #define TRACE_EVENT_FLAG_SCOPE_OFFSET (static_cast<unsigned int>(1 << 3))
  220. #define TRACE_EVENT_FLAG_SCOPE_EXTRA (static_cast<unsigned int>(1 << 4))
  221. #define TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP (static_cast<unsigned int>(1 << 5))
  222. #define TRACE_EVENT_FLAG_ASYNC_TTS (static_cast<unsigned int>(1 << 6))
  223. #define TRACE_EVENT_FLAG_BIND_TO_ENCLOSING (static_cast<unsigned int>(1 << 7))
  224. #define TRACE_EVENT_FLAG_FLOW_IN (static_cast<unsigned int>(1 << 8))
  225. #define TRACE_EVENT_FLAG_FLOW_OUT (static_cast<unsigned int>(1 << 9))
  226. #define TRACE_EVENT_FLAG_HAS_CONTEXT_ID (static_cast<unsigned int>(1 << 10))
  227. #define TRACE_EVENT_FLAG_SCOPE_MASK \
  228. (static_cast<unsigned int>(TRACE_EVENT_FLAG_SCOPE_OFFSET | \
  229. TRACE_EVENT_FLAG_SCOPE_EXTRA))
  230. // Type values for identifying types in the TraceValue union.
  231. #define TRACE_VALUE_TYPE_BOOL (static_cast<unsigned char>(1))
  232. #define TRACE_VALUE_TYPE_UINT (static_cast<unsigned char>(2))
  233. #define TRACE_VALUE_TYPE_INT (static_cast<unsigned char>(3))
  234. #define TRACE_VALUE_TYPE_DOUBLE (static_cast<unsigned char>(4))
  235. #define TRACE_VALUE_TYPE_POINTER (static_cast<unsigned char>(5))
  236. #define TRACE_VALUE_TYPE_STRING (static_cast<unsigned char>(6))
  237. #define TRACE_VALUE_TYPE_COPY_STRING (static_cast<unsigned char>(7))
  238. #define TRACE_VALUE_TYPE_CONVERTABLE (static_cast<unsigned char>(8))
  239. // Enum reflecting the scope of an INSTANT event. Must fit within TRACE_EVENT_FLAG_SCOPE_MASK.
  240. #define TRACE_EVENT_SCOPE_GLOBAL (static_cast<unsigned char>(0 << 3))
  241. #define TRACE_EVENT_SCOPE_PROCESS (static_cast<unsigned char>(1 << 3))
  242. #define TRACE_EVENT_SCOPE_THREAD (static_cast<unsigned char>(2 << 3))
  243. #define TRACE_EVENT_SCOPE_NAME_GLOBAL ('g')
  244. #define TRACE_EVENT_SCOPE_NAME_PROCESS ('p')
  245. #define TRACE_EVENT_SCOPE_NAME_THREAD ('t')
  246. #endif // SkTraceEventCommon_DEFINED