Use mapped memory for uploading large textures.

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 <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
@@ skipping 2169 matching lines @@
   // advance pixels pointer past the skip rows and skip pixels
   pixels = reinterpret_cast<const int8*>(pixels) +
       unpack_skip_rows_ * src_padded_row_size;
   if (unpack_skip_pixels_) {
     uint32 group_size = GLES2Util::ComputeImageGroupSize(format, type);
     pixels = reinterpret_cast<const int8*>(pixels) +
         unpack_skip_pixels_ * group_size;
   }
 
   // Check if we can send it all at once.
-  ScopedTransferBufferPtr buffer(size, helper_, transfer_buffer_);
-  if (!buffer.valid()) {
-    return;
+  int32_t shm_id = 0;
+  uint32_t shm_offset = 0;
+  void* buffer_pointer = nullptr;
+
+  ScopedTransferBufferPtr transfer_alloc(size, helper_, transfer_buffer_);
+  ScopedMappedMemoryPtr mapped_alloc(0, helper_, mapped_memory_.get());
+
+  if (transfer_alloc.valid() && transfer_alloc.size() >= size) {
+    shm_id = transfer_alloc.shm_id();
+    shm_offset = transfer_alloc.offset();
+    buffer_pointer = transfer_alloc.address();
+  } else {
+    mapped_alloc.Reset(size);
+    if (mapped_alloc.valid()) {

[piman, 2015/06/08 21:57:38]

It would be good actually in this case, to free the transfer_alloc immediately
(as opposed to pending token as it will in the ScopedTransferBufferPtr
destructor). Otherwise we just tried to fill up the transfer buffer, finishing
everything just to do that, and we'll force the next call to finish again.
Because we haven't/will not actually write anything to that buffer, we can
release immediately.

Maybe you can add a Cancel() call to ScopedTransferBufferPtr that would do that?

[David Yen, 2015/06/08 22:18:01]

Is there a way to just mark blocks within the ring buffer as freed? I only see
functions to mark blocks as a free pending token or free the whole ring buffer.

[David Yen, 2015/06/09 02:03:52]

I added a DiscardBlock() function but Maintaining free_offset_ and
in_use_offset_ was a bit tricky, I think just marking the block as PADDING is
probably better since the logic to update those variables are well tested in
FreeOldestBlock(). I inspected the code to make sure PADDING is not assumed to
only exist at the end of the ring buffer.

+      mapped_alloc.SetFlushAfterRelease(true);
+      shm_id = mapped_alloc.shm_id();
+      shm_offset = mapped_alloc.offset();
+      buffer_pointer = mapped_alloc.address();
+    }
   }
 
-  if (buffer.size() >= size) {
+  if (buffer_pointer) {
     CopyRectToBuffer(
         pixels, height, unpadded_row_size, src_padded_row_size, unpack_flip_y_,
-        buffer.address(), padded_row_size);
+        buffer_pointer, padded_row_size);
     helper_->TexImage2D(
         target, level, internalformat, width, height, format, type,
-        buffer.shm_id(), buffer.offset());
+        shm_id, shm_offset);
     CheckGLError();
     return;
   }
 
+  // Check if we can allocate from mapped memory.

[piman, 2015/06/08 21:57:38]

You don't need this code any more, right? This is handled by the
ScopedMappedMemoryPtr path.

[David Yen, 2015/06/08 22:18:01]

Oops, forgot to delete. Done.

