gpu: Reuse transfer buffers more aggresively

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 1360 matching lines @@
   }
 
   GLuint buffer_id;
   if (GetBoundPixelTransferBuffer(target, "glBufferData", &buffer_id)) {
     if (!buffer_id) {
       return;
     }
 
     BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id);
     if (buffer) {
-      // Free buffer memory, pending the passage of a token.
-      buffer_tracker_->FreePendingToken(buffer, helper_->InsertToken());
+      if (buffer->used()) {
+        buffer->set_used(false);
+        buffer->set_last_usage_token(helper_->InsertToken());
+      }

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

Where does the last_usage_token get set if it's not bound to
GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM ?

[jadahl, 2014/01/11 11:35:29]

Right, should do the same for other buffer targets in BindBufferHelper.

[reveman, 2014/01/11 23:39:04]

What if we set last usage token when issuing the command that will use the
buffer (ie. DrawArrays) instead of bind/unbind? Then you can get rid of
set_used() and the token would be more tightly packed with the usage. Also more
consistent with how we handle AsyncTexImage2D.

[jadahl, 2014/01/12 09:52:24]

I think this sounds like a good idea.

[jadahl, 2014/01/14 14:15:47]

Hmm, is what you mean to do this for the functions that deal with transfer
buffers? i.e. UnmapBufferCHROMIUM, (Compressed)(Sub)TexImage2D? and not
DrawArrays, which does not deal with pixel transfer buffers at all.

[reveman, 2014/01/14 15:27:20]

Not only transfer buffers but all buffer objects so that you can get rid of
set_used() completely. So both (Compressed)(Sub)TexImage2D and DrawArrays, as
well as any other command that can use a buffer object.

[reveman, 2014/01/14 15:54:26]

Sorry, DrawArrays doesn't use a buffer object as we don't have shared memory
VBOs. The general idea is that any command that will use the contents of a
buffer object on the service side needs a set_last_usage_token call. ie.
BufferSubData in case of VBOs and (Compressed)(Sub)TexImage2D in case of pixel
transfer buffers.

Think this will also allow us to remove set_transfer_ready_token().

[jadahl, 2014/01/14 16:32:09]

I don't see how BufferSubData would be used service side for a
BufferTracker::Buffer, as in those cases it'll be a simple client side memcpy.

[reveman, 2014/01/14 16:55:25]

Right. I guess it's really just (Compressed)(Sub)TexImage2D that need a
set_last_usage_token.

 
-      // Remove old buffer.
-      buffer_tracker_->RemoveBuffer(buffer_id);
+      FreeTransferBuffer(buffer);
+      buffer_tracker_->RemoveBuffer(buffer->id());
     }
 
     // Create new buffer.
     buffer = buffer_tracker_->CreateBuffer(buffer_id, size);
     DCHECK(buffer);
+    buffer->set_used(true);
     if (buffer->address() && data)
       memcpy(buffer->address(), data, size);
     return;
   }
 
   if (size == 0) {
     return;
   }
 
   // If there is no data just send BufferData
@@ skipping 103 matching lines @@
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBufferSubData("
       << GLES2Util::GetStringBufferTarget(target) << ", "
       << offset << ", " << size << ", "
       << static_cast<const void*>(data) << ")");
   BufferSubDataHelper(target, offset, size, data);
   CheckGLError();
 }
 
