Hookup the GPUTrace events.

gpu/command_buffer/service/gpu_tracer.cc

Index: gpu/command_buffer/service/gpu_tracer.cc
diff --git a/gpu/command_buffer/service/gpu_tracer.cc b/gpu/command_buffer/service/gpu_tracer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4afd79331ac8097308cd583c16f5d5b6945202df
--- /dev/null
+++ b/gpu/command_buffer/service/gpu_tracer.cc
@@ -0,0 +1,287 @@
+// 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 <stack>
+
+#include "base/bind.h"
+#include "base/debug/trace_event.h"
+#include "base/threading/non_thread_safe.h"
+#include "base/threading/thread.h"
+#include "base/time.h"
+#include "ui/gl/gl_bindings.h"
+
+namespace gpu {
+namespace gles2 {
+namespace {
+
+static const unsigned int kGPUTraceMaxQueueSize = 1024;
+
+class Outputter
+    : public base::Thread,
+      public base::RefCounted<Outputter> {
+ public:
+  static scoped_refptr<Outputter> Create(const std::string& name) {
+    if (!g_outputter_thread) {
+      g_outputter_thread = new Outputter(name);
+      g_outputter_thread->Start();
+    }
+    return g_outputter_thread;
+  }
+
+ protected:

[jonathan.backer, 2012/11/30 20:25:45]

private?

[dsinclair, 2012/11/30 21:51:41]

Done.

+  explicit Outputter(const std::string& name) : base::Thread(name.c_str()) {}
+
+  virtual ~Outputter() {
+    g_outputter_thread->Stop();
+    g_outputter_thread = NULL;
+  }
+
+  static Outputter* g_outputter_thread;
+
+ private:
+  friend class base::RefCounted<Outputter>;
+
+  DISALLOW_COPY_AND_ASSIGN(Outputter);
+};
+Outputter* Outputter::g_outputter_thread = NULL;

[jonathan.backer, 2012/11/30 20:25:45]

nit: newline?

[dsinclair, 2012/11/30 21:51:41]

Done.

+
+class Trace : public base::RefCountedThreadSafe<Trace> {
+ public:
+  virtual void Start() = 0;
+  virtual void End() = 0;
+
+  // True if the the results of this query are available.
+  virtual bool IsAvailable() = 0;
+
+  virtual void Process(scoped_refptr<Outputter> output) = 0;

[jonathan.backer, 2012/11/30 20:25:45]

I'd just pass this in the constructor and hold a ref. Then the no-op doesn't
have it.

[dsinclair, 2012/11/30 21:51:41]

Done.

+
+ protected:
+  explicit Trace(const std::string& name) : name_(name) {}
+  virtual ~Trace() {};
+
+  const char* name() {
+    return name_.c_str();

[jonathan.backer, 2012/11/30 20:25:45]

Do we need this for the no-op?

[dsinclair, 2012/11/30 21:51:41]

Yes, we'll need to use this to get the name for the service ASYNC trace output.

+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<Trace>;
+
+  std::string name_;
+
+  DISALLOW_COPY_AND_ASSIGN(Trace);
+};
+
+class GLARBTimerTrace : public Trace {
+ public:
+  explicit GLARBTimerTrace(const std::string& name, int64 offset);

[jonathan.backer, 2012/11/30 20:25:45]

no longer need explicit

[dsinclair, 2012/11/30 21:51:41]

Done.

+

[jonathan.backer, 2012/11/30 20:25:45]

// Implementation of gpu::Tracer.

[dsinclair, 2012/11/30 21:51:41]

Done.

+  void Start() OVERRIDE;

[jonathan.backer, 2012/11/30 20:25:45]

still virtual.

[dsinclair, 2012/11/30 21:51:41]

Done.

+  void End() OVERRIDE;
+  bool IsAvailable() OVERRIDE;
+  void Process(scoped_refptr<Outputter> output) OVERRIDE;
+
+ private:
+  ~GLARBTimerTrace() OVERRIDE;
+
+  void Output();
+
+  int64 offset_;
+  int64 start_time_;
+  int64 end_time_;
+
+  unsigned int start_timer_;
+  unsigned int end_timer_;
+
+  DISALLOW_COPY_AND_ASSIGN(GLARBTimerTrace);
+};
+
+class NoopTrace : public Trace {
+ public:
+  NoopTrace(const std::string& name) : Trace(name) {}

[jonathan.backer, 2012/11/30 20:25:45]

explicit

[dsinclair, 2012/11/30 21:51:41]

Done.

+
+  void Start() {}

[jonathan.backer, 2012/11/30 20:25:45]

see above

[dsinclair, 2012/11/30 21:51:41]

Done.

+  void End() {}
+
+  bool IsAvailable() { return true; }
+  void Process(scoped_refptr<Outputter> output) {}
+
+ private:
+  ~NoopTrace() {}
+
+  DISALLOW_COPY_AND_ASSIGN(NoopTrace);
+};
+
+class GPUTracerImpl : public GPUTracer {

[jonathan.backer, 2012/11/30 20:25:45]

I know that you want to future proof, but are we going to subclass this if we
don't have ARB_timer_query?

[dsinclair, 2012/11/30 21:51:41]

I think so, there is nothing ARB_timer_query specific inside this code. It
delegates to subclass to create the right Trace object which is where the
specific implementation code lives.

The Begin, End and Process calls are all really generic.

+ public:
+  GPUTracerImpl()
+      : gpu_category_enabled_(TRACE_EVENT_API_GET_CATEGORY_ENABLED("gpu")) {
+  }
+  virtual ~GPUTracerImpl() {}
+
+  // Begin a trace.

[jonathan.backer, 2012/11/30 20:25:45]

// Implementation of gpu::GPUTracer.

[dsinclair, 2012/11/30 21:51:41]

Done.

+  virtual bool Begin(const std::string& name) OVERRIDE;
+
+  // End the last started trace.
+  virtual bool End() OVERRIDE;
+
+  // Process any completed traces.
+  virtual void Process() OVERRIDE;
+
+ protected:
+  // Create a new trace.
+  virtual scoped_refptr<Trace> CreateTrace(const std::string& name);
+
+  scoped_refptr<Outputter> output_;
+
+  const unsigned char* gpu_category_enabled_;
+
+ private:
+  scoped_refptr<Trace> current_trace_;
+  std::deque<scoped_refptr<Trace> > traces_;
+
+  DISALLOW_COPY_AND_ASSIGN(GPUTracerImpl);
+};
+
+class GPUTracerARBTimerQuery : public GPUTracerImpl {
+ public:
+  GPUTracerARBTimerQuery();
+  ~GPUTracerARBTimerQuery();
+
+  scoped_refptr<Trace> CreateTrace(const std::string& name);
+
+ private:
+  int64 timer_offset_;
+
+  DISALLOW_COPY_AND_ASSIGN(GPUTracerARBTimerQuery);
+};
+
+GPUTracerARBTimerQuery::GPUTracerARBTimerQuery() : GPUTracerImpl() {

[jonathan.backer, 2012/11/30 20:25:45]

I think that we list all the class declarations and then implement them in order
of the declarations.

[dsinclair, 2012/11/30 21:51:41]

Done.

+  // TODO(dsinclair): This offset can drift, we should move to another thread
+  // in order to re-calculate the drift every second-ish.
+  // TODO(dsinclair): Change to glGetInteger64v.
+  GLuint64 gl_now = 0;
+  GLuint query;
+  glGenQueries(1, &query);
+
+  glQueryCounter(query, GL_TIMESTAMP);
+  glGetQueryObjectui64v(query, GL_QUERY_RESULT, &gl_now);
+  glDeleteQueries(1, &query);
+
+  gl_now /= base::Time::kNanosecondsPerMicrosecond;
+  base::TimeTicks system_now = base::TimeTicks::NowFromSystemTraceTime();
+  timer_offset_ = system_now.ToInternalValue() - gl_now;
+
+  output_ = Outputter::Create("GL_ARB_timer_query");
+}
+
+GPUTracerARBTimerQuery::~GPUTracerARBTimerQuery() {
+}
+
+scoped_refptr<Trace> GPUTracerARBTimerQuery::CreateTrace(
+    const std::string& name) {
+  if (*gpu_category_enabled_)
+    return new GLARBTimerTrace(name, timer_offset_);
+  return GPUTracerImpl::CreateTrace(name);
+}
+
+GLARBTimerTrace::GLARBTimerTrace(const std::string& name, int64 offset)
+    : Trace(name),
+      offset_(offset),
+      start_time_(0),
+      end_time_(0),
+      start_timer_(0),
+      end_timer_(0) {
+  GLuint queries[2];
+  glGenQueries(2, queries);
+
+  start_timer_ = queries[0];
+  end_timer_ = queries[1];
+}
+
+GLARBTimerTrace::~GLARBTimerTrace() {
+}
+
+void GLARBTimerTrace::Start() {
+  glQueryCounter(start_timer_, GL_TIMESTAMP);
+}
+
+void GLARBTimerTrace::End() {
+  glQueryCounter(end_timer_, GL_TIMESTAMP);
+}
+
+bool GLARBTimerTrace::IsAvailable() {
+  GLint done = 0;
+  glGetQueryObjectiv(end_timer_, GL_QUERY_RESULT_AVAILABLE, &done);
+  return !!done;
+}
+
+void GLARBTimerTrace::Process(scoped_refptr<Outputter> output) {

[jonathan.backer, 2012/11/30 20:25:45]

DCHECK(IsAvailable())?

[dsinclair, 2012/11/30 21:51:41]

Done.

+  GLint64 timestamp;
+
+  glGetQueryObjecti64v(start_timer_, GL_QUERY_RESULT, &timestamp);
+  start_time_ = (timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_;
+
+  glGetQueryObjecti64v(end_timer_, GL_QUERY_RESULT, &timestamp);
+  end_time_ = (timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_;
+
+  GLuint queries[] = {start_timer_, end_timer_};
+  glDeleteQueries(2, queries);
+
+  output->message_loop()->PostTask(FROM_HERE,
+      base::Bind(&GLARBTimerTrace::Output, this));
+}
+
+void GLARBTimerTrace::Output() {
+  // TODO(dsinclair): Output TRACE_EVENT
+}
+
+bool GPUTracerImpl::Begin(const std::string& name) {
+  // Make sure we are not nesting trace commands.
+  if (current_trace_.get() != NULL)
+    return false;
+
+  current_trace_ = CreateTrace(name);
+  current_trace_->Start();
+  return true;
+}
+
+bool GPUTracerImpl::End() {
+  if (current_trace_.get() == NULL) {
+    return false;
+  }

[jonathan.backer, 2012/11/30 20:25:45]

nit: braces

[dsinclair, 2012/11/30 21:51:41]

Done.

+
+  current_trace_->End();
+  traces_.push_back(current_trace_);
+  current_trace_ = NULL;
+
+  if (traces_.size() > kGPUTraceMaxQueueSize)
+    Process();
+
+  return true;
+}
+
+void GPUTracerImpl::Process() {
+  while (!traces_.empty() && traces_.front()->IsAvailable()) {
+    traces_.front()->Process(output_);
+    traces_.pop_front();
+  }
+}
+
+scoped_refptr<Trace> GPUTracerImpl::CreateTrace(const std::string& name) {
+  return new NoopTrace(name);
+}
+
+}  // namespace
+
+scoped_ptr<GPUTracer> GPUTracer::Create() {
+  if (gfx::g_driver_gl.ext.b_GL_ARB_timer_query)
+    return scoped_ptr<GPUTracer>(new GPUTracerARBTimerQuery());
+  return scoped_ptr<GPUTracer>(NULL);
+}
+
+}  // namespace gles2
+}  // namespace gpu