+  int32 mapped_shm_id = 0;
+  unsigned int mapped_shm_offset = 0;
+  void* mem = mapped_memory_->Alloc(size, &mapped_shm_id, &mapped_shm_offset);
+  if (mem) {
+    CopyRectToBuffer(
+        pixels, height, unpadded_row_size, src_padded_row_size, unpack_flip_y_,
+        mem, padded_row_size);
+    helper_->TexImage2D(
+        target, level, internalformat, width, height, format, type,
+        mapped_shm_id, mapped_shm_offset);
+    CheckGLError();
+    mapped_memory_->FreePendingToken(mem, helper_->InsertToken());
+    return;
+  }
+
   // No, so send it using TexSubImage2D.
   helper_->TexImage2D(
      target, level, internalformat, width, height, format, type,
      0, 0);
   TexSubImage2DImpl(
       target, level, 0, 0, width, height, format, type, unpadded_row_size,
-      pixels, src_padded_row_size, GL_TRUE, &buffer, padded_row_size);
+      pixels, src_padded_row_size, GL_TRUE, &transfer_alloc, padded_row_size);
   CheckGLError();
 }
 
 void GLES2Implementation::TexImage3D(
     GLenum target, GLint level, GLint internalformat, GLsizei width,
     GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type,
     const void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImage3D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
@@ skipping 65 matching lines @@
   pixels = reinterpret_cast<const int8*>(pixels) +
       unpack_skip_images_ * src_padded_row_size * src_height +
       unpack_skip_rows_ * src_padded_row_size;
   if (unpack_skip_pixels_) {
     uint32 group_size = GLES2Util::ComputeImageGroupSize(format, type);
     pixels = reinterpret_cast<const int8*>(pixels) +
         unpack_skip_pixels_ * group_size;
   }
 
   // Check if we can send it all at once.
-  ScopedTransferBufferPtr buffer(size, helper_, transfer_buffer_);
-  if (!buffer.valid()) {
-    return;
+  int32_t shm_id = 0;
+  uint32_t shm_offset = 0;
+  void* buffer_pointer = nullptr;
+
+  ScopedTransferBufferPtr transfer_alloc(size, helper_, transfer_buffer_);
+  ScopedMappedMemoryPtr mapped_alloc(0, helper_, mapped_memory_.get());
+
+  if (transfer_alloc.valid() && transfer_alloc.size() >= size) {
+    shm_id = transfer_alloc.shm_id();
+    shm_offset = transfer_alloc.offset();
+    buffer_pointer = transfer_alloc.address();
+  } else {
+    mapped_alloc.Reset(size);
+    if (mapped_alloc.valid()) {
+      mapped_alloc.SetFlushAfterRelease(true);
+      shm_id = mapped_alloc.shm_id();
+      shm_offset = mapped_alloc.offset();
+      buffer_pointer = mapped_alloc.address();
+    }
   }
 
-  if (buffer.size() >= size) {
-    void* buffer_pointer = buffer.address();
+  if (buffer_pointer) {
     for (GLsizei z = 0; z < depth; ++z) {
       // Only the last row of the last image is unpadded.
       uint32 src_unpadded_row_size =
           (z == depth - 1) ? unpadded_row_size : src_padded_row_size;
       // TODO(zmo): Ignore flip_y flag for now.
       CopyRectToBuffer(
           pixels, height, src_unpadded_row_size, src_padded_row_size, false,
           buffer_pointer, padded_row_size);
       pixels = reinterpret_cast<const int8*>(pixels) +
           src_padded_row_size * src_height;
       buffer_pointer = reinterpret_cast<int8*>(buffer_pointer) +
           padded_row_size * height;
     }
     helper_->TexImage3D(
         target, level, internalformat, width, height, depth, format, type,
-        buffer.shm_id(), buffer.offset());
+        shm_id, shm_offset);
     CheckGLError();
     return;
   }
 
+  // Check if we can allocate from mapped memory.
+  int32 mapped_shm_id = 0;
+  unsigned int mapped_shm_offset = 0;
+  void* mem = mapped_memory_->Alloc(size, &mapped_shm_id, &mapped_shm_offset);
+  if (mem) {
+    CopyRectToBuffer(
+        pixels, height, unpadded_row_size, src_padded_row_size, unpack_flip_y_,
+        mem, padded_row_size);
+    helper_->TexImage2D(
+        target, level, internalformat, width, height, format, type,
+        mapped_shm_id, mapped_shm_offset);
+    CheckGLError();
+    mapped_memory_->FreePendingToken(mem, helper_->InsertToken());
+  }
+
   // No, so send it using TexSubImage3D.
   helper_->TexImage3D(
      target, level, internalformat, width, height, depth, format, type,
      0, 0);
   TexSubImage3DImpl(
       target, level, 0, 0, 0, width, height, depth, format, type,
-      unpadded_row_size, pixels, src_padded_row_size, GL_TRUE, &buffer,
+      unpadded_row_size, pixels, src_padded_row_size, GL_TRUE, &transfer_alloc,
       padded_row_size);
   CheckGLError();
 }
 
 void GLES2Implementation::TexSubImage2D(
     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() << "] glTexSubImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
@@ skipping 3388 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