Use mapped memory for uploading large textures.

gpu/command_buffer/client/ring_buffer.cc

Index: gpu/command_buffer/client/ring_buffer.cc
diff --git a/gpu/command_buffer/client/ring_buffer.cc b/gpu/command_buffer/client/ring_buffer.cc
index 813bb348863d8810c93690896a9441c67e194c79..bf848a22199bc27903aecc786486de91150114ff 100644
--- a/gpu/command_buffer/client/ring_buffer.cc
+++ b/gpu/command_buffer/client/ring_buffer.cc
@@ -103,6 +103,27 @@ void RingBuffer::FreePendingToken(void* pointer,
   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()) {