Changed the GPU Tracer so the category names can be customized.

gpu/command_buffer/service/gpu_tracer.cc

 // 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 "gpu/command_buffer/service/gpu_tracer.h"
 
 #include <deque>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 
 namespace gpu {
 namespace gles2 {
 
 static const unsigned int kProcessInterval = 16;
 static TraceOutputter* g_outputter_thread = NULL;
 
-TraceMarker::TraceMarker(const std::string& name)
-    : name_(name),
+TraceMarker::TraceMarker(const std::string& category, const std::string& name)
+    : category_(category),
+      name_(name),
       trace_(NULL) {
 }
 
 TraceMarker::~TraceMarker() {
 }
 
 scoped_refptr<TraceOutputter> TraceOutputter::Create(const std::string& name) {
   if (!g_outputter_thread) {
     g_outputter_thread = new TraceOutputter(name);
   }
   return g_outputter_thread;
 }
 
 TraceOutputter::TraceOutputter(const std::string& name)
     : named_thread_(name.c_str()), local_trace_id_(0) {
   named_thread_.Start();
   named_thread_.Stop();
 }
 
 TraceOutputter::~TraceOutputter() { g_outputter_thread = NULL; }
 
-void TraceOutputter::Trace(const std::string& name,
+void TraceOutputter::Trace(const std::string& category,
+                           const std::string& name,
                            int64 start_time,
                            int64 end_time) {
-  TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(
-      TRACE_DISABLED_BY_DEFAULT("gpu.device"),
-      name.c_str(),
-      local_trace_id_,
-      named_thread_.thread_id(),
-      start_time);
-  TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0(
-      TRACE_DISABLED_BY_DEFAULT("gpu.device"),
-      name.c_str(),
-      local_trace_id_,
-      named_thread_.thread_id(),
-      end_time);
+  TRACE_EVENT_COPY_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(category.c_str(),
+                                                    name.c_str(),
+                                                    local_trace_id_,
+                                                    named_thread_.thread_id(),
+                                                    start_time);
+  TRACE_EVENT_COPY_END_WITH_ID_TID_AND_TIMESTAMP0(category.c_str(),
+                                                  name.c_str(),
+                                                  local_trace_id_,
+                                                  named_thread_.thread_id(),
+                                                  end_time);
   ++local_trace_id_;
 }
 
 GPUTrace::GPUTrace(scoped_refptr<Outputter> outputter,
+                   const std::string& category,
                    const std::string& name,
                    int64 offset,
                    GpuTracerType tracer_type)
-    : name_(name),
+    : category_(category),
+      name_(name),
       outputter_(outputter),
       offset_(offset),
       start_time_(0),
       end_time_(0),
       tracer_type_(tracer_type),
       end_requested_(false) {
   memset(queries_, 0, sizeof(queries_));
   switch (tracer_type_) {
     case kTracerTypeARBTimer:
     case kTracerTypeDisjointTimer:
@@ skipping 11 matching lines @@
       break;
 
     case kTracerTypeARBTimer:
     case kTracerTypeDisjointTimer:
       glDeleteQueriesARB(2, queries_);
       break;
   }
 }
 
 void GPUTrace::Start() {
-  TRACE_EVENT_COPY_ASYNC_BEGIN0(
-      TRACE_DISABLED_BY_DEFAULT("gpu.service"), name().c_str(), this);
+  TRACE_EVENT_COPY_ASYNC_BEGIN0(category().c_str(), name().c_str(), this);

[vmiura, 2014/12/08 23:23:06]

Shoud we check the gpu.service category is enabled here?

if (*gpu_trace_srv_category) {
  TRACE_EVENT_COPY_ASYNC_BEGIN0(category().c_str(), name().c_str(), this);
}

[David Yen, 2014/12/08 23:45:38]

I believe Start() is only called from the GPUTracer when IsTracing() is false,
which does the category checking.

[vmiura, 2014/12/08 23:53:00]

True, but IsTracing() returns true both (*gpu_trace_srv_category != 0) ||
(*gpu_trace_dev_category != 0).

If the user turns on gpu.device, won't they effectively get the gpu.service
events as well?  Checking for *gpu_trace_srv_category will block that.

[David Yen, 2014/12/09 00:10:41]

Good point, done.

 
   switch (tracer_type_) {
     case kTracerTypeInvalid:
       break;
 
     case kTracerTypeDisjointTimer:
       // For the disjoint timer, GPU idle time does not seem to increment the
       // internal counter. We must calculate the offset before any query. The
       // good news is any device that supports disjoint timer will also support
       // glGetInteger64v, so we can query it directly unlike the ARBTimer case.
@@ skipping 19 matching lines @@
     case kTracerTypeInvalid:
       break;
 
     case kTracerTypeARBTimer:
     case kTracerTypeDisjointTimer:
       // GL_TIMESTAMP and GL_TIMESTAMP_EXT both have the same value.
       glQueryCounter(queries_[1], GL_TIMESTAMP);
       break;
   }
 
-  TRACE_EVENT_COPY_ASYNC_END0(
-      TRACE_DISABLED_BY_DEFAULT("gpu.service"), name().c_str(), this);
+  TRACE_EVENT_COPY_ASYNC_END0(category().c_str(), name().c_str(), this);

[vmiura, 2014/12/08 23:23:06]

And here.

if (*gpu_trace_srv_category) {
  ...
}

[David Yen, 2014/12/08 23:45:38]

Same reason as above.

[David Yen, 2014/12/09 00:10:41]

Done.

 }
 
 bool GPUTrace::IsAvailable() {
   if (tracer_type_ != kTracerTypeInvalid) {
     if (!end_requested_)
       return false;
 
     GLint done = 0;
     glGetQueryObjectiv(queries_[1], GL_QUERY_RESULT_AVAILABLE, &done);
     return !!done;
@@ skipping 13 matching lines @@
 
   // TODO(dsinclair): It's possible for the timer to wrap during the start/end.
   // We need to detect if the end is less then the start and correct for the
   // wrapping.
   glGetQueryObjectui64v(queries_[0], GL_QUERY_RESULT, &begin_stamp);
   glGetQueryObjectui64v(queries_[1], GL_QUERY_RESULT, &end_stamp);
 
   start_time_ = (begin_stamp / base::Time::kNanosecondsPerMicrosecond) +
                 offset_;
   end_time_ = (end_stamp / base::Time::kNanosecondsPerMicrosecond) + offset_;
-  outputter_->Trace(name(), start_time_, end_time_);
+  outputter_->Trace(category(), name(), start_time_, end_time_);
 }
 
 GPUTracer::GPUTracer(gles2::GLES2Decoder* decoder)
     : gpu_trace_srv_category(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
           TRACE_DISABLED_BY_DEFAULT("gpu.service"))),
       gpu_trace_dev_category(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
           TRACE_DISABLED_BY_DEFAULT("gpu.device"))),
       decoder_(decoder),
       timer_offset_(0),
       last_tracer_source_(kTraceGroupInvalid),
@@ skipping 23 matching lines @@
   if (IsTracing()) {
     // Reset disjoint bit for the disjoint timer.
     if (tracer_type_ == kTracerTypeDisjointTimer) {
       GLint disjoint_value = 0;
       glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjoint_value);
     }
 
     // Begin a Trace for all active markers
     for (int n = 0; n < NUM_TRACER_SOURCES; n++) {
       for (size_t i = 0; i < markers_[n].size(); i++) {
-        markers_[n][i].trace_ = CreateTrace(markers_[n][i].name_);
-        markers_[n][i].trace_->Start();
+        TraceMarker& trace_marker = markers_[n][i];
+        trace_marker.trace_ = CreateTrace(trace_marker.category_,
+                                          trace_marker.name_);
+        trace_marker.trace_->Start();
       }
     }
   }
   return true;
 }
 
 bool GPUTracer::EndDecoding() {
   if (!gpu_executing_)
     return false;
 
@@ skipping 12 matching lines @@
     IssueProcessTask();
   }
 
   gpu_executing_ = false;
 
   // NOTE(vmiura): glFlush() here can help give better trace results,
   // but it distorts the normal device behavior.
   return true;
 }
 
