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) {
+      if (&block == &blocks_.back()) {
+        // If this block is the last one we can effectively remove it.
+        if (free_offset_ == 0) {
+          // Last block had looped around.
+          free_offset_ = size_;
+        }
+        free_offset_ -= block.size;

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

nit: I would just do free_offset_ = offset so that you don't have to worry about
wraparound

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

Done.

+        blocks_.pop_back();
+
+        // We should also pop any PADDING at the back as well,
+        // but be careful because free_offset_ must be 0 when at the end.
+        while (!blocks_.empty() && blocks_.back().state == PADDING) {
+          if (free_offset_ == 0)
+            free_offset_ = size_;
+          free_offset_ -= blocks_.back().size;

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

Same here, if you want to pop PADDING ones, free_offset_ = blocks_.back().offset
should work.


Actually, you may want to simply set block.state = PADDING and go directly to
the while loop.

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

Done.

+          blocks_.pop_back();
+        }
+      } else if (&block == &blocks_.front()) {

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

I'm not sure the front part is that useful, because typically the use case is to
discard the last created block, and otherwise that case is handled efficiently
by FreeOldestBlock().

If you want to keep it, you could set block.state = PADDING and then go directly
to the while loop.

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

I think it is better to handle it here so that GetLargestFreeSizeNoWaiting() can
return a size accommodating this block immediately. In other parts of the code
we expect to wait otherwise.

+        // If this block is the front, we can remove it from the front.
+        in_use_offset_ += block.size;
+        if (in_use_offset_ == size_)
+          in_use_offset_ = 0;
+        blocks_.pop_front();
+
+        // We should also pop any PADDING at the front as well, but be careful
+        // because in_use_offset_ must be size_ when at the front.
+        while (!blocks_.empty() && blocks_.front().state == PADDING) {
+          in_use_offset_ += blocks_.front().size;
+          if (in_use_offset_ == size_)
+            in_use_offset_ = 0;
+          blocks_.pop_front();
+        }
+      } else {
+        // Mark this as padding and let the FreeOldestBlock() handle offsets.
+        block.state = PADDING;
+      }
+
+      // In the special case when there are no blocks, we should be reset it.
+      if (blocks_.empty()) {
+        in_use_offset_ = 0;
+        free_offset_ = 0;
+      }
+      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