+void GLES2Implementation::FreeTransferBuffer(BufferTracker::Buffer* buffer) {
+  int32 token = buffer->last_usage_token();
+
+  if (buffer->async_query_id()) {
+    QueryTracker::Query* query =
+        query_tracker_->GetQuery(buffer->async_query_id());
+    if (!query->CheckResultsAvailable(helper_))
+      buffer_tracker_->FreePendingSerial(buffer, query->serial());
+    else
+      buffer_tracker_->Free(buffer);
+  } else if (token) {
+    if (helper_->HasTokenPassed(token))
+      buffer_tracker_->Free(buffer);
+    else
+      buffer_tracker_->FreePendingToken(buffer, token);
+  }
+  // TODO(jadahl): What to do if there is both token and query
+}
+
 bool GLES2Implementation::GetBoundPixelTransferBuffer(
     GLenum target,
     const char* function_name,
     GLuint* buffer_id) {
   *buffer_id = 0;
 
   switch (target) {
     case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:
       *buffer_id = bound_pixel_pack_transfer_buffer_id_;
       break;
@@ skipping 872 matching lines @@
 }
 
 // NOTE #1: On old versions of OpenGL, calling glBindXXX with an unused id
 // generates a new resource. On newer versions of OpenGL they don't. The code
 // related to binding below will need to change if we switch to the new OpenGL
 // model. Specifically it assumes a bind will succeed which is always true in
 // the old model but possibly not true in the new model if another context has
 // deleted the resource.
 
 bool GLES2Implementation::BindBufferHelper(
-    GLenum target, GLuint buffer) {
+    GLenum target, GLuint buffer_id) {
+  BufferTracker::Buffer* buffer;

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

nit: = NULL

+
   // TODO(gman): See note #1 above.
   bool changed = false;
   switch (target) {
     case GL_ARRAY_BUFFER:
-      if (bound_array_buffer_id_ != buffer) {
-        bound_array_buffer_id_ = buffer;
+      if (bound_array_buffer_id_ != buffer_id) {
+        bound_array_buffer_id_ = buffer_id;
         changed = true;
       }
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
-      changed = vertex_array_object_manager_->BindElementArray(buffer);
+      changed = vertex_array_object_manager_->BindElementArray(buffer_id);
       break;
     case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:
-      bound_pixel_pack_transfer_buffer_id_ = buffer;
+      bound_pixel_pack_transfer_buffer_id_ = buffer_id;
       break;
     case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:
-      bound_pixel_unpack_transfer_buffer_id_ = buffer;
+      // Mark any previously bound buffer as unused.
+      if (bound_pixel_unpack_transfer_buffer_id_ != buffer_id &&
+          bound_pixel_unpack_transfer_buffer_id_ != 0) {
+        buffer =
+            buffer_tracker_->GetBuffer(bound_pixel_unpack_transfer_buffer_id_);
+        if (buffer) {
+          buffer->set_last_usage_token(helper_->InsertToken());
+        }
+      }
+
+      bound_pixel_unpack_transfer_buffer_id_ = buffer_id;
+      buffer = buffer_tracker_->GetBuffer(buffer_id);
+      if (buffer) {
+        buffer->set_used(true);
+        buffer->set_last_usage_token(0);
+      }
+
       break;
     default:
       changed = true;
       break;
   }
   // TODO(gman): There's a bug here. If the target is invalid the ID will not be
   // used even though it's marked it as used here.
-  GetIdHandler(id_namespaces::kBuffers)->MarkAsUsedForBind(buffer);
+  GetIdHandler(id_namespaces::kBuffers)->MarkAsUsedForBind(buffer_id);
   return changed;
 }
 
 bool GLES2Implementation::BindFramebufferHelper(
     GLenum target, GLuint framebuffer) {
   // TODO(gman): See note #1 above.
   bool changed = false;
   switch (target) {
     case GL_FRAMEBUFFER:
       if (bound_framebuffer_ != framebuffer ||
@@ skipping 113 matching lines @@
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteBuffers", "id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (buffers[ii] == bound_array_buffer_id_) {
       bound_array_buffer_id_ = 0;
     }
     vertex_array_object_manager_->UnbindBuffer(buffers[ii]);
+
     BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffers[ii]);
     if (buffer) {
-      // Free buffer memory, pending the passage of a token.
-      buffer_tracker_->FreePendingToken(buffer, helper_->InsertToken());
-      // Remove buffer.
-      buffer_tracker_->RemoveBuffer(buffers[ii]);
+      buffer->set_used(false);
+      buffer->set_last_usage_token(helper_->InsertToken());
+
+      FreeTransferBuffer(buffer);
+      buffer_tracker_->RemoveBuffer(buffer->id());
     }
+
     if (buffers[ii] == bound_pixel_unpack_transfer_buffer_id_) {
       bound_pixel_unpack_transfer_buffer_id_ = 0;
     }
   }
 }
 
 void GLES2Implementation::DeleteBuffersStub(
     GLsizei n, const GLuint* buffers) {
   helper_->DeleteBuffersImmediate(n, buffers);
 }
@@ skipping 699 matching lines @@
   // queries across contexts?
   return query_tracker_->GetQuery(id) != NULL;
 }
 
 void GLES2Implementation::BeginQueryEXT(GLenum target, GLuint id) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] BeginQueryEXT("
                  << GLES2Util::GetStringQueryTarget(target)
                  << ", " << id << ")");
 
+  QueryKey key = std::make_pair(target, false);
+
   // if any outstanding queries INV_OP
-  QueryMap::iterator it = current_queries_.find(target);
+  QueryMap::iterator it = current_queries_.find(key);
   if (it != current_queries_.end()) {
     SetGLError(
         GL_INVALID_OPERATION, "glBeginQueryEXT", "query already in progress");
     return;
   }
 
   // id = 0 INV_OP
   if (id == 0) {
     SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT", "id is 0");
     return;
   }
 
   // TODO(gman) if id not GENned INV_OPERATION
 
   // if id does not have an object
   QueryTracker::Query* query = query_tracker_->GetQuery(id);
   if (!query) {
     query = query_tracker_->CreateQuery(id, target);
     if (!query) {
       MustBeContextLost();
       return;
     }
   } else if (query->target() != target) {
     SetGLError(
         GL_INVALID_OPERATION, "glBeginQueryEXT", "target does not match");
     return;
   }
 
-  current_queries_[target] = query;
+  current_queries_[key] = query;
 
   query->Begin(this);
   CheckGLError();
 }
 
 void GLES2Implementation::EndQueryEXT(GLenum target) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] EndQueryEXT("
                  << GLES2Util::GetStringQueryTarget(target) << ")");
   // Don't do anything if the context is lost.
   if (helper_->IsContextLost()) {
     return;
   }
 
-  QueryMap::iterator it = current_queries_.find(target);
+  QueryKey key = std::make_pair(target, false);
+  QueryMap::iterator it = current_queries_.find(key);
   if (it == current_queries_.end()) {
     SetGLError(GL_INVALID_OPERATION, "glEndQueryEXT", "no active query");
     return;
   }
 
   QueryTracker::Query* query = it->second;
   query->End(this);
   current_queries_.erase(it);
   CheckGLError();
 }
 
 void GLES2Implementation::GetQueryivEXT(
     GLenum target, GLenum pname, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] GetQueryivEXT("
                  << GLES2Util::GetStringQueryTarget(target) << ", "
                  << GLES2Util::GetStringQueryParameter(pname) << ", "
                  << static_cast<const void*>(params) << ")");
 
   if (pname != GL_CURRENT_QUERY_EXT) {
     SetGLErrorInvalidEnum("glGetQueryivEXT", pname, "pname");
     return;
   }
-  QueryMap::iterator it = current_queries_.find(target);
+  QueryKey key = std::make_pair(target, false);
+  QueryMap::iterator it = current_queries_.find(key);
   if (it != current_queries_.end()) {
     QueryTracker::Query* query = it->second;
     *params = query->id();
   } else {
     *params = 0;
   }
   GPU_CLIENT_LOG("  " << *params);
   CheckGLError();
 }
 
 void GLES2Implementation::GetQueryObjectuivEXT(
     GLuint id, GLenum pname, GLuint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] GetQueryivEXT(" << id << ", "
                  << GLES2Util::GetStringQueryObjectParameter(pname) << ", "
                  << static_cast<const void*>(params) << ")");
 
   QueryTracker::Query* query = query_tracker_->GetQuery(id);
   if (!query) {
     SetGLError(GL_INVALID_OPERATION, "glQueryObjectuivEXT", "unknown query id");
     return;
   }
 
-  QueryMap::iterator it = current_queries_.find(query->target());
+  QueryKey key = std::make_pair(query->target(), false);
+  QueryMap::iterator it = current_queries_.find(key);
   if (it != current_queries_.end()) {
     SetGLError(
         GL_INVALID_OPERATION,
         "glQueryObjectuivEXT", "query active. Did you to call glEndQueryEXT?");
     return;
   }
 
   if (query->NeverUsed()) {
     SetGLError(
         GL_INVALID_OPERATION,
@@ skipping 245 matching lines @@
   }
   if (!buffer->mapped()) {
     SetGLError(GL_INVALID_OPERATION, "glUnmapBufferCHROMIUM", "not mapped");
     return false;
   }
   buffer->set_mapped(false);
   CheckGLError();
   return true;
 }
 
