Added support for TimeStamp queries using QueryCounterEXT.

ui/gl/gpu_timing.cc

 // Copyright (c) 2015 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 "ui/gl/gpu_timing.h"
 
 #include "base/time/time.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_version_info.h"
@@ skipping 295 matching lines @@
   DCHECK(context);
   const GLVersionInfo* version_info = context->GetVersionInfo();
   DCHECK(version_info);
   if (version_info->is_es3 &&  // glGetInteger64v is supported under ES3.
     context->HasExtension("GL_EXT_disjoint_timer_query")) {
     timer_type_ = GPUTiming::kTimerTypeDisjoint;
   } else if (context->HasExtension("GL_ARB_timer_query")) {
     timer_type_ = GPUTiming::kTimerTypeARB;
   } else if (context->HasExtension("GL_EXT_timer_query")) {
     timer_type_ = GPUTiming::kTimerTypeEXT;
+    force_time_elapsed_query_ = true;
   }
 }
 
 GPUTimingImpl::~GPUTimingImpl() {
 }
 
 uint32_t GPUTimingImpl::GetDisjointCount() {
   if (timer_type_ == GPUTiming::kTimerTypeDisjoint) {
     GLint disjoint_value = 0;
     glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjoint_value);
@@ skipping 42 matching lines @@
         queries_.back().get())->EndQuery(this, result);
   } else {
     // Simply end the query and reset the current offset
     DCHECK(GetLastElapsedQuery().get());
     GetLastElapsedQuery()->EndQuery(this, result);
     DCHECK(GetLastElapsedQuery().get() == nullptr);
   }
 }
 
 scoped_refptr<QueryResult> GPUTimingImpl::DoTimeStampQuery() {
-  DCHECK(timer_type_ == GPUTiming::kTimerTypeDisjoint ||
-         timer_type_ == GPUTiming::kTimerTypeARB);
+  DCHECK(timer_type_ != GPUTiming::kTimerTypeInvalid);
 
   if (force_time_elapsed_query_) {
     // Replace with elapsed timer queries instead.
     scoped_refptr<QueryResult> result = BeginElapsedTimeQuery();
     EndElapsedTimeQuery(result);
     return result;
   }
 
   queries_.push_back(new TimeStampTimerQuery(next_timer_query_id_++));
   return static_cast<TimeStampTimerQuery*>(queries_.back().get())->DoQuery();
@@ skipping 79 matching lines @@
   if (have_context) {
     if (!end_requested_) {
       DCHECK(gpu_timing_client_->gpu_timing_);
       DCHECK(elapsed_timer_result_.get());
       gpu_timing_client_->gpu_timing_->EndElapsedTimeQuery(
           elapsed_timer_result_);
     }
   }
 }
 
