Added support for TimeStamp queries using QueryCounterEXT.

gpu/command_buffer/service/query_manager.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/query_manager.h"
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
@@ skipping 48 matching lines @@
 
 class AsyncPixelTransfersCompletedQuery
     : public QueryManager::Query,
       public base::SupportsWeakPtr<AsyncPixelTransfersCompletedQuery> {
  public:
   AsyncPixelTransfersCompletedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
+  bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~AsyncPixelTransfersCompletedQuery() override;
 
   scoped_refptr<AsyncPixelTransferCompletionObserverImpl> observer_;
 };
 
 AsyncPixelTransfersCompletedQuery::AsyncPixelTransfersCompletedQuery(
@@ skipping 21 matching lines @@
 
   // Ask AsyncPixelTransferDelegate to run completion callback after all
   // previous async transfers are done. No guarantee that callback is run
   // on the current thread.
   manager()->decoder()->GetAsyncPixelTransferManager()->AsyncNotifyCompletion(
       mem_params, observer_.get());
 
   return AddToPendingTransferQueue(submit_count);
 }
 
+bool AsyncPixelTransfersCompletedQuery::QueryCounter(
+    base::subtle::Atomic32 submit_count) {
+  NOTREACHED();
+  return false;
+}
+
 bool AsyncPixelTransfersCompletedQuery::Process(bool did_finish) {
   QuerySync* sync = manager()->decoder()->GetSharedMemoryAs<QuerySync*>(
       shm_id(), shm_offset(), sizeof(*sync));
   if (!sync)
     return false;
 
   // Check if completion callback has been run. sync->process_count atomicity
   // is guaranteed as this is already used to notify client of a completed
   // query.
   if (base::subtle::Acquire_Load(&sync->process_count) != submit_count())
@@ skipping 16 matching lines @@
 
 }  // namespace
 
 class AllSamplesPassedQuery : public QueryManager::Query {
  public:
   AllSamplesPassedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset,
       GLuint service_id);
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
+  bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~AllSamplesPassedQuery() override;
 
  private:
   // Service side query id.
   GLuint service_id_;
 };
 
 AllSamplesPassedQuery::AllSamplesPassedQuery(
     QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset,
     GLuint service_id)
     : Query(manager, target, shm_id, shm_offset),
       service_id_(service_id) {
 }
 
 bool AllSamplesPassedQuery::Begin() {
   BeginQueryHelper(target(), service_id_);
   return true;
 }
 
 bool AllSamplesPassedQuery::End(base::subtle::Atomic32 submit_count) {
   EndQueryHelper(target());
   return AddToPendingQueue(submit_count);
 }
 