+void GLES2Implementation::BeginInternalQueryAsyncPixelUnpackCompleted(
+    BufferTracker::Buffer *buffer) {
+  QueryKey key = std::make_pair(GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM, true);
+
+  DCHECK(current_queries_.find(key) == current_queries_.end());
+
+  GLuint id;
+  GetIdHandler(id_namespaces::kQueries)->MakeIds(this, 0, 1, &id);
+  QueryTracker::Query* query = query_tracker_->CreateInternalQuery(
+      id, GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM);
+  if (!query) {
+    MustBeContextLost();
+    return;
+  }
+
+  buffer->set_async_query_id(id);

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

What if we do several AsyncTexImage2DCHROMIUM on the same buffer?

[jadahl, 2014/01/11 11:35:29]

That would not work, true. I guess it could work by associating a buffer with a
query serial instead, and if a later AsyncTexImage2DCHROMIUM would occur, it'd
be updated with the new serial.

[piman, 2014/01/16 21:22:50]

We need to fix this, or change the API to prevent multiple
AsyncTexImage2DCHROMIUM on the same buffer (and document that), but I think the
latter is very limiting.

[jadahl, 2014/01/17 08:50:25]

Then should we just introduce a new internal command as discussed, without
having to hack gl queries to deal with this?

+  query->Begin(this);
+  CheckGLError();
+
+  current_queries_[key] = query;
+}
+
+void GLES2Implementation::EndInternalQueryAsyncPixelUnpackCompleted() {
+  QueryKey key = std::make_pair(GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM, true);
+
+  DCHECK(current_queries_.find(key) != current_queries_.end());
+
+  QueryMap::iterator it = current_queries_.find(key);
+  QueryTracker::Query* query = it->second;
+  query->End(this);
+  current_queries_.erase(it);
+  CheckGLError();
+}
+
 void GLES2Implementation::AsyncTexImage2DCHROMIUM(
     GLenum target, GLint level, GLint internalformat, GLsizei width,
     GLsizei height, GLint border, GLenum format, GLenum type,
     const void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
       << width << ", " << height << ", " << border << ", "
@@ skipping 24 matching lines @@
 
   // Otherwise, async uploads require a transfer buffer to be bound.
   // TODO(hubbe): Make MapBufferCHROMIUM block if someone tries to re-use
   // the buffer before the transfer is finished. (Currently such
   // synchronization has to be handled manually.)
   GLuint offset = ToGLuint(pixels);
   BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
       bound_pixel_unpack_transfer_buffer_id_,
       "glAsyncTexImage2DCHROMIUM", offset, size);
   if (buffer && buffer->shm_id() != -1) {
+    BeginInternalQueryAsyncPixelUnpackCompleted(buffer);
     helper_->AsyncTexImage2DCHROMIUM(
         target, level, internalformat, width, height, border, format, type,
         buffer->shm_id(), buffer->shm_offset() + offset);
+    EndInternalQueryAsyncPixelUnpackCompleted();
   }
 }
 
 void GLES2Implementation::AsyncTexSubImage2DCHROMIUM(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
     GLsizei height, GLenum format, GLenum type, const void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glAsyncTexSubImage2DCHROMIUM("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
@@ skipping 21 matching lines @@
 
   // Async uploads require a transfer buffer to be bound.
   // TODO(hubbe): Make MapBufferCHROMIUM block if someone tries to re-use
   // the buffer before the transfer is finished. (Currently such
   // synchronization has to be handled manually.)
   GLuint offset = ToGLuint(pixels);
   BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
       bound_pixel_unpack_transfer_buffer_id_,
       "glAsyncTexSubImage2DCHROMIUM", offset, size);
   if (buffer && buffer->shm_id() != -1) {
+    BeginInternalQueryAsyncPixelUnpackCompleted(buffer);
     helper_->AsyncTexSubImage2DCHROMIUM(
         target, level, xoffset, yoffset, width, height, format, type,
         buffer->shm_id(), buffer->shm_offset() + offset);
+    EndInternalQueryAsyncPixelUnpackCompleted();
   }
 }
 
 void GLES2Implementation::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glWaitAsyncTexImage2DCHROMIUM("
       << GLES2Util::GetStringTextureTarget(target) << ")");
   helper_->WaitAsyncTexImage2DCHROMIUM(target);
   CheckGLError();
 }
@@ skipping 166 matching lines @@
   CheckGLError();
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu