Reduce the number of flushes while using glQueries.

gpu/command_buffer/client/query_tracker.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/client/query_tracker.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
@@ skipping 75 matching lines @@
 }
 
 QueryTracker::Query::Query(GLuint id, GLenum target,
                            const QuerySyncManager::QueryInfo& info)
     : id_(id),
       target_(target),
       info_(info),
       state_(kUninitialized),
       submit_count_(0),
       token_(0),
-      flushed_(false),
+      last_flush_(0),
       client_begin_time_us_(0),
       result_(0) {
     }
 
 
 void QueryTracker::Query::Begin(GLES2Implementation* gl) {
   // init memory, inc count
   MarkAsActive();
 
   switch (target()) {
@@ skipping 26 matching lines @@
         // There's an error on the client, no need to bother the service. just
         // set the query as completed and return the error.
         if (error != GL_NO_ERROR) {
           state_ = kComplete;
           result_ = error;
           return;
         }
       }
     }
   }
+  last_flush_ = gl->helper()->flush_generation();
   gl->helper()->EndQueryEXT(target(), submit_count());
   MarkAsPending(gl->helper()->InsertToken());
 }
 
 bool QueryTracker::Query::CheckResultsAvailable(
     CommandBufferHelper* helper) {
   if (Pending()) {
     if (base::subtle::Acquire_Load(&info_.sync->process_count) ==
             submit_count_ ||
         helper->IsContextLost()) {
       switch (target()) {
         case GL_COMMANDS_ISSUED_CHROMIUM:
           result_ = std::min(info_.sync->result,
                              static_cast<uint64>(0xFFFFFFFFL));
           break;
         case GL_LATENCY_QUERY_CHROMIUM:
           DCHECK(info_.sync->result >= client_begin_time_us_);
           result_ = std::min(info_.sync->result - client_begin_time_us_,
                              static_cast<uint64>(0xFFFFFFFFL));
           break;
         case GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM:
         case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
         default:
           result_ = info_.sync->result;
           break;
       }
       state_ = kComplete;
     } else {
-      if (!flushed_) {
-        // TODO(gman): We could reduce the number of flushes by having a
-        // flush count, recording that count at the time we insert the
-        // EndQuery command and then only flushing here if we've have not
-        // passed that count yet.
-        flushed_ = true;
+      uint32 flush_generation = helper->flush_generation();
+      if (!(flush_generation>last_flush_)) {
         helper->Flush();
+        last_flush_ = helper->flush_generation();

[Zhenyao Mo, 2014/04/08 21:13:56]

My apology for not catching this earlier, but this makes situation worse, not
better.  Now if you keep calling CheckResultsAvailable(), very likely
flush_generation == last_flush_, and you will flush everytime.

So instead, once you set last_flush_, you don't wanna update its value here. 
last_flush_ is also a misleading name, maybe just flush_count_.

[rptr, 2014/04/08 22:44:16]

Done.
Problem was updating flush_count_ here. we should update that only when EndQuery
is called.

       } else {
         // Insert no-ops so that eventually the GPU process will see more work.
         helper->Noop(1);
       }
     }
   }
   return state_ == kComplete;
 }
 
 uint32 QueryTracker::Query::GetResult() const {
@@ skipping 67 matching lines @@
     }
 
     query_sync_manager_.Free(query->info_);
     it = removed_queries_.erase(it);
     delete query;
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu