Force time elapsed queries on certain drivers.

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/macros.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"
 
 namespace gfx {
 
 class TimeElapsedTimerQuery;
 class TimerQuery;
 
 int64_t NanoToMicro(uint64_t nano_seconds) {
   const uint64_t up = nano_seconds + base::Time::kNanosecondsPerMicrosecond / 2;
   return static_cast<int64_t>(up / base::Time::kNanosecondsPerMicrosecond);
 }
 
+int32_t QueryTimestampBits() {
+  GLint timestamp_bits;
+  glGetQueryiv(GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, &timestamp_bits);
+  return static_cast<int32_t>(timestamp_bits);
+}
+
 class GPUTimingImpl : public GPUTiming {
  public:
    GPUTimingImpl(GLContextReal* context);
   ~GPUTimingImpl() override;
 
   void ForceTimeElapsedQuery() { force_time_elapsed_query_ = true; }
   bool IsForceTimeElapsedQuery() { return force_time_elapsed_query_; }
 
   GPUTiming::TimerType GetTimerType() const { return timer_type_; }
 
@@ skipping 33 matching lines @@
 
  private:
   scoped_refptr<GPUTimingClient> CreateGPUTimingClient() override;
 
   base::Callback<int64_t(void)> cpu_time_for_testing_;
   GPUTiming::TimerType timer_type_ = GPUTiming::kTimerTypeInvalid;
   uint32_t disjoint_counter_ = 0;
   int64_t offset_ = 0;  // offset cache when timer_type_ == kTimerTypeARB
   bool offset_valid_ = false;
   bool force_time_elapsed_query_ = false;
+  int32_t timestamp_bit_count_gl_ = -1;  // gl implementation timestamp bits
 
   uint32_t next_timer_query_id_ = 0;
   uint32_t next_good_timer_query_id_ = 0; // identify bad ids for disjoints.
   uint32_t query_disjoint_count_ = 0;
 
   // Extra state tracking data for elapsed timer queries.
   int64_t max_time_stamp_ = 0;
   uint32_t elapsed_query_count_ = 0;
   scoped_refptr<TimeElapsedTimerQuery> last_elapsed_query_;
 
@@ skipping 225 matching lines @@
   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;
+    timestamp_bit_count_gl_ = 0;
   }
 }
 
 GPUTimingImpl::~GPUTimingImpl() {
 }
 
 uint32_t GPUTimingImpl::GetDisjointCount() {
   if (timer_type_ == GPUTiming::kTimerTypeDisjoint) {
     GLint disjoint_value = 0;
     glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjoint_value);
@@ skipping 54 matching lines @@
     // 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::kTimerTypeInvalid);
 
+  // Certain GL drivers have timestamp bit count set to 0 which means timestamps
+  // aren't supported. Emulate them with time elapsed queries if that is the
+  // case.
+  if (timestamp_bit_count_gl_ == -1) {
+    DCHECK(timer_type_ != GPUTiming::kTimerTypeEXT);
+    timestamp_bit_count_gl_ = QueryTimestampBits();

[no sievers, 2016/02/17 23:08:45]

Do you have to do that every time though? Isn't GL_QUERY_COUNTER_BITS for
GL_TIMESTAMP more of a static property?

[David Yen, 2016/02/17 23:10:52]

It only lazily initializes it once. It's done lazily so contexts which do not
query timestamps do not have to query the counter.

[Ian Ewell, 2016/02/17 23:11:53]

It is only called once and then timestamp_bit_count_gl is updated so that it is
never called again. It is done here as it affects the fewest amount of tests
(putting it in the constructor broke twice as many tests before the fixes to the
tests.

+    force_time_elapsed_query_ = (timestamp_bit_count_gl_ == 0);
+  }
+
   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 230 matching lines @@
 
 void GPUTimingClient::ForceTimeElapsedQuery() {
   DCHECK(gpu_timing_);
   gpu_timing_->ForceTimeElapsedQuery();
 }
 
 GPUTimingClient::~GPUTimingClient() {
 }
 
 }  // namespace gfx