+bool AllSamplesPassedQuery::QueryCounter(base::subtle::Atomic32 submit_count) {
+  NOTREACHED();
+  return false;
+}
+
 bool AllSamplesPassedQuery::Process(bool did_finish) {
   GLuint available = 0;
   glGetQueryObjectuiv(
       service_id_, GL_QUERY_RESULT_AVAILABLE_EXT, &available);
   if (!available) {
     return true;
   }
   GLuint result = 0;
   glGetQueryObjectuiv(
       service_id_, GL_QUERY_RESULT_EXT, &result);
@@ skipping 11 matching lines @@
 AllSamplesPassedQuery::~AllSamplesPassedQuery() {
 }
 
 class CommandsIssuedQuery : public QueryManager::Query {
  public:
   CommandsIssuedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
+  bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~CommandsIssuedQuery() override;
 
  private:
   base::TimeTicks begin_time_;
 };
 
 CommandsIssuedQuery::CommandsIssuedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
     : Query(manager, target, shm_id, shm_offset) {
 }
 
 bool CommandsIssuedQuery::Begin() {
   begin_time_ = base::TimeTicks::Now();
   return true;
 }
 
 bool CommandsIssuedQuery::End(base::subtle::Atomic32 submit_count) {
   base::TimeDelta elapsed = base::TimeTicks::Now() - begin_time_;
   MarkAsPending(submit_count);
   return MarkAsCompleted(elapsed.InMicroseconds());
 }
 
+bool CommandsIssuedQuery::QueryCounter(base::subtle::Atomic32 submit_count) {
+  NOTREACHED();
+  return false;
+}
+
 bool CommandsIssuedQuery::Process(bool did_finish) {
   NOTREACHED();
   return true;
 }
 
 void CommandsIssuedQuery::Destroy(bool /* have_context */) {
   if (!IsDeleted()) {
     MarkAsDeleted();
   }
 }
 
 CommandsIssuedQuery::~CommandsIssuedQuery() {
 }
 
 class CommandLatencyQuery : public QueryManager::Query {
  public:
   CommandLatencyQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
+  bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~CommandLatencyQuery() override;
 };
 
 CommandLatencyQuery::CommandLatencyQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
     : Query(manager, target, shm_id, shm_offset) {
 }
 
 bool CommandLatencyQuery::Begin() {
     return true;
 }
 
 bool CommandLatencyQuery::End(base::subtle::Atomic32 submit_count) {
     base::TimeDelta now = base::TimeTicks::Now() - base::TimeTicks();
     MarkAsPending(submit_count);
     return MarkAsCompleted(now.InMicroseconds());
 }
 
+bool CommandLatencyQuery::QueryCounter(base::subtle::Atomic32 submit_count) {
+  NOTREACHED();
+  return false;
+}
+
 bool CommandLatencyQuery::Process(bool did_finish) {
   NOTREACHED();
   return true;
 }
 
 void CommandLatencyQuery::Destroy(bool /* have_context */) {
   if (!IsDeleted()) {
     MarkAsDeleted();
   }
 }
 
 CommandLatencyQuery::~CommandLatencyQuery() {
 }
 
 
 class AsyncReadPixelsCompletedQuery
     : public QueryManager::Query,
       public base::SupportsWeakPtr<AsyncReadPixelsCompletedQuery> {
  public:
   AsyncReadPixelsCompletedQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
+  bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   void Complete();
   ~AsyncReadPixelsCompletedQuery() override;
 
  private:
   bool completed_;
   bool complete_result_;
@@ skipping 14 matching lines @@
   if (!AddToPendingQueue(submit_count)) {
     return false;
   }
   manager()->decoder()->WaitForReadPixels(
       base::Bind(&AsyncReadPixelsCompletedQuery::Complete,
                  AsWeakPtr()));
 
   return Process(false);
 }
 
+bool AsyncReadPixelsCompletedQuery::QueryCounter(
+    base::subtle::Atomic32 submit_count) {
+  NOTREACHED();
+  return false;
+}
+
 void AsyncReadPixelsCompletedQuery::Complete() {
   completed_ = true;
   complete_result_ = MarkAsCompleted(1);
 }
 
 bool AsyncReadPixelsCompletedQuery::Process(bool did_finish) {
   return !completed_ || complete_result_;
 }
 
 void AsyncReadPixelsCompletedQuery::Destroy(bool /* have_context */) {
   if (!IsDeleted()) {
     MarkAsDeleted();
   }
 }
 
 AsyncReadPixelsCompletedQuery::~AsyncReadPixelsCompletedQuery() {
 }
 
 
 class GetErrorQuery : public QueryManager::Query {
  public:
   GetErrorQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset);
 
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
+  bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~GetErrorQuery() override;
 
  private:
 };
 
 GetErrorQuery::GetErrorQuery(
       QueryManager* manager, GLenum target, int32 shm_id, uint32 shm_offset)
     : Query(manager, target, shm_id, shm_offset) {
 }
 
 bool GetErrorQuery::Begin() {
   return true;
 }
 
 bool GetErrorQuery::End(base::subtle::Atomic32 submit_count) {
   MarkAsPending(submit_count);
   return MarkAsCompleted(manager()->decoder()->GetErrorState()->GetGLError());
 }
 
