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();
+    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