Delete more event tracing macros (take 2)
Also tried to clean up the comments to be clearer. Re-land of: https://skia-review.googlesource.com/25364, with some macros that are used by Flutter restored. Change-Id: I648815c275dfea2ec83a382a633af8d9f7780512 Reviewed-on: https://skia-review.googlesource.com/25561 Reviewed-by: Mike Klein <mtklein@chromium.org> Commit-Queue: Brian Osman <brianosman@google.com>
This commit is contained in:
Brian Osman
Skia Commit-Bot
parent
39f1a9589b
commit
594838a44d
@ -37,13 +37,11 @@ SkEventTracer::Handle SkATrace::addTraceEvent(char phase,
|
||||
uint8_t flags) {
|
||||
if (fIsEnabled()) {
|
||||
if (TRACE_EVENT_PHASE_COMPLETE == phase ||
|
||||
TRACE_EVENT_PHASE_BEGIN == phase ||
|
||||
TRACE_EVENT_PHASE_INSTANT == phase) {
|
||||
fBeginSection(name);
|
||||
}
|
||||
|
||||
if (TRACE_EVENT_PHASE_END == phase ||
|
||||
TRACE_EVENT_PHASE_INSTANT == phase) {
|
||||
if (TRACE_EVENT_PHASE_INSTANT == phase) {
|
||||
fEndSection();
|
||||
}
|
||||
}
|
||||
|
||||
@ -22,42 +22,6 @@
|
||||
#define TRACE_STR_COPY(str) \
|
||||
skia::tracing_internals::TraceStringWithCopy(str)
|
||||
|
||||
// By default, uint64 ID argument values are not mangled with the Process ID in
|
||||
// TRACE_EVENT_ASYNC macros. Use this macro to force Process ID mangling.
|
||||
#define TRACE_ID_MANGLE(id) \
|
||||
skia::tracing_internals::TraceID::ForceMangle(id)
|
||||
|
||||
// By default, pointers are mangled with the Process ID in TRACE_EVENT_ASYNC
|
||||
// macros. Use this macro to prevent Process ID mangling.
|
||||
#define TRACE_ID_DONT_MANGLE(id) \
|
||||
skia::tracing_internals::TraceID::DontMangle(id)
|
||||
|
||||
// Sets the current sample state to the given category and name (both must be
|
||||
// constant strings). These states are intended for a sampling profiler.
|
||||
// Implementation note: we store category and name together because we don't
|
||||
// want the inconsistency/expense of storing two pointers.
|
||||
// |thread_bucket| is [0..2] and is used to statically isolate samples in one
|
||||
// thread from others.
|
||||
#define TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET( \
|
||||
bucket_number, category, name) \
|
||||
skia::tracing_internals:: \
|
||||
TraceEventSamplingStateScope<bucket_number>::Set(category "\0" name)
|
||||
|
||||
// Returns a current sampling state of the given bucket.
|
||||
#define TRACE_EVENT_GET_SAMPLING_STATE_FOR_BUCKET(bucket_number) \
|
||||
skia::tracing_internals::TraceEventSamplingStateScope<bucket_number>::Current()
|
||||
|
||||
// Creates a scope of a sampling state of the given bucket.
|
||||
//
|
||||
// { // The sampling state is set within this scope.
|
||||
// TRACE_EVENT_SAMPLING_STATE_SCOPE_FOR_BUCKET(0, "category", "name");
|
||||
// ...;
|
||||
// }
|
||||
#define TRACE_EVENT_SCOPED_SAMPLING_STATE_FOR_BUCKET( \
|
||||
bucket_number, category, name) \
|
||||
skia::tracing_internals::TraceEventSamplingStateScope<bucket_number> \
|
||||
traceEventSamplingScope(category "\0" name);
|
||||
|
||||
|
||||
#define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
|
||||
*INTERNAL_TRACE_EVENT_UID(category_group_enabled) & \
|
||||
@ -77,12 +41,6 @@
|
||||
#define TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED \
|
||||
SkEventTracer::GetInstance()->getCategoryGroupEnabled
|
||||
|
||||
// Get the number of times traces have been recorded. This is used to implement
|
||||
// the TRACE_EVENT_IS_NEW_TRACE facility.
|
||||
// unsigned int TRACE_EVENT_API_GET_NUM_TRACES_RECORDED()
|
||||
#define TRACE_EVENT_API_GET_NUM_TRACES_RECORDED \
|
||||
SkEventTracer::GetInstance()->getNumTracesRecorded
|
||||
|
||||
// Add a trace event to the platform tracing system.
|
||||
// SkEventTracer::Handle TRACE_EVENT_API_ADD_TRACE_EVENT(
|
||||
// char phase,
|
||||
@ -113,13 +71,6 @@
|
||||
// Defines visibility for classes in trace_event.h
|
||||
#define TRACE_EVENT_API_CLASS_EXPORT SK_API
|
||||
|
||||
// The thread buckets for the sampling profiler.
|
||||
TRACE_EVENT_API_CLASS_EXPORT extern \
|
||||
TRACE_EVENT_API_ATOMIC_WORD g_trace_state[3];
|
||||
|
||||
#define TRACE_EVENT_API_THREAD_BUCKET(thread_bucket) \
|
||||
g_trace_state[thread_bucket]
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Implementation detail: trace event macros create temporary variables
|
||||
@ -184,43 +135,6 @@ TRACE_EVENT_API_CLASS_EXPORT extern \
|
||||
INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, h); \
|
||||
}
|
||||
|
||||
// Implementation detail: internal macro to create static category and add
|
||||
// event if the category is enabled.
|
||||
#define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category_group, name, id, \
|
||||
flags, ...) \
|
||||
do { \
|
||||
INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
|
||||
if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
|
||||
unsigned char trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID; \
|
||||
skia::tracing_internals::TraceID trace_event_trace_id( \
|
||||
id, &trace_event_flags); \
|
||||
skia::tracing_internals::AddTraceEvent( \
|
||||
phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), \
|
||||
name, trace_event_trace_id.data(), trace_event_flags, \
|
||||
##__VA_ARGS__); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
// Implementation detail: internal macro to create static category and add
|
||||
// event if the category is enabled.
|
||||
#define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(phase, \
|
||||
category_group, name, id, thread_id, flags, ...) \
|
||||
do { \
|
||||
INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
|
||||
if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
|
||||
unsigned char trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID; \
|
||||
skia::tracing_internals::TraceID trace_event_trace_id( \
|
||||
id, &trace_event_flags); \
|
||||
skia::tracing_internals::AddTraceEventWithThreadIdAndTimestamp( \
|
||||
phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), \
|
||||
name, trace_event_trace_id.data(), \
|
||||
thread_id, base::TimeTicks::FromInternalValue(timestamp), \
|
||||
trace_event_flags, ##__VA_ARGS__); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define INTERNAL_TRACE_MEMORY(category, name)
|
||||
|
||||
namespace skia {
|
||||
namespace tracing_internals {
|
||||
|
||||
@ -234,61 +148,11 @@ const uint64_t kNoEventId = 0;
|
||||
// collide when the same pointer is used on different processes.
|
||||
class TraceID {
|
||||
public:
|
||||
class DontMangle {
|
||||
public:
|
||||
explicit DontMangle(const void* id)
|
||||
: data_(static_cast<uint64_t>(
|
||||
reinterpret_cast<uintptr_t>(id))) {}
|
||||
explicit DontMangle(uint64_t id) : data_(id) {}
|
||||
explicit DontMangle(unsigned int id) : data_(id) {}
|
||||
explicit DontMangle(unsigned short id) : data_(id) {}
|
||||
explicit DontMangle(unsigned char id) : data_(id) {}
|
||||
explicit DontMangle(long long id)
|
||||
: data_(static_cast<uint64_t>(id)) {}
|
||||
explicit DontMangle(long id)
|
||||
: data_(static_cast<uint64_t>(id)) {}
|
||||
explicit DontMangle(int id)
|
||||
: data_(static_cast<uint64_t>(id)) {}
|
||||
explicit DontMangle(short id)
|
||||
: data_(static_cast<uint64_t>(id)) {}
|
||||
explicit DontMangle(signed char id)
|
||||
: data_(static_cast<uint64_t>(id)) {}
|
||||
uint64_t data() const { return data_; }
|
||||
private:
|
||||
uint64_t data_;
|
||||
};
|
||||
|
||||
class ForceMangle {
|
||||
public:
|
||||
explicit ForceMangle(uint64_t id) : data_(id) {}
|
||||
explicit ForceMangle(unsigned int id) : data_(id) {}
|
||||
explicit ForceMangle(unsigned short id) : data_(id) {}
|
||||
explicit ForceMangle(unsigned char id) : data_(id) {}
|
||||
explicit ForceMangle(long long id)
|
||||
: data_(static_cast<uint64_t>(id)) {}
|
||||
explicit ForceMangle(long id)
|
||||
: data_(static_cast<uint64_t>(id)) {}
|
||||
explicit ForceMangle(int id)
|
||||
: data_(static_cast<uint64_t>(id)) {}
|
||||
explicit ForceMangle(short id)
|
||||
: data_(static_cast<uint64_t>(id)) {}
|
||||
explicit ForceMangle(signed char id)
|
||||
: data_(static_cast<uint64_t>(id)) {}
|
||||
uint64_t data() const { return data_; }
|
||||
private:
|
||||
uint64_t data_;
|
||||
};
|
||||
|
||||
TraceID(const void* id, unsigned char* flags)
|
||||
: data_(static_cast<uint64_t>(
|
||||
reinterpret_cast<uintptr_t>(id))) {
|
||||
*flags |= TRACE_EVENT_FLAG_MANGLE_ID;
|
||||
}
|
||||
TraceID(ForceMangle id, unsigned char* flags) : data_(id.data()) {
|
||||
*flags |= TRACE_EVENT_FLAG_MANGLE_ID;
|
||||
}
|
||||
TraceID(DontMangle id, unsigned char* flags) : data_(id.data()) {
|
||||
}
|
||||
TraceID(uint64_t id, unsigned char* flags)
|
||||
: data_(id) { (void)flags; }
|
||||
TraceID(unsigned int id, unsigned char* flags)
|
||||
@ -370,10 +234,8 @@ INTERNAL_DECLARE_SET_TRACE_VALUE_INT(short, TRACE_VALUE_TYPE_INT)
|
||||
INTERNAL_DECLARE_SET_TRACE_VALUE_INT(signed char, TRACE_VALUE_TYPE_INT)
|
||||
INTERNAL_DECLARE_SET_TRACE_VALUE(bool, as_bool, TRACE_VALUE_TYPE_BOOL)
|
||||
INTERNAL_DECLARE_SET_TRACE_VALUE(double, as_double, TRACE_VALUE_TYPE_DOUBLE)
|
||||
INTERNAL_DECLARE_SET_TRACE_VALUE(const void*, as_pointer,
|
||||
TRACE_VALUE_TYPE_POINTER)
|
||||
INTERNAL_DECLARE_SET_TRACE_VALUE(const char*, as_string,
|
||||
TRACE_VALUE_TYPE_STRING)
|
||||
INTERNAL_DECLARE_SET_TRACE_VALUE(const void*, as_pointer, TRACE_VALUE_TYPE_POINTER)
|
||||
INTERNAL_DECLARE_SET_TRACE_VALUE(const char*, as_string, TRACE_VALUE_TYPE_STRING)
|
||||
INTERNAL_DECLARE_SET_TRACE_VALUE(const TraceStringWithCopy&, as_string,
|
||||
TRACE_VALUE_TYPE_COPY_STRING)
|
||||
|
||||
@ -476,58 +338,6 @@ class TRACE_EVENT_API_CLASS_EXPORT ScopedTracer {
|
||||
Data data_;
|
||||
};
|
||||
|
||||
// Used by TRACE_EVENT_BINARY_EFFICIENTx macro. Do not use directly.
|
||||
class TRACE_EVENT_API_CLASS_EXPORT ScopedTraceBinaryEfficient {
|
||||
public:
|
||||
ScopedTraceBinaryEfficient(const char* category_group, const char* name);
|
||||
~ScopedTraceBinaryEfficient();
|
||||
|
||||
private:
|
||||
const uint8_t* category_group_enabled_;
|
||||
const char* name_;
|
||||
SkEventTracer::Handle event_handle_;
|
||||
};
|
||||
|
||||
// This macro generates less code then TRACE_EVENT0 but is also
|
||||
// slower to execute when tracing is off. It should generally only be
|
||||
// used with code that is seldom executed or conditionally executed
|
||||
// when debugging.
|
||||
// For now the category_group must be "gpu".
|
||||
#define TRACE_EVENT_BINARY_EFFICIENT0(category_group, name) \
|
||||
skia::tracing_internals::ScopedTraceBinaryEfficient \
|
||||
INTERNAL_TRACE_EVENT_UID(scoped_trace)(category_group, name);
|
||||
|
||||
// TraceEventSamplingStateScope records the current sampling state
|
||||
// and sets a new sampling state. When the scope exists, it restores
|
||||
// the sampling state having recorded.
|
||||
template<size_t BucketNumber>
|
||||
class TraceEventSamplingStateScope {
|
||||
public:
|
||||
TraceEventSamplingStateScope(const char* category_and_name) {
|
||||
previous_state_ = TraceEventSamplingStateScope<BucketNumber>::Current();
|
||||
TraceEventSamplingStateScope<BucketNumber>::Set(category_and_name);
|
||||
}
|
||||
|
||||
~TraceEventSamplingStateScope() {
|
||||
TraceEventSamplingStateScope<BucketNumber>::Set(previous_state_);
|
||||
}
|
||||
|
||||
static inline const char* Current() {
|
||||
return reinterpret_cast<const char*>(TRACE_EVENT_API_ATOMIC_LOAD(
|
||||
g_trace_state[BucketNumber]));
|
||||
}
|
||||
|
||||
static inline void Set(const char* category_and_name) {
|
||||
TRACE_EVENT_API_ATOMIC_STORE(
|
||||
g_trace_state[BucketNumber],
|
||||
reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD>(
|
||||
const_cast<char*>(category_and_name)));
|
||||
}
|
||||
|
||||
private:
|
||||
const char* previous_state_;
|
||||
};
|
||||
|
||||
} // namespace tracing_internals
|
||||
} // namespace skia
|
||||
|
||||
|
||||
@ -4,46 +4,25 @@
|
||||
#ifndef SkTraceEventCommon_DEFINED
|
||||
#define SkTraceEventCommon_DEFINED
|
||||
|
||||
// This header file defines the set of trace_event macros without specifying
|
||||
// how the events actually get collected and stored. If you need to expose trace
|
||||
// events to some other universe, you can copy-and-paste this file as well as
|
||||
// trace_event.h, modifying the macros contained there as necessary for the
|
||||
// target platform. The end result is that multiple libraries can funnel events
|
||||
// through to a shared trace event collector.
|
||||
|
||||
// IMPORTANT: To avoid conflicts, if you need to modify this file for a library,
|
||||
// land your change in base/ first, and then copy-and-paste it.
|
||||
|
||||
// Trace events are for tracking application performance and resource usage.
|
||||
// Macros are provided to track:
|
||||
// Begin and end of function calls
|
||||
// Duration of scoped regions
|
||||
// Instantaneous events
|
||||
// Counters
|
||||
//
|
||||
// Events are issued against categories. Whereas LOG's
|
||||
// categories are statically defined, TRACE categories are created
|
||||
// implicitly with a string. For example:
|
||||
// TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent",
|
||||
// TRACE_EVENT_SCOPE_THREAD)
|
||||
// The first two arguments to all TRACE macros are the category and name. Both are strings, and
|
||||
// must have application lifetime (statics or literals). The same applies to arg_names, and string
|
||||
// argument values. However, you can force a copy of a string argument value with TRACE_STR_COPY:
|
||||
// TRACE_EVENT1("category", "name", "arg1", "literal string is only referenced");
|
||||
// TRACE_EVENT1("category", "name", "arg1", TRACE_STR_COPY("string will be copied"));
|
||||
//
|
||||
// It is often the case that one trace may belong in multiple categories at the
|
||||
// same time. The first argument to the trace can be a comma-separated list of
|
||||
// categories, forming a category group, like:
|
||||
//
|
||||
// TRACE_EVENT_INSTANT0("input,views", "OnMouseOver", TRACE_EVENT_SCOPE_THREAD)
|
||||
// Categories are used to group events, and
|
||||
// can be enabled or disabled by the tracing framework. The trace system will automatically add the
|
||||
// process id, thread id, and microsecond timestamp to all events.
|
||||
//
|
||||
// We can enable/disable tracing of OnMouseOver by enabling/disabling either
|
||||
// category.
|
||||
//
|
||||
// Events can be INSTANT, or can be pairs of BEGIN and END in the same scope:
|
||||
// TRACE_EVENT_BEGIN0("MY_SUBSYSTEM", "SomethingCostly")
|
||||
// doSomethingCostly()
|
||||
// TRACE_EVENT_END0("MY_SUBSYSTEM", "SomethingCostly")
|
||||
// Note: our tools can't always determine the correct BEGIN/END pairs unless
|
||||
// these are used in the same scope. Use ASYNC_BEGIN/ASYNC_END macros if you
|
||||
// need them to be in separate scopes.
|
||||
//
|
||||
// A common use case is to trace entire function scopes. This
|
||||
// issues a trace BEGIN and END automatically:
|
||||
// The TRACE_EVENT[0-2] macros trace the duration of entire scopes:
|
||||
// void doSomethingCostly() {
|
||||
// TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly");
|
||||
// ...
|
||||
@ -51,145 +30,25 @@
|
||||
//
|
||||
// Additional parameters can be associated with an event:
|
||||
// void doSomethingCostly2(int howMuch) {
|
||||
// TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly",
|
||||
// "howMuch", howMuch);
|
||||
// TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly", "howMuch", howMuch);
|
||||
// ...
|
||||
// }
|
||||
//
|
||||
// The trace system will automatically add to this information the
|
||||
// current process id, thread id, and a timestamp in microseconds.
|
||||
//
|
||||
// To trace an asynchronous procedure such as an IPC send/receive, use
|
||||
// ASYNC_BEGIN and ASYNC_END:
|
||||
// [single threaded sender code]
|
||||
// static int send_count = 0;
|
||||
// ++send_count;
|
||||
// TRACE_EVENT_ASYNC_BEGIN0("ipc", "message", send_count);
|
||||
// Send(new MyMessage(send_count));
|
||||
// [receive code]
|
||||
// void OnMyMessage(send_count) {
|
||||
// TRACE_EVENT_ASYNC_END0("ipc", "message", send_count);
|
||||
// }
|
||||
// The third parameter is a unique ID to match ASYNC_BEGIN/ASYNC_END pairs.
|
||||
// ASYNC_BEGIN and ASYNC_END can occur on any thread of any traced process.
|
||||
// Pointers can be used for the ID parameter, and they will be mangled
|
||||
// internally so that the same pointer on two different processes will not
|
||||
// match. For example:
|
||||
// class MyTracedClass {
|
||||
// public:
|
||||
// MyTracedClass() {
|
||||
// TRACE_EVENT_ASYNC_BEGIN0("category", "MyTracedClass", this);
|
||||
// }
|
||||
// ~MyTracedClass() {
|
||||
// TRACE_EVENT_ASYNC_END0("category", "MyTracedClass", this);
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// Trace event also supports counters, which is a way to track a quantity
|
||||
// as it varies over time. Counters are created with the following macro:
|
||||
// Trace event also supports counters, which is a way to track a quantity as it varies over time.
|
||||
// Counters are created with the following macro:
|
||||
// TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue);
|
||||
//
|
||||
// Counters are process-specific. The macro itself can be issued from any
|
||||
// thread, however.
|
||||
// Counters are process-specific. The macro itself can be issued from any thread, however.
|
||||
//
|
||||
// Sometimes, you want to track two counters at once. You can do this with two
|
||||
// counter macros:
|
||||
// Sometimes, you want to track two counters at once. You can do this with two counter macros:
|
||||
// TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]);
|
||||
// TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]);
|
||||
// Or you can do it with a combined macro:
|
||||
// TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter",
|
||||
// "bytesPinned", g_myCounterValue[0],
|
||||
// "bytesAllocated", g_myCounterValue[1]);
|
||||
// This indicates to the tracing UI that these counters should be displayed
|
||||
// in a single graph, as a summed area chart.
|
||||
//
|
||||
// Since counters are in a global namespace, you may want to disambiguate with a
|
||||
// unique ID, by using the TRACE_COUNTER_ID* variations.
|
||||
//
|
||||
// By default, trace collection is compiled in, but turned off at runtime.
|
||||
// Collecting trace data is the responsibility of the embedding
|
||||
// application. In Chrome's case, navigating to about:tracing will turn on
|
||||
// tracing and display data collected across all active processes.
|
||||
//
|
||||
//
|
||||
// Memory scoping note:
|
||||
// Tracing copies the pointers, not the string content, of the strings passed
|
||||
// in for category_group, name, and arg_names. Thus, the following code will
|
||||
// cause problems:
|
||||
// char* str = strdup("importantName");
|
||||
// TRACE_EVENT_INSTANT0("SUBSYSTEM", str); // BAD!
|
||||
// free(str); // Trace system now has dangling pointer
|
||||
//
|
||||
// To avoid this issue with the |name| and |arg_name| parameters, use the
|
||||
// TRACE_EVENT_COPY_XXX overloads of the macros at additional runtime overhead.
|
||||
// Notes: The category must always be in a long-lived char* (i.e. static const).
|
||||
// The |arg_values|, when used, are always deep copied with the _COPY
|
||||
// macros.
|
||||
//
|
||||
// When are string argument values copied:
|
||||
// const char* arg_values are only referenced by default:
|
||||
// TRACE_EVENT1("category", "name",
|
||||
// "arg1", "literal string is only referenced");
|
||||
// Use TRACE_STR_COPY to force copying of a const char*:
|
||||
// TRACE_EVENT1("category", "name",
|
||||
// "arg1", TRACE_STR_COPY("string will be copied"));
|
||||
// std::string arg_values are always copied:
|
||||
// TRACE_EVENT1("category", "name",
|
||||
// "arg1", std::string("string will be copied"));
|
||||
//
|
||||
//
|
||||
// Convertable notes:
|
||||
// Converting a large data type to a string can be costly. To help with this,
|
||||
// the trace framework provides an interface ConvertableToTraceFormat. If you
|
||||
// inherit from it and implement the AppendAsTraceFormat method the trace
|
||||
// framework will call back to your object to convert a trace output time. This
|
||||
// means, if the category for the event is disabled, the conversion will not
|
||||
// happen.
|
||||
//
|
||||
// class MyData : public base::trace_event::ConvertableToTraceFormat {
|
||||
// public:
|
||||
// MyData() {}
|
||||
// void AppendAsTraceFormat(std::string* out) const override {
|
||||
// out->append("{\"foo\":1}");
|
||||
// }
|
||||
// private:
|
||||
// ~MyData() override {}
|
||||
// DISALLOW_COPY_AND_ASSIGN(MyData);
|
||||
// };
|
||||
//
|
||||
// TRACE_EVENT1("foo", "bar", "data",
|
||||
// scoped_refptr<ConvertableToTraceFormat>(new MyData()));
|
||||
//
|
||||
// The trace framework will take ownership if the passed pointer and it will
|
||||
// be free'd when the trace buffer is flushed.
|
||||
//
|
||||
// Note, we only do the conversion when the buffer is flushed, so the provided
|
||||
// data object should not be modified after it's passed to the trace framework.
|
||||
//
|
||||
//
|
||||
// Thread Safety:
|
||||
// A thread safe singleton and mutex are used for thread safety. Category
|
||||
// enabled flags are used to limit the performance impact when the system
|
||||
// is not enabled.
|
||||
//
|
||||
// TRACE_EVENT macros first cache a pointer to a category. The categories are
|
||||
// statically allocated and safe at all times, even after exit. Fetching a
|
||||
// category is protected by the TraceLog::lock_. Multiple threads initializing
|
||||
// the static variable is safe, as they will be serialized by the lock and
|
||||
// multiple calls will return the same pointer to the category.
|
||||
//
|
||||
// Then the category_group_enabled flag is checked. This is a unsigned char, and
|
||||
// not intended to be multithread safe. It optimizes access to AddTraceEvent
|
||||
// which is threadsafe internally via TraceLog::lock_. The enabled flag may
|
||||
// cause some threads to incorrectly call or skip calling AddTraceEvent near
|
||||
// the time of the system being enabled or disabled. This is acceptable as
|
||||
// we tolerate some data loss while the system is being enabled/disabled and
|
||||
// because AddTraceEvent is threadsafe internally and checks the enabled state
|
||||
// again under lock.
|
||||
//
|
||||
// Without the use of these static category pointers and enabled flags all
|
||||
// trace points would carry a significant performance cost of acquiring a lock
|
||||
// and resolving the category.
|
||||
// "bytesPinned", g_myCounterValue[0],
|
||||
// "bytesAllocated", g_myCounterValue[1]);
|
||||
// The tracing UI will show these counters in a single graph, as a summed area chart.
|
||||
|
||||
#if defined(TRACE_EVENT0)
|
||||
#error "Another copy of this file has already been included."
|
||||
@ -199,84 +58,49 @@
|
||||
// to explicitly enable the event.
|
||||
#define TRACE_DISABLED_BY_DEFAULT(name) "disabled-by-default-" name
|
||||
|
||||
// Records a pair of begin and end events called "name" for the current
|
||||
// scope, with 0, 1 or 2 associated arguments. If the category is not
|
||||
// enabled, then this does nothing.
|
||||
// - category and name strings must have application lifetime (statics or
|
||||
// literals). They may not include " chars.
|
||||
#define TRACE_EVENT0(category_group, name) \
|
||||
INTERNAL_TRACE_MEMORY(category_group, name) \
|
||||
// Records a pair of begin and end events called "name" for the current scope, with 0, 1 or 2
|
||||
// associated arguments. If the category is not enabled, then this does nothing.
|
||||
#define TRACE_EVENT0(category_group, name) \
|
||||
INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name)
|
||||
|
||||
#define TRACE_EVENT1(category_group, name, arg1_name, arg1_val) \
|
||||
INTERNAL_TRACE_MEMORY(category_group, name) \
|
||||
INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val)
|
||||
|
||||
#define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, \
|
||||
arg2_val) \
|
||||
INTERNAL_TRACE_MEMORY(category_group, name) \
|
||||
INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val, \
|
||||
arg2_name, arg2_val)
|
||||
#define TRACE_EVENT2(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val) \
|
||||
INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, arg1_name, arg1_val, arg2_name, arg2_val)
|
||||
|
||||
// Records a single event called "name" immediately, with 0, 1 or 2
|
||||
// associated arguments. If the category is not enabled, then this
|
||||
// does nothing.
|
||||
// - category and name strings must have application lifetime (statics or
|
||||
// literals). They may not include " chars.
|
||||
// Records a single event called "name" immediately, with 0, 1 or 2 associated arguments. If the
|
||||
// category is not enabled, then this does nothing.
|
||||
#define TRACE_EVENT_INSTANT0(category_group, name, scope) \
|
||||
INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
|
||||
TRACE_EVENT_FLAG_NONE | scope)
|
||||
|
||||
#define TRACE_EVENT_INSTANT1(category_group, name, scope, arg1_name, arg1_val) \
|
||||
INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
|
||||
TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val)
|
||||
|
||||
#define TRACE_EVENT_INSTANT2(category_group, name, scope, arg1_name, arg1_val, \
|
||||
arg2_name, arg2_val) \
|
||||
INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
|
||||
TRACE_EVENT_FLAG_NONE | scope, arg1_name, arg1_val, \
|
||||
arg2_name, arg2_val)
|
||||
#define TRACE_EVENT_COPY_INSTANT0(category_group, name, scope) \
|
||||
INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
|
||||
TRACE_EVENT_FLAG_COPY | scope)
|
||||
#define TRACE_EVENT_COPY_INSTANT1(category_group, name, scope, arg1_name, \
|
||||
arg1_val) \
|
||||
INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
|
||||
TRACE_EVENT_FLAG_COPY | scope, arg1_name, arg1_val)
|
||||
#define TRACE_EVENT_COPY_INSTANT2(category_group, name, scope, arg1_name, \
|
||||
arg1_val, arg2_name, arg2_val) \
|
||||
INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category_group, name, \
|
||||
TRACE_EVENT_FLAG_COPY | scope, arg1_name, arg1_val, \
|
||||
arg2_name, arg2_val)
|
||||
|
||||
// Records the value of a counter called "name" immediately. Value
|
||||
// must be representable as a 32 bit integer.
|
||||
// - category and name strings must have application lifetime (statics or
|
||||
// literals). They may not include " chars.
|
||||
#define TRACE_COUNTER1(category_group, name, value) \
|
||||
INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
|
||||
TRACE_EVENT_FLAG_NONE, "value", \
|
||||
static_cast<int>(value))
|
||||
#define TRACE_COPY_COUNTER1(category_group, name, value) \
|
||||
INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
|
||||
TRACE_EVENT_FLAG_COPY, "value", \
|
||||
static_cast<int>(value))
|
||||
|
||||
// Records the values of a multi-parted counter called "name" immediately.
|
||||
// The UI will treat value1 and value2 as parts of a whole, displaying their
|
||||
// values as a stacked-bar chart.
|
||||
// - category and name strings must have application lifetime (statics or
|
||||
// literals). They may not include " chars.
|
||||
#define TRACE_COUNTER2(category_group, name, value1_name, value1_val, \
|
||||
value2_name, value2_val) \
|
||||
INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
|
||||
TRACE_EVENT_FLAG_NONE, value1_name, \
|
||||
static_cast<int>(value1_val), value2_name, \
|
||||
static_cast<int>(value2_val))
|
||||
#define TRACE_COPY_COUNTER2(category_group, name, value1_name, value1_val, \
|
||||
value2_name, value2_val) \
|
||||
INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category_group, name, \
|
||||
TRACE_EVENT_FLAG_COPY, value1_name, \
|
||||
static_cast<int>(value1_val), value2_name, \
|
||||
static_cast<int>(value2_val))
|
||||
|
||||
// Macro to efficiently determine if a given category group is enabled.
|
||||
#define TRACE_EVENT_CATEGORY_GROUP_ENABLED(category_group, ret) \
|
||||
@ -289,25 +113,6 @@
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
// Macro to efficiently determine, through polling, if a new trace has begun.
|
||||
#define TRACE_EVENT_IS_NEW_TRACE(ret) \
|
||||
do { \
|
||||
static int INTERNAL_TRACE_EVENT_UID(lastRecordingNumber) = 0; \
|
||||
int num_traces_recorded = TRACE_EVENT_API_GET_NUM_TRACES_RECORDED(); \
|
||||
if (num_traces_recorded != -1 && \
|
||||
num_traces_recorded != \
|
||||
INTERNAL_TRACE_EVENT_UID(lastRecordingNumber)) { \
|
||||
INTERNAL_TRACE_EVENT_UID(lastRecordingNumber) = num_traces_recorded; \
|
||||
*ret = true; \
|
||||
} else { \
|
||||
*ret = false; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
// Notes regarding the following definitions:
|
||||
// New values can be added and propagated to third party libraries, but existing
|
||||
// definitions must never be changed, because third party libraries may use old
|
||||
// definitions.
|
||||
|
||||
// Phase indicates the nature of an event entry. E.g. part of a begin/end pair.
|
||||
#define TRACE_EVENT_PHASE_BEGIN ('B')
|
||||
@ -315,23 +120,8 @@
|
||||
#define TRACE_EVENT_PHASE_COMPLETE ('X')
|
||||
#define TRACE_EVENT_PHASE_INSTANT ('I')
|
||||
#define TRACE_EVENT_PHASE_ASYNC_BEGIN ('S')
|
||||
#define TRACE_EVENT_PHASE_ASYNC_STEP_INTO ('T')
|
||||
#define TRACE_EVENT_PHASE_ASYNC_STEP_PAST ('p')
|
||||
#define TRACE_EVENT_PHASE_ASYNC_END ('F')
|
||||
#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN ('b')
|
||||
#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_END ('e')
|
||||
#define TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT ('n')
|
||||
#define TRACE_EVENT_PHASE_FLOW_BEGIN ('s')
|
||||
#define TRACE_EVENT_PHASE_FLOW_STEP ('t')
|
||||
#define TRACE_EVENT_PHASE_FLOW_END ('f')
|
||||
#define TRACE_EVENT_PHASE_METADATA ('M')
|
||||
#define TRACE_EVENT_PHASE_COUNTER ('C')
|
||||
#define TRACE_EVENT_PHASE_SAMPLE ('P')
|
||||
#define TRACE_EVENT_PHASE_CREATE_OBJECT ('N')
|
||||
#define TRACE_EVENT_PHASE_SNAPSHOT_OBJECT ('O')
|
||||
#define TRACE_EVENT_PHASE_DELETE_OBJECT ('D')
|
||||
#define TRACE_EVENT_PHASE_MEMORY_DUMP ('v')
|
||||
#define TRACE_EVENT_PHASE_MARK ('R')
|
||||
|
||||
// Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
|
||||
#define TRACE_EVENT_FLAG_NONE (static_cast<unsigned int>(0))
|
||||
@ -361,8 +151,7 @@
|
||||
#define TRACE_VALUE_TYPE_COPY_STRING (static_cast<unsigned char>(7))
|
||||
#define TRACE_VALUE_TYPE_CONVERTABLE (static_cast<unsigned char>(8))
|
||||
|
||||
// Enum reflecting the scope of an INSTANT event. Must fit within
|
||||
// TRACE_EVENT_FLAG_SCOPE_MASK.
|
||||
// Enum reflecting the scope of an INSTANT event. Must fit within TRACE_EVENT_FLAG_SCOPE_MASK.
|
||||
#define TRACE_EVENT_SCOPE_GLOBAL (static_cast<unsigned char>(0 << 3))
|
||||
#define TRACE_EVENT_SCOPE_PROCESS (static_cast<unsigned char>(1 << 3))
|
||||
#define TRACE_EVENT_SCOPE_THREAD (static_cast<unsigned char>(2 << 3))
|
||||
@ -370,4 +159,5 @@
|
||||
#define TRACE_EVENT_SCOPE_NAME_GLOBAL ('g')
|
||||
#define TRACE_EVENT_SCOPE_NAME_PROCESS ('p')
|
||||
#define TRACE_EVENT_SCOPE_NAME_THREAD ('t')
|
||||
|
||||
#endif // SkTraceEventCommon_DEFINED
|
||||
|
||||
Loading…
Reference in New Issue
Block a user