gpu: Reuse transfer buffers more aggresively

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),
+      serial_(0),
       client_begin_time_us_(0),
       result_(0) {
     }
 
 
 void QueryTracker::Query::Begin(GLES2Implementation* gl) {
   // init memory, inc count
   MarkAsActive();
 
   switch (target()) {
     case GL_GET_ERROR_QUERY_CHROMIUM:
       // To nothing on begin for error queries.
       break;
     case GL_LATENCY_QUERY_CHROMIUM:
       client_begin_time_us_ = MicrosecondsSinceOriginOfTime();
       // tell service about id, shared memory and count
-      gl->helper()->BeginQueryEXT(target(), id(), shm_id(), shm_offset());
+      gl->helper()->BeginQueryEXT(
+          target(), id(), serial(), shm_id(), shm_offset());
       break;
     case GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM:
     case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
     default:
       // tell service about id, shared memory and count
-      gl->helper()->BeginQueryEXT(target(), id(), shm_id(), shm_offset());
+      gl->helper()->BeginQueryEXT(
+          target(), id(), serial(), shm_id(), shm_offset());
       break;
   }
 }
 
 void QueryTracker::Query::End(GLES2Implementation* gl) {
   switch (target()) {
     case GL_GET_ERROR_QUERY_CHROMIUM: {
       GLenum error = gl->GetClientSideGLError();
       if (error == GL_NO_ERROR) {
         // There was no error so start the query on the serivce.
         // it will end immediately.
-        gl->helper()->BeginQueryEXT(target(), id(), shm_id(), shm_offset());
+        gl->helper()->BeginQueryEXT(
+            target(), id(), serial(), shm_id(), shm_offset());
       } else {
         // 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;
         }
       }
     }
   }
-  gl->helper()->EndQueryEXT(target(), submit_count());
+  gl->helper()->EndQueryEXT(target(), serial(), submit_count());
   MarkAsPending(gl->helper()->InsertToken());
 }
 
 bool QueryTracker::Query::CheckResultsAvailable(
     CommandBufferHelper* helper) {
   if (Pending()) {
     if (info_.sync->process_count == submit_count_ ||
         helper->IsContextLost()) {
       // Need a MemoryBarrier here so that sync->result read after
       // sync->process_count.
@@ skipping 31 matching lines @@
   }
   return state_ == kComplete;
 }
 
 uint32 QueryTracker::Query::GetResult() const {
   DCHECK(state_ == kComplete || state_ == kUninitialized);
   return result_;
 }
 
 QueryTracker::QueryTracker(MappedMemoryManager* manager)
-    : query_sync_manager_(manager) {
+    : query_sync_manager_(manager),
+      next_serial_(1) {
 }
 
 QueryTracker::~QueryTracker() {
   while (!queries_.empty()) {
     delete queries_.begin()->second;
     queries_.erase(queries_.begin());
   }
   while (!removed_queries_.empty()) {
     delete removed_queries_.front();
     removed_queries_.pop_front();
   }
 }
 
-QueryTracker::Query* QueryTracker::CreateQuery(GLuint id, GLenum target) {
+QueryTracker::Query* QueryTracker::CreateQuery(
+    GLuint id, GLenum target) {
   DCHECK_NE(0u, id);
   FreeCompletedQueries();
   QuerySyncManager::QueryInfo info;
   if (!query_sync_manager_.Alloc(&info)) {
     return NULL;
   }
   Query* query = new Query(id, target, info);
   std::pair<QueryMap::iterator, bool> result =
       queries_.insert(std::make_pair(id, query));
   DCHECK(result.second);
   return query;
 }
 
+QueryTracker::Query* QueryTracker::CreateInternalQuery(
+    GLuint id, GLenum target) {
+  Query* query = CreateQuery(id, target);
+  query->set_serial(NextSerial());
+  return query;
+}
+
 QueryTracker::Query* QueryTracker::GetQuery(
     GLuint client_id) {
   QueryMap::iterator it = queries_.find(client_id);
   return it != queries_.end() ? it->second : NULL;
 }
 
 void QueryTracker::RemoveQuery(GLuint client_id) {
   QueryMap::iterator it = queries_.find(client_id);
   if (it != queries_.end()) {
     Query* query = it->second;
@@ skipping 21 matching lines @@
       ++it;
       continue;
     }
 
     query_sync_manager_.Free(query->info_);
     it = removed_queries_.erase(it);
     delete query;
   }
 }
 
+uint32 QueryTracker::NextSerial() {
+  uint32 serial = next_serial_++;
+  if (serial == 0)
+    return NextSerial();

[piman, 2014/01/11 02:02:32]

In case of wrap around we need to Finish().
The rest of the code assumes last_read_serial > |serial| means serial has
passed. It would not be true with this code, after wraparound.

We do Finish when tokens wrap (see CommandBufferHelper::InsertToken).

If we're worried that we might actually wrap in practice and don't want to
Finish() in that case, we can do something like double-buffer the range, and
only call Finish() if the last_read_serial has the same high bit as the new
serial, when that high bit changes. That should not happen in practice (unless
we can have 2^31 queries actually in flight).

[jadahl, 2014/01/16 16:24:39]

Will Finish() really help anything? In the version I just uploaded I simply
provide an API via CommandBufferHelper (HasSerialPassed(uint32)) that just
checks the bits.

This will work if we have less than 2^31 concurrent queries, and if we'd ever
have that many I think we have bigger problems already :)

+  return serial;
+}
+
 }  // namespace gles2
 }  // namespace gpu