Mirror-Tools
/
shaka-packager
mirror of https://github.com/shaka-project/shaka-packager.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
shaka-packager/base/debug/trace_event_impl.cc

1693 lines
53 KiB
C++
Raw Normal View History

Start with media/mp4, media/webm and base codes from Chromium.
2013-09-24 01:35:40 +00:00
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/debug/trace_event_impl.h"
#include <algorithm>
#include "base/base_switches.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "base/debug/leak_annotations.h"
#include "base/debug/trace_event.h"
#include "base/format_macros.h"
#include "base/lazy_instance.h"
#include "base/memory/singleton.h"
#include "base/process/process_metrics.h"
#include "base/stl_util.h"
#include "base/strings/string_split.h"
#include "base/strings/string_tokenizer.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/synchronization/cancellation_flag.h"
#include "base/synchronization/waitable_event.h"
#include "base/sys_info.h"
#include "base/third_party/dynamic_annotations/dynamic_annotations.h"
#include "base/threading/platform_thread.h"
#include "base/threading/thread_id_name_manager.h"
#include "base/threading/thread_local.h"
#include "base/time/time.h"
#if defined(OS_WIN)
#include "base/debug/trace_event_win.h"
#endif
class DeleteTraceLogForTesting {
public:
static void Delete() {
Singleton<base::debug::TraceLog,
LeakySingletonTraits<base::debug::TraceLog> >::OnExit(0);
}
};
// The thread buckets for the sampling profiler.
BASE_EXPORT TRACE_EVENT_API_ATOMIC_WORD g_trace_state[3];
namespace base {
namespace debug {
// Controls the number of trace events we will buffer in-memory
// before throwing them away.
const size_t kTraceEventBufferSize = 500000;
const size_t kTraceEventBatchSize = 1000;
const size_t kTraceEventInitialBufferSize = 1024;
#define MAX_CATEGORY_GROUPS 100
namespace {
// Parallel arrays g_category_groups and g_category_group_enabled are separate
// so that a pointer to a member of g_category_group_enabled can be easily
// converted to an index into g_category_groups. This allows macros to deal
// only with char enabled pointers from g_category_group_enabled, and we can
// convert internally to determine the category name from the char enabled
// pointer.
const char* g_category_groups[MAX_CATEGORY_GROUPS] = {
"tracing already shutdown",
"tracing categories exhausted; must increase MAX_CATEGORY_GROUPS",
"__metadata",
};
// The enabled flag is char instead of bool so that the API can be used from C.
unsigned char g_category_group_enabled[MAX_CATEGORY_GROUPS] = { 0 };
const int g_category_already_shutdown = 0;
const int g_category_categories_exhausted = 1;
const int g_category_metadata = 2;
const int g_num_builtin_categories = 3;
int g_category_index = g_num_builtin_categories; // Skip default categories.
// The name of the current thread. This is used to decide if the current
// thread name has changed. We combine all the seen thread names into the
// output name for the thread.
LazyInstance<ThreadLocalPointer<const char> >::Leaky
g_current_thread_name = LAZY_INSTANCE_INITIALIZER;
const char kRecordUntilFull[] = "record-until-full";
const char kRecordContinuously[] = "record-continuously";
const char kEnableSampling[] = "enable-sampling";
size_t NextIndex(size_t index) {
index++;
if (index >= kTraceEventBufferSize)
index = 0;
return index;
}
} // namespace
class TraceBufferRingBuffer : public TraceBuffer {
public:
TraceBufferRingBuffer()
: unused_event_index_(0),
oldest_event_index_(0) {
logged_events_.reserve(kTraceEventInitialBufferSize);
}
virtual ~TraceBufferRingBuffer() {}
virtual void AddEvent(const TraceEvent& event) OVERRIDE {
if (unused_event_index_ < Size())
logged_events_[unused_event_index_] = event;
else
logged_events_.push_back(event);
unused_event_index_ = NextIndex(unused_event_index_);
if (unused_event_index_ == oldest_event_index_) {
oldest_event_index_ = NextIndex(oldest_event_index_);
}
}
virtual bool HasMoreEvents() const OVERRIDE {
return oldest_event_index_ != unused_event_index_;
}
virtual const TraceEvent& NextEvent() OVERRIDE {
DCHECK(HasMoreEvents());
size_t next = oldest_event_index_;
oldest_event_index_ = NextIndex(oldest_event_index_);
return GetEventAt(next);
}
virtual bool IsFull() const OVERRIDE {
return false;
}
virtual size_t CountEnabledByName(
const unsigned char* category,
const std::string& event_name) const OVERRIDE {
size_t notify_count = 0;
size_t index = oldest_event_index_;
while (index != unused_event_index_) {
const TraceEvent& event = GetEventAt(index);
if (category == event.category_group_enabled() &&
strcmp(event_name.c_str(), event.name()) == 0) {
++notify_count;
}
index = NextIndex(index);
}
return notify_count;
}
virtual const TraceEvent& GetEventAt(size_t index) const OVERRIDE {
DCHECK(index < logged_events_.size());
return logged_events_[index];
}
virtual size_t Size() const OVERRIDE {
return logged_events_.size();
}
private:
size_t unused_event_index_;
size_t oldest_event_index_;
std::vector<TraceEvent> logged_events_;
DISALLOW_COPY_AND_ASSIGN(TraceBufferRingBuffer);
};
class TraceBufferVector : public TraceBuffer {
public:
TraceBufferVector() : current_iteration_index_(0) {
logged_events_.reserve(kTraceEventInitialBufferSize);
}
virtual ~TraceBufferVector() {
}
virtual void AddEvent(const TraceEvent& event) OVERRIDE {
// Note, we have two callers which need to be handled. The first is
// AddTraceEventWithThreadIdAndTimestamp() which checks Size() and does an
// early exit if full. The second is AddThreadNameMetadataEvents().
// We can not DECHECK(!IsFull()) because we have to add the metadata
// events even if the buffer is full.
logged_events_.push_back(event);
}
virtual bool HasMoreEvents() const OVERRIDE {
return current_iteration_index_ < Size();
}
virtual const TraceEvent& NextEvent() OVERRIDE {
DCHECK(HasMoreEvents());
return GetEventAt(current_iteration_index_++);
}
virtual bool IsFull() const OVERRIDE {
return Size() >= kTraceEventBufferSize;
}
virtual size_t CountEnabledByName(
const unsigned char* category,
const std::string& event_name) const OVERRIDE {
size_t notify_count = 0;
for (size_t i = 0; i < Size(); i++) {
const TraceEvent& event = GetEventAt(i);
if (category == event.category_group_enabled() &&
strcmp(event_name.c_str(), event.name()) == 0) {
++notify_count;
}
}
return notify_count;
}
virtual const TraceEvent& GetEventAt(size_t index) const OVERRIDE {
DCHECK(index < logged_events_.size());
return logged_events_[index];
}
virtual size_t Size() const OVERRIDE {
return logged_events_.size();
}
private:
size_t current_iteration_index_;
std::vector<TraceEvent> logged_events_;
DISALLOW_COPY_AND_ASSIGN(TraceBufferVector);
};
class TraceBufferDiscardsEvents : public TraceBuffer {
public:
virtual ~TraceBufferDiscardsEvents() { }
virtual void AddEvent(const TraceEvent& event) OVERRIDE {}
virtual bool HasMoreEvents() const OVERRIDE { return false; }
virtual const TraceEvent& NextEvent() OVERRIDE {
NOTREACHED();
return *static_cast<TraceEvent*>(NULL);
}
virtual bool IsFull() const OVERRIDE { return false; }
virtual size_t CountEnabledByName(
const unsigned char* category,
const std::string& event_name) const OVERRIDE {
return 0;
}
virtual size_t Size() const OVERRIDE { return 0; }
virtual const TraceEvent& GetEventAt(size_t index) const OVERRIDE {
NOTREACHED();
return *static_cast<TraceEvent*>(NULL);
}
};
////////////////////////////////////////////////////////////////////////////////
//
// TraceEvent
//
////////////////////////////////////////////////////////////////////////////////
namespace {
size_t GetAllocLength(const char* str) { return str ? strlen(str) + 1 : 0; }
// Copies |*member| into |*buffer|, sets |*member| to point to this new
// location, and then advances |*buffer| by the amount written.
void CopyTraceEventParameter(char** buffer,
const char** member,
const char* end) {
if (*member) {
size_t written = strlcpy(*buffer, *member, end - *buffer) + 1;
DCHECK_LE(static_cast<int>(written), end - *buffer);
*member = *buffer;
*buffer += written;
}
}
} // namespace
TraceEvent::TraceEvent()
: id_(0u),
category_group_enabled_(NULL),
name_(NULL),
thread_id_(0),
phase_(TRACE_EVENT_PHASE_BEGIN),
flags_(0) {
arg_names_[0] = NULL;
arg_names_[1] = NULL;
memset(arg_values_, 0, sizeof(arg_values_));
}
TraceEvent::TraceEvent(
int thread_id,
TimeTicks timestamp,
char phase,
const unsigned char* category_group_enabled,
const char* name,
unsigned long long id,
int num_args,
const char** arg_names,
const unsigned char* arg_types,
const unsigned long long* arg_values,
scoped_ptr<ConvertableToTraceFormat> convertable_values[],
unsigned char flags)
: timestamp_(timestamp),
id_(id),
category_group_enabled_(category_group_enabled),
name_(name),
thread_id_(thread_id),
phase_(phase),
flags_(flags) {
// Clamp num_args since it may have been set by a third_party library.
num_args = (num_args > kTraceMaxNumArgs) ? kTraceMaxNumArgs : num_args;
int i = 0;
for (; i < num_args; ++i) {
arg_names_[i] = arg_names[i];
arg_types_[i] = arg_types[i];
if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE)
convertable_values_[i].reset(convertable_values[i].release());
else
arg_values_[i].as_uint = arg_values[i];
}
for (; i < kTraceMaxNumArgs; ++i) {
arg_names_[i] = NULL;
arg_values_[i].as_uint = 0u;
convertable_values_[i].reset();
arg_types_[i] = TRACE_VALUE_TYPE_UINT;
}
bool copy = !!(flags & TRACE_EVENT_FLAG_COPY);
size_t alloc_size = 0;
if (copy) {
alloc_size += GetAllocLength(name);
for (i = 0; i < num_args; ++i) {
alloc_size += GetAllocLength(arg_names_[i]);
if (arg_types_[i] == TRACE_VALUE_TYPE_STRING)
arg_types_[i] = TRACE_VALUE_TYPE_COPY_STRING;
}
}
bool arg_is_copy[kTraceMaxNumArgs];
for (i = 0; i < num_args; ++i) {
// No copying of convertable types, we retain ownership.
if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
continue;
// We only take a copy of arg_vals if they are of type COPY_STRING.
arg_is_copy[i] = (arg_types_[i] == TRACE_VALUE_TYPE_COPY_STRING);
if (arg_is_copy[i])
alloc_size += GetAllocLength(arg_values_[i].as_string);
}
if (alloc_size) {
parameter_copy_storage_ = new RefCountedString;
parameter_copy_storage_->data().resize(alloc_size);
char* ptr = string_as_array(&parameter_copy_storage_->data());
const char* end = ptr + alloc_size;
if (copy) {
CopyTraceEventParameter(&ptr, &name_, end);
for (i = 0; i < num_args; ++i) {
CopyTraceEventParameter(&ptr, &arg_names_[i], end);
}
}
for (i = 0; i < num_args; ++i) {
if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
continue;
if (arg_is_copy[i])
CopyTraceEventParameter(&ptr, &arg_values_[i].as_string, end);
}
DCHECK_EQ(end, ptr) << "Overrun by " << ptr - end;
}
}
TraceEvent::TraceEvent(const TraceEvent& other)
: timestamp_(other.timestamp_),
id_(other.id_),
category_group_enabled_(other.category_group_enabled_),
name_(other.name_),
thread_id_(other.thread_id_),
phase_(other.phase_),
flags_(other.flags_) {
parameter_copy_storage_ = other.parameter_copy_storage_;
for (int i = 0; i < kTraceMaxNumArgs; ++i) {
arg_values_[i] = other.arg_values_[i];
arg_names_[i] = other.arg_names_[i];
arg_types_[i] = other.arg_types_[i];
if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE) {
convertable_values_[i].reset(
const_cast<TraceEvent*>(&other)->convertable_values_[i].release());
} else {
convertable_values_[i].reset();
}
}
}
TraceEvent& TraceEvent::operator=(const TraceEvent& other) {
if (this == &other)
return *this;
timestamp_ = other.timestamp_;
id_ = other.id_;
category_group_enabled_ = other.category_group_enabled_;
name_ = other.name_;
parameter_copy_storage_ = other.parameter_copy_storage_;
thread_id_ = other.thread_id_;
phase_ = other.phase_;
flags_ = other.flags_;
for (int i = 0; i < kTraceMaxNumArgs; ++i) {
arg_values_[i] = other.arg_values_[i];
arg_names_[i] = other.arg_names_[i];
arg_types_[i] = other.arg_types_[i];
if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE) {
convertable_values_[i].reset(
const_cast<TraceEvent*>(&other)->convertable_values_[i].release());
} else {
convertable_values_[i].reset();
}
}
return *this;
}
TraceEvent::~TraceEvent() {
}
// static
void TraceEvent::AppendValueAsJSON(unsigned char type,
TraceEvent::TraceValue value,
std::string* out) {
std::string::size_type start_pos;
switch (type) {
case TRACE_VALUE_TYPE_BOOL:
*out += value.as_bool ? "true" : "false";
break;
case TRACE_VALUE_TYPE_UINT:
StringAppendF(out, "%" PRIu64, static_cast<uint64>(value.as_uint));
break;
case TRACE_VALUE_TYPE_INT:
StringAppendF(out, "%" PRId64, static_cast<int64>(value.as_int));
break;
case TRACE_VALUE_TYPE_DOUBLE:
StringAppendF(out, "%f", value.as_double);
break;
case TRACE_VALUE_TYPE_POINTER:
// JSON only supports double and int numbers.
// So as not to lose bits from a 64-bit pointer, output as a hex string.
StringAppendF(out, "\"0x%" PRIx64 "\"", static_cast<uint64>(
reinterpret_cast<intptr_t>(
value.as_pointer)));
break;
case TRACE_VALUE_TYPE_STRING:
case TRACE_VALUE_TYPE_COPY_STRING:
*out += "\"";
start_pos = out->size();
*out += value.as_string ? value.as_string : "NULL";
// insert backslash before special characters for proper json format.
while ((start_pos = out->find_first_of("\\\"", start_pos)) !=
std::string::npos) {
out->insert(start_pos, 1, '\\');
// skip inserted escape character and following character.
start_pos += 2;
}
*out += "\"";
break;
default:
NOTREACHED() << "Don't know how to print this value";
break;
}
}
void TraceEvent::AppendAsJSON(std::string* out) const {
int64 time_int64 = timestamp_.ToInternalValue();
int process_id = TraceLog::GetInstance()->process_id();
// Category group checked at category creation time.
DCHECK(!strchr(name_, '"'));
StringAppendF(out,
"{\"cat\":\"%s\",\"pid\":%i,\"tid\":%i,\"ts\":%" PRId64 ","
"\"ph\":\"%c\",\"name\":\"%s\",\"args\":{",
TraceLog::GetCategoryGroupName(category_group_enabled_),
process_id,
thread_id_,
time_int64,
phase_,
name_);
// Output argument names and values, stop at first NULL argument name.
for (int i = 0; i < kTraceMaxNumArgs && arg_names_[i]; ++i) {
if (i > 0)
*out += ",";
*out += "\"";
*out += arg_names_[i];
*out += "\":";
if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
convertable_values_[i]->AppendAsTraceFormat(out);
else
AppendValueAsJSON(arg_types_[i], arg_values_[i], out);
}
*out += "}";
// If id_ is set, print it out as a hex string so we don't loose any
// bits (it might be a 64-bit pointer).
if (flags_ & TRACE_EVENT_FLAG_HAS_ID)
StringAppendF(out, ",\"id\":\"0x%" PRIx64 "\"", static_cast<uint64>(id_));
// Instant events also output their scope.
if (phase_ == TRACE_EVENT_PHASE_INSTANT) {
char scope = '?';
switch (flags_ & TRACE_EVENT_FLAG_SCOPE_MASK) {
case TRACE_EVENT_SCOPE_GLOBAL:
scope = TRACE_EVENT_SCOPE_NAME_GLOBAL;
break;
case TRACE_EVENT_SCOPE_PROCESS:
scope = TRACE_EVENT_SCOPE_NAME_PROCESS;
break;
case TRACE_EVENT_SCOPE_THREAD:
scope = TRACE_EVENT_SCOPE_NAME_THREAD;
break;
}
StringAppendF(out, ",\"s\":\"%c\"", scope);
}
*out += "}";
}
void TraceEvent::AppendPrettyPrinted(std::ostringstream* out) const {
*out << name_ << "[";
*out << TraceLog::GetCategoryGroupName(category_group_enabled_);
*out << "]";
if (arg_names_[0]) {
*out << ", {";
for (int i = 0; i < kTraceMaxNumArgs && arg_names_[i]; ++i) {
if (i > 0)
*out << ", ";
*out << arg_names_[i] << ":";
std::string value_as_text;
if (arg_types_[i] == TRACE_VALUE_TYPE_CONVERTABLE)
convertable_values_[i]->AppendAsTraceFormat(&value_as_text);
else
AppendValueAsJSON(arg_types_[i], arg_values_[i], &value_as_text);
*out << value_as_text;
}
*out << "}";
}
}
////////////////////////////////////////////////////////////////////////////////
//
// TraceResultBuffer
//
////////////////////////////////////////////////////////////////////////////////
TraceResultBuffer::OutputCallback
TraceResultBuffer::SimpleOutput::GetCallback() {
return Bind(&SimpleOutput::Append, Unretained(this));
}
void TraceResultBuffer::SimpleOutput::Append(
const std::string& json_trace_output) {
json_output += json_trace_output;
}
TraceResultBuffer::TraceResultBuffer() : append_comma_(false) {
}
TraceResultBuffer::~TraceResultBuffer() {
}
void TraceResultBuffer::SetOutputCallback(
const OutputCallback& json_chunk_callback) {
output_callback_ = json_chunk_callback;
}
void TraceResultBuffer::Start() {
append_comma_ = false;
output_callback_.Run("[");
}
void TraceResultBuffer::AddFragment(const std::string& trace_fragment) {
if (append_comma_)
output_callback_.Run(",");
append_comma_ = true;
output_callback_.Run(trace_fragment);
}
void TraceResultBuffer::Finish() {
output_callback_.Run("]");
}
////////////////////////////////////////////////////////////////////////////////
//
// TraceSamplingThread
//
////////////////////////////////////////////////////////////////////////////////
class TraceBucketData;
typedef base::Callback<void(TraceBucketData*)> TraceSampleCallback;
class TraceBucketData {
public:
TraceBucketData(base::subtle::AtomicWord* bucket,
const char* name,
TraceSampleCallback callback);
~TraceBucketData();
TRACE_EVENT_API_ATOMIC_WORD* bucket;
const char* bucket_name;
TraceSampleCallback callback;
};
// This object must be created on the IO thread.
class TraceSamplingThread : public PlatformThread::Delegate {
public:
TraceSamplingThread();
virtual ~TraceSamplingThread();
// Implementation of PlatformThread::Delegate:
virtual void ThreadMain() OVERRIDE;
static void DefaultSampleCallback(TraceBucketData* bucekt_data);
void Stop();
void InstallWaitableEventForSamplingTesting(WaitableEvent* waitable_event);
private:
friend class TraceLog;
void GetSamples();
// Not thread-safe. Once the ThreadMain has been called, this can no longer
// be called.
void RegisterSampleBucket(TRACE_EVENT_API_ATOMIC_WORD* bucket,
const char* const name,
TraceSampleCallback callback);
// Splits a combined "category\0name" into the two component parts.
static void ExtractCategoryAndName(const char* combined,
const char** category,
const char** name);
std::vector<TraceBucketData> sample_buckets_;
bool thread_running_;
scoped_ptr<CancellationFlag> cancellation_flag_;
scoped_ptr<WaitableEvent> waitable_event_for_testing_;
};
TraceSamplingThread::TraceSamplingThread()
: thread_running_(false) {
cancellation_flag_.reset(new CancellationFlag);
}
TraceSamplingThread::~TraceSamplingThread() {
}
void TraceSamplingThread::ThreadMain() {
PlatformThread::SetName("Sampling Thread");
thread_running_ = true;
const int kSamplingFrequencyMicroseconds = 1000;
while (!cancellation_flag_->IsSet()) {
PlatformThread::Sleep(
TimeDelta::FromMicroseconds(kSamplingFrequencyMicroseconds));
GetSamples();
if (waitable_event_for_testing_.get())
waitable_event_for_testing_->Signal();
}
}
// static
void TraceSamplingThread::DefaultSampleCallback(TraceBucketData* bucket_data) {
TRACE_EVENT_API_ATOMIC_WORD category_and_name =
TRACE_EVENT_API_ATOMIC_LOAD(*bucket_data->bucket);
if (!category_and_name)
return;
const char* const combined =
reinterpret_cast<const char* const>(category_and_name);
const char* category_group;
const char* name;
ExtractCategoryAndName(combined, &category_group, &name);
TRACE_EVENT_API_ADD_TRACE_EVENT(TRACE_EVENT_PHASE_SAMPLE,
TraceLog::GetCategoryGroupEnabled(category_group),
name, 0, 0, NULL, NULL, NULL, NULL, 0);
}
void TraceSamplingThread::GetSamples() {
for (size_t i = 0; i < sample_buckets_.size(); ++i) {
TraceBucketData* bucket_data = &sample_buckets_[i];
bucket_data->callback.Run(bucket_data);
}
}
void TraceSamplingThread::RegisterSampleBucket(
TRACE_EVENT_API_ATOMIC_WORD* bucket,
const char* const name,
TraceSampleCallback callback) {
DCHECK(!thread_running_);
sample_buckets_.push_back(TraceBucketData(bucket, name, callback));
}
// static
void TraceSamplingThread::ExtractCategoryAndName(const char* combined,
const char** category,
const char** name) {
*category = combined;
*name = &combined[strlen(combined) + 1];
}
void TraceSamplingThread::Stop() {
cancellation_flag_->Set();
}
void TraceSamplingThread::InstallWaitableEventForSamplingTesting(
WaitableEvent* waitable_event) {
waitable_event_for_testing_.reset(waitable_event);
}
TraceBucketData::TraceBucketData(base::subtle::AtomicWord* bucket,
const char* name,
TraceSampleCallback callback)
: bucket(bucket),
bucket_name(name),
callback(callback) {
}
TraceBucketData::~TraceBucketData() {
}
////////////////////////////////////////////////////////////////////////////////
//
// TraceLog
//
////////////////////////////////////////////////////////////////////////////////
TraceLog::NotificationHelper::NotificationHelper(TraceLog* trace_log)
: trace_log_(trace_log),
notification_(0) {
}
TraceLog::NotificationHelper::~NotificationHelper() {
}
void TraceLog::NotificationHelper::AddNotificationWhileLocked(
int notification) {
if (trace_log_->notification_callback_.is_null())
return;
if (notification_ == 0)
callback_copy_ = trace_log_->notification_callback_;
notification_ |= notification;
}
void TraceLog::NotificationHelper::SendNotificationIfAny() {
if (notification_)
callback_copy_.Run(notification_);
}
// static
TraceLog* TraceLog::GetInstance() {
return Singleton<TraceLog, LeakySingletonTraits<TraceLog> >::get();
}
// static
// Note, if you add more options here you also need to update:
// content/browser/devtools/devtools_tracing_handler:TraceOptionsFromString
TraceLog::Options TraceLog::TraceOptionsFromString(const std::string& options) {
std::vector<std::string> split;
base::SplitString(options, ',', &split);
int ret = 0;
for (std::vector<std::string>::iterator iter = split.begin();
iter != split.end();
++iter) {
if (*iter == kRecordUntilFull) {
ret |= RECORD_UNTIL_FULL;
} else if (*iter == kRecordContinuously) {
ret |= RECORD_CONTINUOUSLY;
} else if (*iter == kEnableSampling) {
ret |= ENABLE_SAMPLING;
} else {
NOTREACHED(); // Unknown option provided.
}
}
if (!(ret & RECORD_UNTIL_FULL) && !(ret & RECORD_CONTINUOUSLY))
ret |= RECORD_UNTIL_FULL; // Default when no options are specified.
return static_cast<Options>(ret);
}
TraceLog::TraceLog()
: enable_count_(0),
num_traces_recorded_(0),
event_callback_(NULL),
dispatching_to_observer_list_(false),
process_sort_index_(0),
watch_category_(NULL),
trace_options_(RECORD_UNTIL_FULL),
sampling_thread_handle_(0),
category_filter_(CategoryFilter::kDefaultCategoryFilterString) {
// Trace is enabled or disabled on one thread while other threads are
// accessing the enabled flag. We don't care whether edge-case events are
// traced or not, so we allow races on the enabled flag to keep the trace
// macros fast.
// TODO(jbates): ANNOTATE_BENIGN_RACE_SIZED crashes windows TSAN bots:
// ANNOTATE_BENIGN_RACE_SIZED(g_category_group_enabled,
// sizeof(g_category_group_enabled),
// "trace_event category enabled");
for (int i = 0; i < MAX_CATEGORY_GROUPS; ++i) {
ANNOTATE_BENIGN_RACE(&g_category_group_enabled[i],
"trace_event category enabled");
}
#if defined(OS_NACL) // NaCl shouldn't expose the process id.
SetProcessID(0);
#else
SetProcessID(static_cast<int>(GetCurrentProcId()));
// NaCl also shouldn't access the command line.
if (CommandLine::InitializedForCurrentProcess() &&
CommandLine::ForCurrentProcess()->HasSwitch(switches::kTraceToConsole)) {
std::string category_string =
CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
switches::kTraceToConsole);
if (category_string.empty())
category_string = "*";
SetEnabled(CategoryFilter(category_string), ECHO_TO_CONSOLE);
}
#endif
logged_events_.reset(GetTraceBuffer());
}
TraceLog::~TraceLog() {
}
const unsigned char* TraceLog::GetCategoryGroupEnabled(
const char* category_group) {
TraceLog* tracelog = GetInstance();
if (!tracelog) {
DCHECK(!g_category_group_enabled[g_category_already_shutdown]);
return &g_category_group_enabled[g_category_already_shutdown];
}
return tracelog->GetCategoryGroupEnabledInternal(category_group);
}
const char* TraceLog::GetCategoryGroupName(
const unsigned char* category_group_enabled) {
// Calculate the index of the category group by finding
// category_group_enabled in g_category_group_enabled array.
uintptr_t category_begin =
reinterpret_cast<uintptr_t>(g_category_group_enabled);
uintptr_t category_ptr = reinterpret_cast<uintptr_t>(category_group_enabled);
DCHECK(category_ptr >= category_begin &&
category_ptr < reinterpret_cast<uintptr_t>(
g_category_group_enabled + MAX_CATEGORY_GROUPS)) <<
"out of bounds category pointer";
uintptr_t category_index =
(category_ptr - category_begin) / sizeof(g_category_group_enabled[0]);
return g_category_groups[category_index];
}
void TraceLog::UpdateCategoryGroupEnabledFlag(int category_index) {
bool is_enabled = enable_count_ && category_filter_.IsCategoryGroupEnabled(
g_category_groups[category_index]);
SetCategoryGroupEnabled(category_index, is_enabled);
}
void TraceLog::UpdateCategoryGroupEnabledFlags() {
for (int i = 0; i < g_category_index; i++)
UpdateCategoryGroupEnabledFlag(i);
}
void TraceLog::SetCategoryGroupEnabled(int category_index, bool is_enabled) {
g_category_group_enabled[category_index] =
is_enabled ? CATEGORY_GROUP_ENABLED : 0;
#if defined(OS_ANDROID)
ApplyATraceEnabledFlag(&g_category_group_enabled[category_index]);
#endif
}
bool TraceLog::IsCategoryGroupEnabled(
const unsigned char* category_group_enabled) {
// On Android, ATrace and normal trace can be enabled independently.
// This function checks if the normal trace is enabled.
return *category_group_enabled & CATEGORY_GROUP_ENABLED;
}
const unsigned char* TraceLog::GetCategoryGroupEnabledInternal(
const char* category_group) {
DCHECK(!strchr(category_group, '"')) <<
"Category groups may not contain double quote";
AutoLock lock(lock_);
unsigned char* category_group_enabled = NULL;
// Search for pre-existing category group.
for (int i = 0; i < g_category_index; i++) {
if (strcmp(g_category_groups[i], category_group) == 0) {
category_group_enabled = &g_category_group_enabled[i];
break;
}
}
if (!category_group_enabled) {
// Create a new category group
DCHECK(g_category_index < MAX_CATEGORY_GROUPS) <<
"must increase MAX_CATEGORY_GROUPS";
if (g_category_index < MAX_CATEGORY_GROUPS) {
int new_index = g_category_index++;
// Don't hold on to the category_group pointer, so that we can create
// category groups with strings not known at compile time (this is
// required by SetWatchEvent).
const char* new_group = strdup(category_group);
ANNOTATE_LEAKING_OBJECT_PTR(new_group);
g_category_groups[new_index] = new_group;
DCHECK(!g_category_group_enabled[new_index]);
// Note that if both included and excluded patterns in the
// CategoryFilter are empty, we exclude nothing,
// thereby enabling this category group.
UpdateCategoryGroupEnabledFlag(new_index);
category_group_enabled = &g_category_group_enabled[new_index];
} else {
category_group_enabled =
&g_category_group_enabled[g_category_categories_exhausted];
}
}
return category_group_enabled;
}
void TraceLog::GetKnownCategoryGroups(
std::vector<std::string>* category_groups) {
AutoLock lock(lock_);
for (int i = g_num_builtin_categories; i < g_category_index; i++)
category_groups->push_back(g_category_groups[i]);
}
void TraceLog::SetEnabled(const CategoryFilter& category_filter,
Options options) {
std::vector<EnabledStateObserver*> observer_list;
{
AutoLock lock(lock_);
if (enable_count_++ > 0) {
if (options != trace_options_) {
DLOG(ERROR) << "Attemting to re-enable tracing with a different "
<< "set of options.";
}
category_filter_.Merge(category_filter);
UpdateCategoryGroupEnabledFlags();
return;
}
if (options != trace_options_) {
trace_options_ = options;
logged_events_.reset(GetTraceBuffer());
}
if (dispatching_to_observer_list_) {
DLOG(ERROR) <<
"Cannot manipulate TraceLog::Enabled state from an observer.";
return;
}
num_traces_recorded_++;
category_filter_ = CategoryFilter(category_filter);
UpdateCategoryGroupEnabledFlags();
if (options & ENABLE_SAMPLING) {
sampling_thread_.reset(new TraceSamplingThread);
sampling_thread_->RegisterSampleBucket(
&g_trace_state[0],
"bucket0",
Bind(&TraceSamplingThread::DefaultSampleCallback));
sampling_thread_->RegisterSampleBucket(
&g_trace_state[1],
"bucket1",
Bind(&TraceSamplingThread::DefaultSampleCallback));
sampling_thread_->RegisterSampleBucket(
&g_trace_state[2],
"bucket2",
Bind(&TraceSamplingThread::DefaultSampleCallback));
if (!PlatformThread::Create(
0, sampling_thread_.get(), &sampling_thread_handle_)) {
DCHECK(false) << "failed to create thread";
}
}
dispatching_to_observer_list_ = true;
observer_list = enabled_state_observer_list_;
}
// Notify observers outside the lock in case they trigger trace events.
for (size_t i = 0; i < observer_list.size(); ++i)
observer_list[i]->OnTraceLogEnabled();
{
AutoLock lock(lock_);
dispatching_to_observer_list_ = false;
}
}
const CategoryFilter& TraceLog::GetCurrentCategoryFilter() {
AutoLock lock(lock_);
DCHECK(enable_count_ > 0);
return category_filter_;
}
void TraceLog::SetDisabled() {
std::vector<EnabledStateObserver*> observer_list;
{
AutoLock lock(lock_);
DCHECK(enable_count_ > 0);
if (--enable_count_ != 0)
return;
if (dispatching_to_observer_list_) {
DLOG(ERROR)
<< "Cannot manipulate TraceLog::Enabled state from an observer.";
return;
}
if (sampling_thread_.get()) {
// Stop the sampling thread.
sampling_thread_->Stop();
lock_.Release();
PlatformThread::Join(sampling_thread_handle_);
lock_.Acquire();
sampling_thread_handle_ = PlatformThreadHandle();
sampling_thread_.reset();
}
category_filter_.Clear();
watch_category_ = NULL;
watch_event_name_ = "";
UpdateCategoryGroupEnabledFlags();
AddMetadataEvents();
dispatching_to_observer_list_ = true;
observer_list = enabled_state_observer_list_;
}
// Dispatch to observers outside the lock in case the observer triggers a
// trace event.
for (size_t i = 0; i < observer_list.size(); ++i)
observer_list[i]->OnTraceLogDisabled();
{
AutoLock lock(lock_);
dispatching_to_observer_list_ = false;
}
}
int TraceLog::GetNumTracesRecorded() {
AutoLock lock(lock_);
if (enable_count_ == 0)
return -1;
return num_traces_recorded_;
}
void TraceLog::AddEnabledStateObserver(EnabledStateObserver* listener) {
enabled_state_observer_list_.push_back(listener);
}
void TraceLog::RemoveEnabledStateObserver(EnabledStateObserver* listener) {
std::vector<EnabledStateObserver*>::iterator it =
std::find(enabled_state_observer_list_.begin(),
enabled_state_observer_list_.end(),
listener);
if (it != enabled_state_observer_list_.end())
enabled_state_observer_list_.erase(it);
}
bool TraceLog::HasEnabledStateObserver(EnabledStateObserver* listener) const {
std::vector<EnabledStateObserver*>::const_iterator it =
std::find(enabled_state_observer_list_.begin(),
enabled_state_observer_list_.end(),
listener);
return it != enabled_state_observer_list_.end();
}
float TraceLog::GetBufferPercentFull() const {
return (float)((double)logged_events_->Size()/(double)kTraceEventBufferSize);
}
void TraceLog::SetNotificationCallback(
const TraceLog::NotificationCallback& cb) {
AutoLock lock(lock_);
notification_callback_ = cb;
}
TraceBuffer* TraceLog::GetTraceBuffer() {
if (trace_options_ & RECORD_CONTINUOUSLY)
return new TraceBufferRingBuffer();
else if (trace_options_ & ECHO_TO_CONSOLE)
return new TraceBufferDiscardsEvents();
return new TraceBufferVector();
}
void TraceLog::SetEventCallback(EventCallback cb) {
AutoLock lock(lock_);
event_callback_ = cb;
};
void TraceLog::Flush(const TraceLog::OutputCallback& cb) {
// Ignore memory allocations from here down.
INTERNAL_TRACE_MEMORY(TRACE_DISABLED_BY_DEFAULT("memory"),
TRACE_MEMORY_IGNORE);
scoped_ptr<TraceBuffer> previous_logged_events;
{
AutoLock lock(lock_);
previous_logged_events.swap(logged_events_);
logged_events_.reset(GetTraceBuffer());
} // release lock
while (previous_logged_events->HasMoreEvents()) {
scoped_refptr<RefCountedString> json_events_str_ptr =
new RefCountedString();
for (size_t i = 0; i < kTraceEventBatchSize; ++i) {
if (i > 0)
*(&(json_events_str_ptr->data())) += ",";
previous_logged_events->NextEvent().AppendAsJSON(
&(json_events_str_ptr->data()));
if (!previous_logged_events->HasMoreEvents())
break;
}
cb.Run(json_events_str_ptr);
}
}
void TraceLog::AddTraceEvent(
char phase,
const unsigned char* category_group_enabled,
const char* name,
unsigned long long id,
int num_args,
const char** arg_names,
const unsigned char* arg_types,
const unsigned long long* arg_values,
scoped_ptr<ConvertableToTraceFormat> convertable_values[],
unsigned char flags) {
int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
base::TimeTicks now = base::TimeTicks::NowFromSystemTraceTime();
AddTraceEventWithThreadIdAndTimestamp(phase, category_group_enabled, name, id,
thread_id, now, num_args, arg_names,
arg_types, arg_values,
convertable_values, flags);
}
void TraceLog::AddTraceEventWithThreadIdAndTimestamp(
char phase,
const unsigned char* category_group_enabled,
const char* name,
unsigned long long id,
int thread_id,
const TimeTicks& timestamp,
int num_args,
const char** arg_names,
const unsigned char* arg_types,
const unsigned long long* arg_values,
scoped_ptr<ConvertableToTraceFormat> convertable_values[],
unsigned char flags) {
DCHECK(name);
if (flags & TRACE_EVENT_FLAG_MANGLE_ID)
id ^= process_id_hash_;
#if defined(OS_ANDROID)
SendToATrace(phase, GetCategoryGroupName(category_group_enabled), name, id,
num_args, arg_names, arg_types, arg_values, convertable_values,
flags);
#endif
if (!IsCategoryGroupEnabled(category_group_enabled))
return;
TimeTicks now = timestamp - time_offset_;
EventCallback event_callback_copy;
NotificationHelper notifier(this);
// Check and update the current thread name only if the event is for the
// current thread to avoid locks in most cases.
if (thread_id == static_cast<int>(PlatformThread::CurrentId())) {
const char* new_name = ThreadIdNameManager::GetInstance()->
GetName(thread_id);
// Check if the thread name has been set or changed since the previous
// call (if any), but don't bother if the new name is empty. Note this will
// not detect a thread name change within the same char* buffer address: we
// favor common case performance over corner case correctness.
if (new_name != g_current_thread_name.Get().Get() &&
new_name && *new_name) {
g_current_thread_name.Get().Set(new_name);
AutoLock lock(lock_);
hash_map<int, std::string>::iterator existing_name =
thread_names_.find(thread_id);
if (existing_name == thread_names_.end()) {
// This is a new thread id, and a new name.
thread_names_[thread_id] = new_name;
} else {
// This is a thread id that we've seen before, but potentially with a
// new name.
std::vector<StringPiece> existing_names;
Tokenize(existing_name->second, ",", &existing_names);
bool found = std::find(existing_names.begin(),
existing_names.end(),
new_name) != existing_names.end();
if (!found) {
existing_name->second.push_back(',');
existing_name->second.append(new_name);
}
}
}
}
TraceEvent trace_event(thread_id,
now, phase, category_group_enabled, name, id,
num_args, arg_names, arg_types, arg_values,
convertable_values, flags);
do {
AutoLock lock(lock_);
event_callback_copy = event_callback_;
if (logged_events_->IsFull())
break;
logged_events_->AddEvent(trace_event);
if (trace_options_ & ECHO_TO_CONSOLE) {
TimeDelta duration;
if (phase == TRACE_EVENT_PHASE_END) {
duration = timestamp - thread_event_start_times_[thread_id].top();
thread_event_start_times_[thread_id].pop();
}
std::string thread_name = thread_names_[thread_id];
if (thread_colors_.find(thread_name) == thread_colors_.end())
thread_colors_[thread_name] = (thread_colors_.size() % 6) + 1;
std::ostringstream log;
log << base::StringPrintf("%s: \x1b[0;3%dm",
thread_name.c_str(),
thread_colors_[thread_name]);
size_t depth = 0;
if (thread_event_start_times_.find(thread_id) !=
thread_event_start_times_.end())
depth = thread_event_start_times_[thread_id].size();
for (size_t i = 0; i < depth; ++i)
log << "| ";
trace_event.AppendPrettyPrinted(&log);
if (phase == TRACE_EVENT_PHASE_END)
log << base::StringPrintf(" (%.3f ms)", duration.InMillisecondsF());
LOG(ERROR) << log.str() << "\x1b[0;m";
if (phase == TRACE_EVENT_PHASE_BEGIN)
thread_event_start_times_[thread_id].push(timestamp);
}
if (logged_events_->IsFull())
notifier.AddNotificationWhileLocked(TRACE_BUFFER_FULL);
if (watch_category_ == category_group_enabled && watch_event_name_ == name)
notifier.AddNotificationWhileLocked(EVENT_WATCH_NOTIFICATION);
} while (0); // release lock
notifier.SendNotificationIfAny();
if (event_callback_copy != NULL) {
event_callback_copy(phase, category_group_enabled, name, id,
num_args, arg_names, arg_types, arg_values,
flags);
}
}
void TraceLog::AddTraceEventEtw(char phase,
const char* name,
const void* id,
const char* extra) {
#if defined(OS_WIN)
TraceEventETWProvider::Trace(name, phase, id, extra);
#endif
INTERNAL_TRACE_EVENT_ADD(phase, "ETW Trace Event", name,
TRACE_EVENT_FLAG_COPY, "id", id, "extra", extra);
}
void TraceLog::AddTraceEventEtw(char phase,
const char* name,
const void* id,
const std::string& extra)
{
#if defined(OS_WIN)
TraceEventETWProvider::Trace(name, phase, id, extra);
#endif
INTERNAL_TRACE_EVENT_ADD(phase, "ETW Trace Event", name,
TRACE_EVENT_FLAG_COPY, "id", id, "extra", extra);
}
void TraceLog::SetWatchEvent(const std::string& category_name,
const std::string& event_name) {
const unsigned char* category = GetCategoryGroupEnabled(
category_name.c_str());
size_t notify_count = 0;
{
AutoLock lock(lock_);
watch_category_ = category;
watch_event_name_ = event_name;
// First, search existing events for watch event because we want to catch
// it even if it has already occurred.
notify_count = logged_events_->CountEnabledByName(category, event_name);
} // release lock
// Send notification for each event found.
for (size_t i = 0; i < notify_count; ++i) {
NotificationHelper notifier(this);
lock_.Acquire();
notifier.AddNotificationWhileLocked(EVENT_WATCH_NOTIFICATION);
lock_.Release();
notifier.SendNotificationIfAny();
}
}
void TraceLog::CancelWatchEvent() {
AutoLock lock(lock_);
watch_category_ = NULL;
watch_event_name_ = "";
}
namespace {
template <typename T>
void AddMetadataEventToBuffer(
TraceBuffer* logged_events,
int thread_id,
const char* metadata_name, const char* arg_name,
const T& value) {
int num_args = 1;
unsigned char arg_type;
unsigned long long arg_value;
trace_event_internal::SetTraceValue(value, &arg_type, &arg_value);
logged_events->AddEvent(TraceEvent(
thread_id,
TimeTicks(), TRACE_EVENT_PHASE_METADATA,
&g_category_group_enabled[g_category_metadata],
metadata_name, trace_event_internal::kNoEventId,
num_args, &arg_name, &arg_type, &arg_value, NULL,
TRACE_EVENT_FLAG_NONE));
}
}
void TraceLog::AddMetadataEvents() {
lock_.AssertAcquired();
int current_thread_id = static_cast<int>(base::PlatformThread::CurrentId());
if (process_sort_index_ != 0) {
AddMetadataEventToBuffer(logged_events_.get(),
current_thread_id,
"process_sort_index", "sort_index",
process_sort_index_);
}
if (process_name_.size()) {
AddMetadataEventToBuffer(logged_events_.get(),
current_thread_id,
"process_name", "name",
process_name_);
}
if (process_labels_.size() > 0) {
std::vector<std::string> labels;
for(base::hash_map<int, std::string>::iterator it = process_labels_.begin();
it != process_labels_.end();
it++) {
labels.push_back(it->second);
}
AddMetadataEventToBuffer(logged_events_.get(),
current_thread_id,
"process_labels", "labels",
JoinString(labels, ','));
}
// Thread sort indices.
for(hash_map<int, int>::iterator it = thread_sort_indices_.begin();
it != thread_sort_indices_.end();
it++) {
if (it->second == 0)
continue;
AddMetadataEventToBuffer(logged_events_.get(),
it->first,
"thread_sort_index", "sort_index",
it->second);
}
// Thread names.
for(hash_map<int, std::string>::iterator it = thread_names_.begin();
it != thread_names_.end();
it++) {
if (it->second.empty())
continue;
AddMetadataEventToBuffer(logged_events_.get(),
it->first,
"thread_name", "name",
it->second);
}
}
void TraceLog::InstallWaitableEventForSamplingTesting(
WaitableEvent* waitable_event) {
sampling_thread_->InstallWaitableEventForSamplingTesting(waitable_event);
}
void TraceLog::DeleteForTesting() {
DeleteTraceLogForTesting::Delete();
}
void TraceLog::SetProcessID(int process_id) {
process_id_ = process_id;
// Create a FNV hash from the process ID for XORing.
// See http://isthe.com/chongo/tech/comp/fnv/ for algorithm details.
unsigned long long offset_basis = 14695981039346656037ull;
unsigned long long fnv_prime = 1099511628211ull;
unsigned long long pid = static_cast<unsigned long long>(process_id_);
process_id_hash_ = (offset_basis ^ pid) * fnv_prime;
}
void TraceLog::SetProcessSortIndex(int sort_index) {
AutoLock lock(lock_);
process_sort_index_ = sort_index;
}
void TraceLog::SetProcessName(const std::string& process_name) {
AutoLock lock(lock_);
process_name_ = process_name;
}
void TraceLog::UpdateProcessLabel(
int label_id, const std::string& current_label) {
if(!current_label.length())
return RemoveProcessLabel(label_id);
AutoLock lock(lock_);
process_labels_[label_id] = current_label;
}
void TraceLog::RemoveProcessLabel(int label_id) {
AutoLock lock(lock_);
base::hash_map<int, std::string>::iterator it = process_labels_.find(
label_id);
if (it == process_labels_.end())
return;
process_labels_.erase(it);
}
void TraceLog::SetThreadSortIndex(PlatformThreadId thread_id, int sort_index) {
AutoLock lock(lock_);
thread_sort_indices_[static_cast<int>(thread_id)] = sort_index;
}
void TraceLog::SetTimeOffset(TimeDelta offset) {
time_offset_ = offset;
}
size_t TraceLog::GetObserverCountForTest() const {
return enabled_state_observer_list_.size();
}
bool CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
const std::string& str) {
return str.empty() ||
str.at(0) == ' ' ||
str.at(str.length() - 1) == ' ';
}
bool CategoryFilter::DoesCategoryGroupContainCategory(
const char* category_group,
const char* category) const {
DCHECK(category);
CStringTokenizer category_group_tokens(category_group,
category_group + strlen(category_group), ",");
while (category_group_tokens.GetNext()) {
std::string category_group_token = category_group_tokens.token();
// Don't allow empty tokens, nor tokens with leading or trailing space.
DCHECK(!CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
category_group_token))
<< "Disallowed category string";
if (MatchPattern(category_group_token.c_str(), category))
return true;
}
return false;
}
CategoryFilter::CategoryFilter(const std::string& filter_string) {
if (!filter_string.empty())
Initialize(filter_string);
else
Initialize(CategoryFilter::kDefaultCategoryFilterString);
}
CategoryFilter::CategoryFilter(const CategoryFilter& cf)
: included_(cf.included_),
disabled_(cf.disabled_),
excluded_(cf.excluded_) {
}
CategoryFilter::~CategoryFilter() {
}
CategoryFilter& CategoryFilter::operator=(const CategoryFilter& rhs) {
if (this == &rhs)
return *this;
included_ = rhs.included_;
disabled_ = rhs.disabled_;
excluded_ = rhs.excluded_;
return *this;
}
void CategoryFilter::Initialize(const std::string& filter_string) {
// Tokenize list of categories, delimited by ','.
StringTokenizer tokens(filter_string, ",");
// Add each token to the appropriate list (included_,excluded_).
while (tokens.GetNext()) {
std::string category = tokens.token();
// Ignore empty categories.
if (category.empty())
continue;
// Excluded categories start with '-'.
if (category.at(0) == '-') {
// Remove '-' from category string.
category = category.substr(1);
excluded_.push_back(category);
} else if (category.compare(0, strlen(TRACE_DISABLED_BY_DEFAULT("")),
TRACE_DISABLED_BY_DEFAULT("")) == 0) {
disabled_.push_back(category);
} else {
included_.push_back(category);
}
}
}
void CategoryFilter::WriteString(const StringList& values,
std::string* out,
bool included) const {
bool prepend_comma = !out->empty();
int token_cnt = 0;
for (StringList::const_iterator ci = values.begin();
ci != values.end(); ++ci) {
if (token_cnt > 0 || prepend_comma)
StringAppendF(out, ",");
StringAppendF(out, "%s%s", (included ? "" : "-"), ci->c_str());
++token_cnt;
}
}
std::string CategoryFilter::ToString() const {
std::string filter_string;
WriteString(included_, &filter_string, true);
WriteString(disabled_, &filter_string, true);
WriteString(excluded_, &filter_string, false);
return filter_string;
}
bool CategoryFilter::IsCategoryGroupEnabled(
const char* category_group_name) const {
// TraceLog should call this method only as part of enabling/disabling
// categories.
StringList::const_iterator ci;
// Check the disabled- filters and the disabled-* wildcard first so that a
// "*" filter does not include the disabled.
for (ci = disabled_.begin(); ci != disabled_.end(); ++ci) {
if (DoesCategoryGroupContainCategory(category_group_name, ci->c_str()))
return true;
}
if (DoesCategoryGroupContainCategory(category_group_name,
TRACE_DISABLED_BY_DEFAULT("*")))
return false;
for (ci = included_.begin(); ci != included_.end(); ++ci) {
if (DoesCategoryGroupContainCategory(category_group_name, ci->c_str()))
return true;
}
for (ci = excluded_.begin(); ci != excluded_.end(); ++ci) {
if (DoesCategoryGroupContainCategory(category_group_name, ci->c_str()))
return false;
}
// If the category group is not excluded, and there are no included patterns
// we consider this pattern enabled.
return included_.empty();
}
bool CategoryFilter::HasIncludedPatterns() const {
return !included_.empty();
}
void CategoryFilter::Merge(const CategoryFilter& nested_filter) {
// Keep included patterns only if both filters have an included entry.
// Otherwise, one of the filter was specifying "*" and we want to honour the
// broadest filter.
if (HasIncludedPatterns() && nested_filter.HasIncludedPatterns()) {
included_.insert(included_.end(),
nested_filter.included_.begin(),
nested_filter.included_.end());
} else {
included_.clear();
}
disabled_.insert(disabled_.end(),
nested_filter.disabled_.begin(),
nested_filter.disabled_.end());
excluded_.insert(excluded_.end(),
nested_filter.excluded_.begin(),
nested_filter.excluded_.end());
}
void CategoryFilter::Clear() {
included_.clear();
disabled_.clear();
excluded_.clear();
}
} // namespace debug
} // namespace base
namespace trace_event_internal {
ScopedTrace::ScopedTrace(
TRACE_EVENT_API_ATOMIC_WORD* event_uid, const char* name) {
category_group_enabled_ =
reinterpret_cast<const unsigned char*>(TRACE_EVENT_API_ATOMIC_LOAD(
*event_uid));
if (!category_group_enabled_) {
category_group_enabled_ = TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("gpu");
TRACE_EVENT_API_ATOMIC_STORE(
*event_uid,
reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD>(category_group_enabled_));
}
if (*category_group_enabled_) {
name_ = name;
TRACE_EVENT_API_ADD_TRACE_EVENT(
TRACE_EVENT_PHASE_BEGIN, // phase
category_group_enabled_, // category enabled
name, // name
0, // id
0, // num_args
NULL, // arg_names
NULL, // arg_types
NULL, // arg_values
NULL, // convertable_values
TRACE_EVENT_FLAG_NONE); // flags
} else {
category_group_enabled_ = NULL;
}
}
ScopedTrace::~ScopedTrace() {
if (category_group_enabled_ && *category_group_enabled_) {
TRACE_EVENT_API_ADD_TRACE_EVENT(
TRACE_EVENT_PHASE_END, // phase
category_group_enabled_, // category enabled
name_, // name
0, // id
0, // num_args
NULL, // arg_names
NULL, // arg_types
NULL, // arg_values
NULL, // convertable values
TRACE_EVENT_FLAG_NONE); // flags
}
}
} // namespace trace_event_internal