+bool GetErrorQuery::QueryCounter(base::subtle::Atomic32 submit_count) {
+  NOTREACHED();
+  return false;
+}
+
 bool GetErrorQuery::Process(bool did_finish) {
   NOTREACHED();
   return true;
 }
 
 void GetErrorQuery::Destroy(bool /* have_context */) {
   if (!IsDeleted()) {
     MarkAsDeleted();
   }
 }
 
 GetErrorQuery::~GetErrorQuery() {
 }
 
 class CommandsCompletedQuery : public QueryManager::Query {
  public:
   CommandsCompletedQuery(QueryManager* manager,
                          GLenum target,
                          int32 shm_id,
                          uint32 shm_offset);
 
   // Overridden from QueryManager::Query:
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
+  bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~CommandsCompletedQuery() override;
 
  private:
   scoped_ptr<gfx::GLFence> fence_;
   base::TimeTicks begin_time_;
 };
 
 CommandsCompletedQuery::CommandsCompletedQuery(QueryManager* manager,
                                                GLenum target,
                                                int32 shm_id,
                                                uint32 shm_offset)
     : Query(manager, target, shm_id, shm_offset) {}
 
 bool CommandsCompletedQuery::Begin() {
   begin_time_ = base::TimeTicks::Now();
   return true;
 }
 
 bool CommandsCompletedQuery::End(base::subtle::Atomic32 submit_count) {
   fence_.reset(gfx::GLFence::Create());
   DCHECK(fence_);
   return AddToPendingQueue(submit_count);
 }
 
+bool CommandsCompletedQuery::QueryCounter(base::subtle::Atomic32 submit_count) {
+  NOTREACHED();
+  return false;
+}
+
 bool CommandsCompletedQuery::Process(bool did_finish) {
   // Note: |did_finish| guarantees that the GPU has passed the fence but
   // we cannot assume that GLFence::HasCompleted() will return true yet as
   // that's not guaranteed by all GLFence implementations.
   if (!did_finish && fence_ && !fence_->HasCompleted())
     return true;
 
   base::TimeDelta elapsed = base::TimeTicks::Now() - begin_time_;
   return MarkAsCompleted(elapsed.InMicroseconds());
 }
@@ skipping 10 matching lines @@
 class TimeElapsedQuery : public QueryManager::Query {
  public:
   TimeElapsedQuery(QueryManager* manager,
                    GLenum target,
                    int32 shm_id,
                    uint32 shm_offset);
 
   // Overridden from QueryManager::Query:
   bool Begin() override;
   bool End(base::subtle::Atomic32 submit_count) override;
+  bool QueryCounter(base::subtle::Atomic32 submit_count) override;
   bool Process(bool did_finish) override;
   void Destroy(bool have_context) override;
 
  protected:
   ~TimeElapsedQuery() override;
 
  private:
   scoped_ptr<gfx::GPUTimer> gpu_timer_;
 };
 
 TimeElapsedQuery::TimeElapsedQuery(QueryManager* manager,
                                    GLenum target,
                                    int32 shm_id,
                                    uint32 shm_offset)
     : Query(manager, target, shm_id, shm_offset),
       gpu_timer_(manager->CreateGPUTimer(true)) {}
 
 bool TimeElapsedQuery::Begin() {
   gpu_timer_->Start();
   return true;
 }
 
 bool TimeElapsedQuery::End(base::subtle::Atomic32 submit_count) {
   gpu_timer_->End();
   return AddToPendingQueue(submit_count);
 }
 
+bool TimeElapsedQuery::QueryCounter(base::subtle::Atomic32 submit_count) {
+  NOTREACHED();
+  return false;
+}
+
 bool TimeElapsedQuery::Process(bool did_finish) {
   if (!gpu_timer_->IsAvailable())
     return true;
 
   const uint64_t nano_seconds =
       gpu_timer_->GetDeltaElapsed() * base::Time::kNanosecondsPerMicrosecond;
   return MarkAsCompleted(nano_seconds);
 }
 
 void TimeElapsedQuery::Destroy(bool have_context) {
   if (gpu_timer_.get()) {
     gpu_timer_->Destroy(have_context);
     gpu_timer_.reset();
   }
 }
 
 TimeElapsedQuery::~TimeElapsedQuery() {}
 
