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 7 #include "include/core/SkTypes.h" 8 #include "include/utils/SkTraceEventPhase.h" 9 10 // Trace events are for tracking application performance and resource usage. 11 // Macros are provided to track: 12 // Duration of scoped regions 13 // Instantaneous events 14 // Counters 15 // 16 // The first two arguments to all TRACE macros are the category and name. Both are strings, and 17 // must have application lifetime (statics or literals). The same applies to arg_names, and string 18 // argument values. However, you can force a copy of a string argument value with TRACE_STR_COPY: 19 // TRACE_EVENT1("category", "name", "arg1", "literal string is only referenced"); 20 // TRACE_EVENT1("category", "name", "arg1", TRACE_STR_COPY("string will be copied")); 21 // 22 // 23 // Categories are used to group events, and 24 // can be enabled or disabled by the tracing framework. The trace system will automatically add the 25 // process id, thread id, and microsecond timestamp to all events. 26 // 27 // 28 // The TRACE_EVENT[0-2] macros trace the duration of entire scopes: 29 // void doSomethingCostly() { 30 // TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly"); 31 // ... 32 // } 33 // 34 // Additional parameters can be associated with an event: 35 // void doSomethingCostly2(int howMuch) { 36 // TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly", "howMuch", howMuch); 37 // ... 38 // } 39 // 40 // 41 // Trace event also supports counters, which is a way to track a quantity as it varies over time. 42 // Counters are created with the following macro: 43 // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue); 44 // 45 // Counters are process-specific. The macro itself can be issued from any thread, however. 46 // 47 // Sometimes, you want to track two counters at once. You can do this with two counter macros: 48 // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]); 49 // TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]); 50 // Or you can do it with a combined macro: 51 // TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter", 52 // "bytesPinned", g_myCounterValue[0], 53 // "bytesAllocated", g_myCounterValue[1]); 54 // The tracing UI will show these counters in a single graph, as a summed area chart. 55 56 #if defined(TRACE_EVENT0) 57 #error "Another copy of this file has already been included." 58 #endif 59 60 #define TRACE_EMPTY do {} while (0) 61 62 #ifdef SK_DISABLE_TRACING 63 64 #define ATRACE_ANDROID_FRAMEWORK(fmt, ...) TRACE_EMPTY 65 #define ATRACE_ANDROID_FRAMEWORK_ALWAYS(fmt, ...) TRACE_EMPTY 66 #define HITRACE_OHOS_NAME_ALWAYS(name) TRACE_EMPTY 67 #define HITRACE_OHOS_NAME_FMT_ALWAYS(fmt, ...) TRACE_EMPTY 68 #define SKIA_OHOS_TRACE_PRIV(category_group, name) TRACE_EMPTY 69 #define TRACE_EVENT0(cg, n) TRACE_EMPTY 70 #define TRACE_EVENT0_ALWAYS(cg, n) TRACE_EMPTY 71 #define TRACE_EVENT1(cg, n, a1n, a1v) TRACE_EMPTY 72 #define TRACE_EVENT2(cg, n, a1n, a1v, a2n, a2v) TRACE_EMPTY 73 #define TRACE_EVENT_INSTANT0(cg, n, scope) TRACE_EMPTY 74 #define TRACE_EVENT_INSTANT1(cg, n, scope, a1n, a1v) TRACE_EMPTY 75 #define TRACE_EVENT_INSTANT2(cg, n, scope, a1n, a1v, a2n, a2v) TRACE_EMPTY 76 #define TRACE_COUNTER1(cg, n, value) TRACE_EMPTY 77 #define TRACE_COUNTER2(cg, n, v1n, v1v, v2n, v2v) TRACE_EMPTY 78 79 #elif defined(SK_BUILD_FOR_ANDROID_FRAMEWORK) 80 81 #include <cutils/trace.h> 82 #include <stdarg.h> 83 84 class SkAndroidFrameworkTraceUtil { 85 public: SkAndroidFrameworkTraceUtil(const char * name)86 SkAndroidFrameworkTraceUtil(const char* name) { 87 if (CC_UNLIKELY(gEnableAndroidTracing)) { 88 ATRACE_BEGIN(name); 89 } 90 } SkAndroidFrameworkTraceUtil(bool,const char * fmt,...)91 SkAndroidFrameworkTraceUtil(bool, const char* fmt, ...) { 92 if (CC_LIKELY((!gEnableAndroidTracing) || (!ATRACE_ENABLED()))) return; 93 94 const int BUFFER_SIZE = 256; 95 va_list ap; 96 char buf[BUFFER_SIZE]; 97 98 va_start(ap, fmt); 99 vsnprintf(buf, BUFFER_SIZE, fmt, ap); 100 va_end(ap); 101 102 ATRACE_BEGIN(buf); 103 } ~SkAndroidFrameworkTraceUtil()104 ~SkAndroidFrameworkTraceUtil() { 105 if (CC_UNLIKELY(gEnableAndroidTracing)) { 106 ATRACE_END(); 107 } 108 } 109 setEnableTracing(bool enableAndroidTracing)110 static void setEnableTracing(bool enableAndroidTracing) { 111 gEnableAndroidTracing = enableAndroidTracing; 112 } 113 getEnableTracing()114 static bool getEnableTracing() { 115 return gEnableAndroidTracing; 116 } 117 118 private: 119 static bool gEnableAndroidTracing; 120 }; 121 122 class SkAndroidFrameworkTraceUtilAlways { 123 public: SkAndroidFrameworkTraceUtilAlways(const char * fmt,...)124 SkAndroidFrameworkTraceUtilAlways(const char* fmt, ...) { 125 if (!ATRACE_ENABLED()) return; 126 127 const int BUFFER_SIZE = 256; 128 va_list ap; 129 char buf[BUFFER_SIZE]; 130 131 va_start(ap, fmt); 132 vsnprintf(buf, BUFFER_SIZE, fmt, ap); 133 va_end(ap); 134 135 ATRACE_BEGIN(buf); 136 } ~SkAndroidFrameworkTraceUtilAlways()137 ~SkAndroidFrameworkTraceUtilAlways() { 138 ATRACE_END(); 139 } 140 }; 141 142 #define ATRACE_ANDROID_FRAMEWORK(fmt, ...) SkAndroidFrameworkTraceUtil __trace(true, fmt, ##__VA_ARGS__) 143 #define ATRACE_ANDROID_FRAMEWORK_ALWAYS(fmt, ...) SkAndroidFrameworkTraceUtilAlways __trace_always(fmt, ##__VA_ARGS__) 144 #define HITRACE_OHOS_NAME_ALWAYS(name) TRACE_EMPTY 145 #define HITRACE_OHOS_NAME_FMT_ALWAYS(fmt, ...) TRACE_EMPTY 146 #define SKIA_OHOS_TRACE_PRIV(category_group, name) TRACE_EMPTY 147 148 // Records a pair of begin and end events called "name" for the current scope, with 0, 1 or 2 149 // associated arguments. In the framework, the arguments are ignored. 150 #define TRACE_EVENT0(category_group, name) \ 151 SkAndroidFrameworkTraceUtil __trace(name) 152 #define TRACE_EVENT0_ALWAYS(category_group, name) \ 153 SkAndroidFrameworkTraceUtilAlways __trace_always(name) 154 #define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \ 155 SkAndroidFrameworkTraceUtil __trace(name) 156 #define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val) \ 157 SkAndroidFrameworkTraceUtil __trace(name) 158 159 // Records a single event called "name" immediately, with 0, 1 or 2 associated arguments. If the 160 // category is not enabled, then this does nothing. 161 #define TRACE_EVENT_INSTANT0(category_group, name, scope) \ 162 do { SkAndroidFrameworkTraceUtil __trace(name); } while(0) 163 164 #define TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val) \ 165 do { SkAndroidFrameworkTraceUtil __trace(name); } while(0) 166 167 #define TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, \ 168 arg2_name, arg2_val) \ 169 do { SkAndroidFrameworkTraceUtil __trace(name); } while(0) 170 171 // Records the value of a counter called "name" immediately. Value 172 // must be representable as a 32 bit integer. 173 #define TRACE_COUNTER1(category_group, name, value) \ 174 if (CC_UNLIKELY(SkAndroidFrameworkTraceUtil::getEnableTracing())) { \ 175 ATRACE_INT(name, value); \ 176 } 177 178 // Records the values of a multi-parted counter called "name" immediately. 179 // In Chrome, this macro produces a stacked bar chart. ATrace doesn't support 180 // that, so this just produces two separate counters. 181 #define TRACE_COUNTER2(category_group, name, value1_name, value1_val, value2_name, value2_val) \ 182 do { \ 183 if (CC_UNLIKELY(SkAndroidFrameworkTraceUtil::getEnableTracing())) { \ 184 ATRACE_INT(name "-" value1_name, value1_val); \ 185 ATRACE_INT(name "-" value2_name, value2_val); \ 186 } \ 187 } while (0) 188 189 // ATrace has no object tracking 190 #define TRACE_EVENT_OBJECT_CREATED_WITH_ID(category_group, name, id) TRACE_EMPTY 191 #define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(category_group, name, id, snapshot) TRACE_EMPTY 192 #define TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group, name, id) TRACE_EMPTY 193 194 // Macro to efficiently determine if a given category group is enabled. 195 // This is only used for some shader text logging that isn't supported in ATrace anyway. 196 #define TRACE_EVENT_CATEGORY_GROUP_ENABLED(category_group, ret) \ 197 do { *ret = false; } while (0) 198 199 #elif defined(SKIA_OHOS) 200 201 #include "hitrace_meter.h" 202 203 #ifdef NOT_BUILD_FOR_OHOS_SDK 204 #include "parameters.h" 205 #endif 206 207 #define UNLIKELY(exp) (__builtin_expect((exp) != 0, false)) 208 #define ATRACE_ANDROID_FRAMEWORK(fmt, ...) TRACE_EMPTY 209 #define ATRACE_ANDROID_FRAMEWORK_ALWAYS(fmt, ...) TRACE_EMPTY 210 #define HITRACE_OHOS_NAME_ALWAYS(name) HITRACE_METER_NAME(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL, name) 211 #define HITRACE_OHOS_NAME_FMT_ALWAYS(fmt, ...) \ 212 HITRACE_METER_FMT(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL, fmt, ##__VA_ARGS__) 213 214 #ifdef NOT_BUILD_FOR_OHOS_SDK 215 inline static bool enabledSkiaTrace = 216 std::atoi((OHOS::system::GetParameter("persist.sys.graphic.skia.openDebugTrace", "0")).c_str()) != 0; 217 #else 218 inline static bool enabledSkiaTrace = false; 219 #endif 220 221 class SkOHOSTraceUtil { 222 public: SkOHOSTraceUtil(const char * name)223 SkOHOSTraceUtil(const char* name) { 224 if (UNLIKELY(enabledSkiaTrace)) { 225 StartTrace(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL, name); 226 } 227 } 228 229 template<typename... Args> SkOHOSTraceUtil(const char * fmt,Args...args)230 SkOHOSTraceUtil(const char* fmt, Args... args) { 231 if (UNLIKELY(enabledSkiaTrace)) { 232 StartTrace(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL, fmt, args...); 233 } 234 } 235 ~SkOHOSTraceUtil()236 ~SkOHOSTraceUtil() { 237 if (UNLIKELY(enabledSkiaTrace)) { 238 FinishTrace(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL); 239 } 240 } 241 }; 242 243 // print ohos trace without SKIA_OHOS_DEBUG macro 244 #define SKIA_OHOS_TRACE_PRIV(category_group, name) \ 245 HitraceScoped _trace(HITRACE_TAG_GRAPHIC_AGP, name) 246 247 // Records a pair of begin and end events called "name" for the current scope, with 0, 1 or 2 248 // associated arguments. If the category is not enabled, then this does nothing. 249 #define TRACE_EVENT0(category_group, name) \ 250 SkOHOSTraceUtil _ohosTrace(name) 251 252 #define TRACE_EVENT0_ALWAYS(category_group, name) \ 253 HITRACE_METER_NAME(HITRACE_TAG_GRAPHIC_AGP | HITRACE_TAG_COMMERCIAL, name) 254 255 #define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \ 256 SkOHOSTraceUtil _ohosTrace(name) 257 258 #define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val) \ 259 SkOHOSTraceUtil _ohosTrace(name) 260 261 // Records a single event called "name" immediately, with 0, 1 or 2 associated arguments. If the 262 // category is not enabled, then this does nothing. 263 #define TRACE_EVENT_INSTANT0(category_group, name, scope) TRACE_EMPTY 264 #define TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val) TRACE_EMPTY 265 #define TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, arg2_name, arg2_val) TRACE_EMPTY 266 267 // Records the value of a counter called "name" immediately. Value 268 // must be representable as a 32 bit integer. 269 #define TRACE_COUNTER1(category_group, name, value) TRACE_EMPTY 270 271 // Records the values of a multi-parted counter called "name" immediately. 272 #define TRACE_COUNTER2(category_group, name, value1_name, value1_val, value2_name, value2_val) \ 273 do { \ 274 if (UNLIKELY(enabledSkiaTrace)) { \ 275 std::string tid = std::to_string(gettid()); \ 276 std::string threadValue1Name = tid + "-" + name + "-" + value1_name; \ 277 std::string threadValue2Name = tid + "-" + name + "-" + value2_name; \ 278 CountTrace(HITRACE_TAG_GRAPHIC_AGP, threadValue1Name, value1_val); \ 279 CountTrace(HITRACE_TAG_GRAPHIC_AGP, threadValue2Name, value2_val); \ 280 } \ 281 } while (0) 282 283 #define TRACE_EVENT_ASYNC_BEGIN0(category, name, id) TRACE_EMPTY 284 #define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) TRACE_EMPTY 285 #define TRACE_EVENT_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, arg2_name, arg2_val) TRACE_EMPTY 286 #define TRACE_EVENT_ASYNC_END0(category, name, id) TRACE_EMPTY 287 #define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val) TRACE_EMPTY 288 #define TRACE_EVENT_ASYNC_END2(category, name, id, arg1_name, arg1_val, arg2_name, arg2_val) TRACE_EMPTY 289 290 // Macros to track the life time and value of arbitrary client objects. 291 #define TRACE_EVENT_OBJECT_CREATED_WITH_ID(category_group, name, id) TRACE_EMPTY 292 #define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(category_group, name, id, snapshot) TRACE_EMPTY 293 #define TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group, name, id) TRACE_EMPTY 294 295 // Macro to efficiently determine if a given category group is enabled. 296 #define TRACE_EVENT_CATEGORY_GROUP_ENABLED(category_group, ret) \ 297 do { *ret = false; } while (0) 298 299 #else // !SK_BUILD_FOR_ANDROID_FRAMEWORK && !SK_DISABLE_TRACING 300 301 #define ATRACE_ANDROID_FRAMEWORK(fmt, ...) TRACE_EMPTY 302 #define ATRACE_ANDROID_FRAMEWORK_ALWAYS(fmt, ...) TRACE_EMPTY 303 #define HITRACE_OHOS_NAME_ALWAYS(name) TRACE_EMPTY 304 #define HITRACE_OHOS_NAME_FMT_ALWAYS(fmt, ...) TRACE_EMPTY 305 #define SKIA_OHOS_TRACE_PRIV(category_group, name) TRACE_EMPTY 306 307 // Records a pair of begin and end events called "name" for the current scope, with 0, 1 or 2 308 // associated arguments. If the category is not enabled, then this does nothing. 309 #define TRACE_EVENT0(category_group, name) \ 310 INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name) 311 312 #define TRACE_EVENT0_ALWAYS(category_group, name) \ 313 INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name) 314 315 #define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \ 316 INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val) 317 318 #define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val) \ 319 INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val) 320 321 // Records a single event called "name" immediately, with 0, 1 or 2 associated arguments. If the 322 // category is not enabled, then this does nothing. 323 #define TRACE_EVENT_INSTANT0(category_group, name, scope) \ 324 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \ 325 TRACE_EVENT_FLAG_NONE | scope) 326 327 #define TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val) \ 328 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \ 329 TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val) 330 331 #define TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, \ 332 arg2_name, arg2_val) \ 333 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \ 334 TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val, \ 335 arg2_name, arg2_val) 336 337 // Records the value of a counter called "name" immediately. Value 338 // must be representable as a 32 bit integer. 339 #define TRACE_COUNTER1(category_group, name, value) \ 340 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \ 341 TRACE_EVENT_FLAG_NONE, "value", \ 342 static_cast<int>(value)) 343 344 // Records the values of a multi-parted counter called "name" immediately. 345 // The UI will treat value1 and value2 as parts of a whole, displaying their 346 // values as a stacked-bar chart. 347 #define TRACE_COUNTER2(category_group, name, value1_name, value1_val, \ 348 value2_name, value2_val) \ 349 INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \ 350 TRACE_EVENT_FLAG_NONE, value1_name, \ 351 static_cast<int>(value1_val), value2_name, \ 352 static_cast<int>(value2_val)) 353 354 #define TRACE_EVENT_ASYNC_BEGIN0(category, name, id) \ 355 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \ 356 TRACE_EVENT_PHASE_ASYNC_BEGIN, category, name, id, TRACE_EVENT_FLAG_NONE) 357 #define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \ 358 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \ 359 category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val) 360 #define TRACE_EVENT_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \ 361 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \ 362 category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val) 363 364 #define TRACE_EVENT_ASYNC_END0(category, name, id) \ 365 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \ 366 category, name, id, TRACE_EVENT_FLAG_NONE) 367 #define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val) \ 368 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \ 369 category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val) 370 #define TRACE_EVENT_ASYNC_END2(category, name, id, arg1_name, arg1_val, arg2_name, arg2_val) \ 371 INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \ 372 category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, arg2_name, arg2_val) 373 374 // Macros to track the life time and value of arbitrary client objects. 375 #define TRACE_EVENT_OBJECT_CREATED_WITH_ID(category_group, name, id) \ 376 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \ 377 TRACE_EVENT_PHASE_CREATE_OBJECT, category_group, name, id, \ 378 TRACE_EVENT_FLAG_NONE) 379 380 #define TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(category_group, name, id, \ 381 snapshot) \ 382 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \ 383 TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, category_group, name, \ 384 id, TRACE_EVENT_FLAG_NONE, "snapshot", snapshot) 385 386 #define TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group, name, id) \ 387 INTERNAL_TRACE_EVENT_ADD_WITH_ID( \ 388 TRACE_EVENT_PHASE_DELETE_OBJECT, category_group, name, id, \ 389 TRACE_EVENT_FLAG_NONE) 390 391 // Macro to efficiently determine if a given category group is enabled. 392 #define TRACE_EVENT_CATEGORY_GROUP_ENABLED(category_group, ret) \ 393 do { \ 394 INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \ 395 if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \ 396 *ret = true; \ 397 } else { \ 398 *ret = false; \ 399 } \ 400 } while (0) 401 402 #endif 403 404 // Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT. 405 #define TRACE_EVENT_FLAG_NONE (static_cast<unsigned int>(0)) 406 #define TRACE_EVENT_FLAG_COPY (static_cast<unsigned int>(1 << 0)) 407 #define TRACE_EVENT_FLAG_HAS_ID (static_cast<unsigned int>(1 << 1)) 408 #define TRACE_EVENT_FLAG_MANGLE_ID (static_cast<unsigned int>(1 << 2)) 409 #define TRACE_EVENT_FLAG_SCOPE_OFFSET (static_cast<unsigned int>(1 << 3)) 410 #define TRACE_EVENT_FLAG_SCOPE_EXTRA (static_cast<unsigned int>(1 << 4)) 411 #define TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP (static_cast<unsigned int>(1 << 5)) 412 #define TRACE_EVENT_FLAG_ASYNC_TTS (static_cast<unsigned int>(1 << 6)) 413 #define TRACE_EVENT_FLAG_BIND_TO_ENCLOSING (static_cast<unsigned int>(1 << 7)) 414 #define TRACE_EVENT_FLAG_FLOW_IN (static_cast<unsigned int>(1 << 8)) 415 #define TRACE_EVENT_FLAG_FLOW_OUT (static_cast<unsigned int>(1 << 9)) 416 #define TRACE_EVENT_FLAG_HAS_CONTEXT_ID (static_cast<unsigned int>(1 << 10)) 417 418 #define TRACE_EVENT_FLAG_SCOPE_MASK \ 419 (static_cast<unsigned int>(TRACE_EVENT_FLAG_SCOPE_OFFSET | \ 420 TRACE_EVENT_FLAG_SCOPE_EXTRA)) 421 422 // Type values for identifying types in the TraceValue union. 423 #define TRACE_VALUE_TYPE_BOOL (static_cast<unsigned char>(1)) 424 #define TRACE_VALUE_TYPE_UINT (static_cast<unsigned char>(2)) 425 #define TRACE_VALUE_TYPE_INT (static_cast<unsigned char>(3)) 426 #define TRACE_VALUE_TYPE_DOUBLE (static_cast<unsigned char>(4)) 427 #define TRACE_VALUE_TYPE_POINTER (static_cast<unsigned char>(5)) 428 #define TRACE_VALUE_TYPE_STRING (static_cast<unsigned char>(6)) 429 #define TRACE_VALUE_TYPE_COPY_STRING (static_cast<unsigned char>(7)) 430 #define TRACE_VALUE_TYPE_CONVERTABLE (static_cast<unsigned char>(8)) 431 432 // Enum reflecting the scope of an INSTANT event. Must fit within TRACE_EVENT_FLAG_SCOPE_MASK. 433 #define TRACE_EVENT_SCOPE_GLOBAL (static_cast<unsigned char>(0 << 3)) 434 #define TRACE_EVENT_SCOPE_PROCESS (static_cast<unsigned char>(1 << 3)) 435 #define TRACE_EVENT_SCOPE_THREAD (static_cast<unsigned char>(2 << 3)) 436 437 #define TRACE_EVENT_SCOPE_NAME_GLOBAL ('g') 438 #define TRACE_EVENT_SCOPE_NAME_PROCESS ('p') 439 #define TRACE_EVENT_SCOPE_NAME_THREAD ('t') 440 441 #endif // SkTraceEventCommon_DEFINED 442