+void GPUTimer::QueryTimeStamp() {
+  DCHECK(!end_requested_);

[piman, 2015/07/16 01:05:53]

We can QueryCounter multiple times on the same query, so I don't think this is
valid.

[David Yen, 2015/07/16 20:21:12]

Ah yes, GPUTimer has originally always been one use only (For the GPUTracer and
other performance timers). I have restructured it so they can be reused multiple
times and also added unit tests to test for this (verifying it was failing
before).

+  DCHECK(gpu_timing_client_->gpu_timing_);
+  DCHECK(!time_stamp_result_.get() && !elapsed_timer_result_.get());

[piman, 2015/07/16 01:05:53]

same here.

[David Yen, 2015/07/16 20:21:12]

Done.

+  end_requested_ = true;
+  time_stamp_result_ = gpu_timing_client_->gpu_timing_->DoTimeStampQuery();
+}
+
 void GPUTimer::Start() {
+  DCHECK(!end_requested_);

[piman, 2015/07/16 01:05:53]

Is this valid? It looks like for the GL_TIME_ELAPSED queries, we call Start in
BeginBegin and End in EndQuery, so we would hit this the second time?

[David Yen, 2015/07/16 20:21:12]

Done.

   DCHECK(gpu_timing_client_->gpu_timing_);
+  DCHECK(!time_stamp_result_.get() && !elapsed_timer_result_.get());

[piman, 2015/07/16 01:05:53]

Same here wrt !elapsed_timer_result_.get()

[David Yen, 2015/07/16 20:21:12]

Done.

   if (!use_elapsed_timer_)
     time_stamp_result_ = gpu_timing_client_->gpu_timing_->DoTimeStampQuery();
 
   elapsed_timer_result_ =
       gpu_timing_client_->gpu_timing_->BeginElapsedTimeQuery();
 }
 
 void GPUTimer::End() {
+  DCHECK(!end_requested_);
   DCHECK(elapsed_timer_result_.get());
   end_requested_ = true;
   gpu_timing_client_->gpu_timing_->EndElapsedTimeQuery(elapsed_timer_result_);
 }
 
 bool GPUTimer::IsAvailable() {
   if (!end_requested_)
     return false;
   if (!end_available_) {
-    DCHECK(elapsed_timer_result_.get());
-    if (elapsed_timer_result_->IsAvailable()) {
-      end_available_ = true;
+    scoped_refptr<QueryResult> result =
+        elapsed_timer_result_.get() ?
+        elapsed_timer_result_ :
+        time_stamp_result_;
+
+    DCHECK(result.get());
+    if (result->IsAvailable()) {
+        end_available_ = true;

[piman, 2015/07/16 01:05:53]

nit: indent looks wrong

[David Yen, 2015/07/16 20:21:12]

No longer relevant as this section has been rewritten.

     } else {
       gpu_timing_client_->gpu_timing_->UpdateQueryResults();
-      end_available_ = elapsed_timer_result_->IsAvailable();
+      end_available_ = result->IsAvailable();
     }
   }
   return end_available_;
 }
 
 void GPUTimer::GetStartEndTimestamps(int64* start, int64* end) {
   DCHECK(start && end);
-  DCHECK(elapsed_timer_result_.get());
+  DCHECK(elapsed_timer_result_.get() || time_stamp_result_.get());
   DCHECK(IsAvailable());
-  if (time_stamp_result_.get()) {
-    DCHECK(time_stamp_result_->IsAvailable());
-    const int64_t time_stamp = time_stamp_result_->GetStartValue();
-    *start = time_stamp;
-    *end = time_stamp + elapsed_timer_result_->GetDelta();
-  } else {
-    // Use estimation from elasped timer results.
-    *start = elapsed_timer_result_->GetStartValue();
-    *end = elapsed_timer_result_->GetEndValue();
-  }
+  const int64_t time_stamp = time_stamp_result_.get() ?
+                             time_stamp_result_->GetStartValue() :
+                             elapsed_timer_result_->GetStartValue();
+  const int64_t elapsed_time = elapsed_timer_result_.get() ?
+                               elapsed_timer_result_->GetDelta() :
+                               0;
+
+  *start = time_stamp;
+  *end = time_stamp + elapsed_time;
 }
 
 int64 GPUTimer::GetDeltaElapsed() {
-  DCHECK(elapsed_timer_result_.get());
   DCHECK(IsAvailable());
-  return elapsed_timer_result_->GetDelta();
+  if (elapsed_timer_result_.get())
+    return elapsed_timer_result_->GetDelta();
+  return 0;
 }
 
 GPUTimer::GPUTimer(scoped_refptr<GPUTimingClient> gpu_timing_client,
                    bool use_elapsed_timer)
     : use_elapsed_timer_(use_elapsed_timer),
       gpu_timing_client_(gpu_timing_client) {
 }
 
 GPUTimingClient::GPUTimingClient(GPUTimingImpl* gpu_timing)
     : gpu_timing_(gpu_timing) {
@@ skipping 57 matching lines @@
 
 void GPUTimingClient::ForceTimeElapsedQuery() {
   DCHECK(gpu_timing_);
   gpu_timing_->ForceTimeElapsedQuery();
 }
 
 GPUTimingClient::~GPUTimingClient() {
 }
 
 }  // namespace gfx