Use mapped memory for uploading large textures.

gpu/command_buffer/client/ring_buffer.cc

 // Copyright (c) 2011 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.
 
 // This file contains the implementation of the RingBuffer class.
 
 #include "gpu/command_buffer/client/ring_buffer.h"
 
 #include <algorithm>
 
@@ skipping 85 matching lines @@
       DCHECK(block.state == IN_USE)
           << "block that corresponds to offset already freed";
       block.token = token;
       block.state = FREE_PENDING_TOKEN;
       return;
     }
   }
   NOTREACHED() << "attempt to free non-existant block";
 }
 
+void RingBuffer::DiscardBlock(void* pointer) {
+  Offset offset = GetOffset(pointer);
+  offset -= base_offset_;
+  DCHECK(!blocks_.empty()) << "no allocations to free";
+  for (Container::reverse_iterator it = blocks_.rbegin();
+        it != blocks_.rend();
+        ++it) {
+    Block& block = *it;
+    if (block.offset == offset) {
+      DCHECK(block.state == IN_USE)
+          << "block that corresponds to offset already freed";

[piman, 2015/06/09 22:55:05]

nit: I would keep this.

[David Yen, 2015/06/10 18:17:09]

I've changed it to check if state != PADDING. I think it is okay to discard a
FREE_PENDING_TOKEN.

+
+      // Mark this as padding and let the FreeOldestBlock() logic handle
+      // updating all the various offsets.

[piman, 2015/06/09 17:38:27]

I think this is close to not doing anything... If used like a RingBuffer (common
case), the freed block will be the last one, at the end of the blocks. The next
allocation will then try to allocate after that block (because we're not
modifying free_offset_), and if necessary will have to wait to free blocks
starting from the front, before even considering this block. So it's effectively
as if the block was FREE_PENDING_TOKEN with the previous block's token.

So I think it's important, if it's the last block, to move back free_offset_ to
offset and delete the block to allow reuse of this buffer. I guess the only
other constraint is wrt in_use_offset_, in that if they're equal we need to make
sure it indicates completely-free rather than completely-in-use (by clearing
blocks_ and resetting both of them to 0, although I think I can convince myself
they probably already are...).

[David Yen, 2015/06/09 20:11:20]

That is a fair point. I have added the logic to actually remove the blocks if
they are at the front or back, I also added unit tests for all the various
corner cases.

+      block.state = PADDING;
+      return;
+    }
+  }
+  NOTREACHED() << "attempt to free non-existant block";
+}
+
 unsigned int RingBuffer::GetLargestFreeSizeNoWaiting() {
   unsigned int last_token_read = helper_->last_token_read();
   while (!blocks_.empty()) {
     Block& block = blocks_.front();
     if (block.token > last_token_read || block.state == IN_USE) break;
     FreeOldestBlock();
   }
   if (free_offset_ == in_use_offset_) {
     if (blocks_.empty()) {
       // The entire buffer is free.
       DCHECK_EQ(free_offset_, 0u);
       return size_;
     } else {
       // The entire buffer is in use.
       return 0;
     }
   } else if (free_offset_ > in_use_offset_) {
     // It's free from free_offset_ to size_ and from 0 to in_use_offset_
     return std::max(size_ - free_offset_, in_use_offset_);
   } else {
     // It's free from free_offset_ -> in_use_offset_;
     return in_use_offset_ - free_offset_;
   }
 }
 
 }  // namespace gpu