-bool GPUTracer::Begin(const std::string& name, GpuTracerSource source) {
+bool GPUTracer::Begin(const std::string& category, const std::string& name,
+                      GpuTracerSource source) {
   if (!gpu_executing_)
     return false;
 
   DCHECK(source >= 0 && source < NUM_TRACER_SOURCES);
 
   // Push new marker from given 'source'
   last_tracer_source_ = source;
-  markers_[source].push_back(TraceMarker(name));
+  markers_[source].push_back(TraceMarker(category, name));
 
   // Create trace
   if (IsTracing()) {
-    scoped_refptr<GPUTrace> trace = CreateTrace(name);
+    scoped_refptr<GPUTrace> trace = CreateTrace(category, name);
     trace->Start();
     markers_[source].back().trace_ = trace;
   }
 
   return true;
 }
 
 bool GPUTracer::End(GpuTracerSource source) {
   if (!gpu_executing_)
     return false;
@@ skipping 15 matching lines @@
     markers_[source].pop_back();
     return true;
   }
   return false;
 }
 
 bool GPUTracer::IsTracing() {
   return (*gpu_trace_srv_category != 0) || (*gpu_trace_dev_category != 0);
 }
 
+const std::string& GPUTracer::CurrentCategory() const {
+  if (last_tracer_source_ >= 0 &&
+      last_tracer_source_ < NUM_TRACER_SOURCES &&
+      !markers_[last_tracer_source_].empty()) {
+    return markers_[last_tracer_source_].back().category_;
+  }
+  return base::EmptyString();
+}
+
 const std::string& GPUTracer::CurrentName() const {
   if (last_tracer_source_ >= 0 &&
       last_tracer_source_ < NUM_TRACER_SOURCES &&
       !markers_[last_tracer_source_].empty()) {
     return markers_[last_tracer_source_].back().name_;
   }
   return base::EmptyString();
 }
 
-scoped_refptr<GPUTrace> GPUTracer::CreateTrace(const std::string& name) {
+scoped_refptr<GPUTrace> GPUTracer::CreateTrace(const std::string& category,
+                                               const std::string& name) {
   GpuTracerType tracer_type = *gpu_trace_dev_category ? tracer_type_ :
                                                         kTracerTypeInvalid;
 
-  return new GPUTrace(outputter_, name, timer_offset_, tracer_type);
+  return new GPUTrace(outputter_, category, name, timer_offset_, tracer_type);
 }
 
 void GPUTracer::Process() {
   process_posted_ = false;
   ProcessTraces();
   IssueProcessTask();
 }
 
 void GPUTracer::ProcessTraces() {
   if (tracer_type_ == kTracerTypeInvalid) {
@@ skipping 74 matching lines @@
 
   process_posted_ = true;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&GPUTracer::Process, base::AsWeakPtr(this)),
       base::TimeDelta::FromMilliseconds(kProcessInterval));
 }
 
 }  // namespace gles2
 }  // namespace gpu