+class TimeStampQuery : public QueryManager::Query {
+ public:
+  TimeStampQuery(QueryManager* manager,
+                 GLenum target,
+                 int32 shm_id,
+                 uint32 shm_offset);
+
+  // Overridden from QueryManager::Query:
+  bool Begin() override;
+  bool End(base::subtle::Atomic32 submit_count) override;
+  bool QueryCounter(base::subtle::Atomic32 submit_count) override;
+  bool Process(bool did_finish) override;
+  void Destroy(bool have_context) override;
+
+ protected:
+  ~TimeStampQuery() override;
+
+ private:
+  scoped_ptr<gfx::GPUTimer> gpu_timer_;
+};
+
+TimeStampQuery::TimeStampQuery(QueryManager* manager,
+                               GLenum target,
+                               int32 shm_id,
+                               uint32 shm_offset)
+    : Query(manager, target, shm_id, shm_offset),
+      gpu_timer_(manager->CreateGPUTimer(false)) {}
+
+bool TimeStampQuery::Begin() {
+  NOTREACHED();
+  return false;
+}
+
+bool TimeStampQuery::End(base::subtle::Atomic32 submit_count) {
+  NOTREACHED();
+  return false;
+}
+
+bool TimeStampQuery::QueryCounter(base::subtle::Atomic32 submit_count) {
+  gpu_timer_->QueryTimeStamp();
+  return AddToPendingQueue(submit_count);
+}
+
+bool TimeStampQuery::Process(bool did_finish) {
+  if (!gpu_timer_->IsAvailable())
+    return true;
+
+  int64_t start = 0;
+  int64_t end = 0;
+  gpu_timer_->GetStartEndTimestamps(&start, &end);
+  DCHECK(start == end);
+
+  const uint64_t nano_seconds = start * base::Time::kNanosecondsPerMicrosecond;
+  return MarkAsCompleted(nano_seconds);
+}
+
+void TimeStampQuery::Destroy(bool have_context) {
+  if (gpu_timer_.get()) {
+    gpu_timer_->Destroy(have_context);
+    gpu_timer_.reset();
+  }
+}
+
+TimeStampQuery::~TimeStampQuery() {}
+
 QueryManager::QueryManager(
     GLES2Decoder* decoder,
     FeatureInfo* feature_info)
     : decoder_(decoder),
       use_arb_occlusion_query2_for_occlusion_query_boolean_(
           feature_info->feature_flags(
             ).use_arb_occlusion_query2_for_occlusion_query_boolean),
       use_arb_occlusion_query_for_occlusion_query_boolean_(
           feature_info->feature_flags(
             ).use_arb_occlusion_query_for_occlusion_query_boolean),
@@ skipping 48 matching lines @@
       break;
     case GL_GET_ERROR_QUERY_CHROMIUM:
       query = new GetErrorQuery(this, target, shm_id, shm_offset);
       break;
     case GL_COMMANDS_COMPLETED_CHROMIUM:
       query = new CommandsCompletedQuery(this, target, shm_id, shm_offset);
       break;
     case GL_TIME_ELAPSED:
       query = new TimeElapsedQuery(this, target, shm_id, shm_offset);
       break;
+    case GL_TIMESTAMP:
+      query = new TimeStampQuery(this, target, shm_id, shm_offset);
+      break;
     default: {
       GLuint service_id = 0;
       glGenQueries(1, &service_id);
       DCHECK_NE(0u, service_id);
       query = new AllSamplesPassedQuery(
           this, target, shm_id, shm_offset, service_id);
       break;
     }
   }
   std::pair<QueryMap::iterator, bool> result =
@@ skipping 234 matching lines @@
 }
 
 bool QueryManager::EndQuery(Query* query, base::subtle::Atomic32 submit_count) {
   DCHECK(query);
   if (!RemovePendingQuery(query)) {
     return false;
   }
   return query->End(submit_count);
 }
 
+bool QueryManager::QueryCounter(
+    Query* query, base::subtle::Atomic32 submit_count) {
+  DCHECK(query);
+  return query->QueryCounter(submit_count);
+}
+
 }  // namespace gles2
 }  // namespace gpu