gpu: Reuse transfer buffers more aggresively

gpu/command_buffer/service/gles2_cmd_decoder.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/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <stack>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_synthetic_delay.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "build/build_config.h"
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/common/debug_marker_manager.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
@@ skipping 10255 matching lines @@
   if (!texture_ref ||
       async_pixel_transfer_manager_->AsyncTransferIsInProgress(texture_ref)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         function_name, "transfer already in progress");
     return false;
   }
   return true;
 }
 
+namespace {
+void UpdateAsyncUploadToken(AsyncUploadSync* sync, uint32 async_upload_token) {
+  base::subtle::MemoryBarrier();

[epennerAtGoogle, 2014/02/07 20:43:58]

See my other comment on MemoryBarriers. Wouldn't hurt to have a comment. And, do
we need a full barrier here since we are only writing to the value? I have to
admit I'm not completely familiar with what is required on either side.

+  sync->async_token = async_upload_token;
+}
+}
+
 error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
     uint32 immediate_data_size, const cmds::AsyncTexImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM");
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   // TODO(kloveless): Change HandleAsyncTexImage2DCHROMIUM command to use
   // unsigned integer for internalformat.
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id);
   uint32 pixels_shm_offset = static_cast<uint32>(c.pixels_shm_offset);
   uint32 pixels_size;
+  uint32 async_upload_token = static_cast<uint32>(c.async_upload_token);
+  uint32 sync_data_shm_id = static_cast<uint32>(c.sync_data_shm_id);
+  uint32 sync_data_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
+
+  base::ScopedClosureRunner scoped_completion_callback;
+  if (async_upload_token) {
+    AsyncUploadSync* sync = GetSharedMemoryAs<AsyncUploadSync*>(
+        sync_data_shm_id, sync_data_shm_offset, sizeof(*sync));

[piman, 2014/02/07 22:58:20]

The shared memory backing the AsyncUploadSync could be destroyed / unmapped
before the completion. For the transfer data, we dup the shm (for better or
worse), so we should do something similar or add some refcounting of the
transfer buffers, or something.

[jadahl, 2014/02/08 09:18:25]

As epenner replied elsewhere, SafeSharedMemoryPool handles this other places, so
I guess I should look into using that. And then it should be replaced with ref
counting and some layering. epenner, what bug number is that?

[epennerAtGoogle, 2014/02/10 23:12:06]

Bug for reference counting SharedMemory:
https://code.google.com/p/chromium/issues/detail?id=177063

+    scoped_completion_callback.Reset(base::Bind(
+            &AsyncPixelTransferManager::AsyncRun,
+            base::Unretained(GetAsyncPixelTransferManager()),
+            base::Bind(&UpdateAsyncUploadToken,
+                       sync,
+                       async_upload_token)));
+  }
 
   // TODO(epenner): Move this and copies of this memory validation
   // into ValidateTexImage2D step.
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, state_.unpack_alignment, &pixels_size, NULL,
       NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = NULL;
   if (pixels_shm_id != 0 || pixels_shm_offset != 0) {
@@ skipping 74 matching lines @@
     uint32 immediate_data_size, const cmds::AsyncTexSubImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM");
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
+  uint32 async_upload_token = static_cast<uint32>(c.async_upload_token);
+  uint32 sync_data_shm_id = static_cast<uint32>(c.sync_data_shm_id);
+  uint32 sync_data_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
+
+  base::ScopedClosureRunner scoped_completion_callback;
+  if (async_upload_token) {
+    AsyncUploadSync* sync = GetSharedMemoryAs<AsyncUploadSync*>(
+        sync_data_shm_id, sync_data_shm_offset, sizeof(*sync));
+    scoped_completion_callback.Reset(base::Bind(
+            &AsyncPixelTransferManager::AsyncRun,
+            base::Unretained(GetAsyncPixelTransferManager()),
+            base::Bind(&UpdateAsyncUploadToken,
+                       sync,
+                       async_upload_token)));
+  }
 
   // TODO(epenner): Move this and copies of this memory validation
   // into ValidateTexSubImage2D step.
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, state_.unpack_alignment, &data_size,
       NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetSharedMemoryAs<const void*>(
@@ skipping 103 matching lines @@
   DoDidUseTexImageIfNeeded(texture, texture->target());
 }
 
 // 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/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu