Added unit tests for the GPU Tracer.

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;
 
+CPUTime::CPUTime() {
+}
+
+int64 CPUTime::GetCurrentTime() {
+  return base::TimeTicks::NowFromSystemTraceTime().ToInternalValue();
+}
+
+CPUTime::~CPUTime() {
+}
+
 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& category,
-                           const std::string& name,
-                           int64 start_time,
-                           int64 end_time) {
+void TraceOutputter::TraceDevice(const std::string& category,
+                                 const std::string& name,
+                                 int64 start_time,
+                                 int64 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_;
 }
 
+void TraceOutputter::TraceServiceBegin(const std::string& category,
+                                       const std::string& name,
+                                       void* id) {
+  TRACE_EVENT_COPY_ASYNC_BEGIN0(category.c_str(), name.c_str(), id);

[vmiura, 2015/01/07 00:40:56]

Using dynamic category strings isn't working right.  Are you planning to land
that fix after?

[David Yen, 2015/01/07 18:11:47]

Yes, that change is still in the other CL where gl_category is also added:
https://codereview.chromium.org/813573003/

+}
+
+void TraceOutputter::TraceServiceEnd(const std::string& category,
+                                     const std::string& name,
+                                     void* id) {
+  TRACE_EVENT_COPY_ASYNC_END0(category.c_str(), name.c_str(), id);
+}
+
 GPUTrace::GPUTrace(scoped_refptr<Outputter> outputter,
+                   scoped_refptr<CPUTime> cpu_time,
                    const std::string& category,
                    const std::string& name,
                    int64 offset,
                    GpuTracerType tracer_type)
     : category_(category),
       name_(name),
       outputter_(outputter),
+      cpu_time_(cpu_time),
       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:
       glGenQueriesARB(2, queries_);
@@ skipping 11 matching lines @@
 
     case kTracerTypeARBTimer:
     case kTracerTypeDisjointTimer:
       glDeleteQueriesARB(2, queries_);
       break;
   }
 }
 
 void GPUTrace::Start(bool trace_service) {
   if (trace_service) {
-    TRACE_EVENT_COPY_ASYNC_BEGIN0(category().c_str(), name().c_str(), this);
+    outputter_->TraceServiceBegin(category_, name_, this);
   }
 
   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.
       // The "offset_" variable will always be 0 during normal use cases, only
       // under the unit tests will it be set to specific test values.
       if (offset_ == 0) {
         GLint64 gl_now = 0;
         glGetInteger64v(GL_TIMESTAMP, &gl_now);
-        offset_ = base::TimeTicks::NowFromSystemTraceTime().ToInternalValue() -
+        offset_ = cpu_time_->GetCurrentTime() -
                   gl_now / base::Time::kNanosecondsPerMicrosecond;
       }
       // Intentionally fall through to kTracerTypeARBTimer case.xs
     case kTracerTypeARBTimer:
       // GL_TIMESTAMP and GL_TIMESTAMP_EXT both have the same value.
       glQueryCounter(queries_[0], GL_TIMESTAMP);
       break;
   }
 }
 
 void GPUTrace::End(bool tracing_service) {
   end_requested_ = true;
   switch (tracer_type_) {
     case kTracerTypeInvalid:
       break;
 
     case kTracerTypeARBTimer:
     case kTracerTypeDisjointTimer:
       // GL_TIMESTAMP and GL_TIMESTAMP_EXT both have the same value.
       glQueryCounter(queries_[1], GL_TIMESTAMP);
       break;
   }
 
   if (tracing_service) {
-    TRACE_EVENT_COPY_ASYNC_END0(category().c_str(), name().c_str(), this);
+    outputter_->TraceServiceEnd(category_, name_, this);
   }
 }
 
 bool GPUTrace::IsAvailable() {
   if (tracer_type_ != kTracerTypeInvalid) {
     if (!end_requested_)
       return false;
 
     GLint done = 0;
     glGetQueryObjectiv(queries_[1], GL_QUERY_RESULT_AVAILABLE, &done);
@@ skipping 14 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(category(), name(), start_time_, end_time_);
+  outputter_->TraceDevice(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),
       tracer_type_(kTracerTypeInvalid),
       gpu_timing_synced_(false),
       gpu_executing_(false),
       process_posted_(false) {
-  if (gfx::g_driver_gl.ext.b_GL_EXT_disjoint_timer_query) {
-    tracer_type_ = kTracerTypeDisjointTimer;
-    outputter_ = TraceOutputter::Create("GL_EXT_disjoint_timer_query");
-  } else if (gfx::g_driver_gl.ext.b_GL_ARB_timer_query) {
-    tracer_type_ = kTracerTypeARBTimer;
-    outputter_ = TraceOutputter::Create("GL_ARB_timer_query");
-  }
 }
 
 GPUTracer::~GPUTracer() {
 }
 
 bool GPUTracer::BeginDecoding() {
   if (gpu_executing_)
     return false;
 
+  if (outputter_ == NULL) {
+    tracer_type_ = DetermineTracerType();
+    const char* tracer_type_name = "Unknown";
+    switch (tracer_type_) {
+      case kTracerTypeDisjointTimer:
+        tracer_type_name = "GL_EXT_disjoint_timer_query";
+        break;
+      case kTracerTypeARBTimer:
+        tracer_type_name = "GL_ARB_timer_query";
+        break;
+
+      default:
+        break;
+    }
+
+    outputter_ = CreateOutputter(tracer_type_name);
+  }
+
+  if (cpu_time_ == NULL) {
+    cpu_time_ = CreateCPUTime();
+  }
+
   CalculateTimerOffset();
   gpu_executing_ = true;
 
   if (IsTracing()) {
     // Reset disjoint bit for the disjoint timer.
     if (tracer_type_ == kTracerTypeDisjointTimer) {
       GLint disjoint_value = 0;
       glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjoint_value);
     }
 
@@ skipping 101 matching lines @@
     return markers_[last_tracer_source_].back().name_;
   }
   return base::EmptyString();
 }
 
 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_, category, name, timer_offset_, tracer_type);
+  return new GPUTrace(outputter_, cpu_time_, category, name,
+                      timer_offset_, tracer_type);
+}
+
+scoped_refptr<Outputter> GPUTracer::CreateOutputter(const std::string& name) {
+  return TraceOutputter::Create(name);
+}
+
+scoped_refptr<CPUTime> GPUTracer::CreateCPUTime() {
+  return new CPUTime();
+}
+
+GpuTracerType GPUTracer::DetermineTracerType() {
+  if (gfx::g_driver_gl.ext.b_GL_EXT_disjoint_timer_query) {
+    return kTracerTypeDisjointTimer;
+  } else if (gfx::g_driver_gl.ext.b_GL_ARB_timer_query) {
+    return kTracerTypeARBTimer;
+  }
+
+  return kTracerTypeInvalid;
+}
+
+void GPUTracer::PostTask() {
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&GPUTracer::Process, base::AsWeakPtr(this)),
+      base::TimeDelta::FromMilliseconds(kProcessInterval));
 }
 
 void GPUTracer::Process() {
   process_posted_ = false;
   ProcessTraces();
   IssueProcessTask();
 }
 
 void GPUTracer::ProcessTraces() {
   if (tracer_type_ == kTracerTypeInvalid) {
     traces_.clear();
     return;
   }
 
   TRACE_EVENT0("gpu", "GPUTracer::ProcessTraces");
 
   // Make owning decoder's GL context current
-  if (!decoder_->MakeCurrent()) {
+  if (decoder_ && !decoder_->MakeCurrent()) {

[vmiura, 2015/01/07 00:40:56]

Should the tests use a mock decoder instead?

[David Yen, 2015/01/07 18:11:48]

Done.

     // Skip subsequent GL calls if MakeCurrent fails
     traces_.clear();
     return;
   }
 
   // Check if disjoint operation has occurred, discard ongoing traces if so.
   if (tracer_type_ == kTracerTypeDisjointTimer) {
     GLint disjoint_value = 0;
     glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjoint_value);
     if (disjoint_value)
@@ skipping 35 matching lines @@
 
     glGenQueriesARB(1, &query);
 
     glFinish();
     glQueryCounter(query, GL_TIMESTAMP);
     glFinish();
 
     glGetQueryObjectui64v(query, GL_QUERY_RESULT, &gl_now);
     glDeleteQueriesARB(1, &query);
 
-    base::TimeTicks system_now = base::TimeTicks::NowFromSystemTraceTime();
-
     gl_now /= base::Time::kNanosecondsPerMicrosecond;
-    timer_offset_ = system_now.ToInternalValue() - gl_now;
+    timer_offset_ = cpu_time_->GetCurrentTime() - gl_now;
     gpu_timing_synced_ = true;
   }
 }
 
 void GPUTracer::IssueProcessTask() {
   if (traces_.empty() || process_posted_)
     return;
 
   process_posted_ = true;
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&GPUTracer::Process, base::AsWeakPtr(this)),
-      base::TimeDelta::FromMilliseconds(kProcessInterval));
+  PostTask();
 }
 
 }  // namespace gles2
 }  // namespace gpu