Enforce a memory limit on MappedMemoryManager

gpu/command_buffer/client/mapped_memory.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.
 
 #include "gpu/command_buffer/client/mapped_memory.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 
 namespace gpu {
 
 MemoryChunk::MemoryChunk(
     int32 shm_id, gpu::Buffer shm, CommandBufferHelper* helper)
     : shm_id_(shm_id),
       shm_(shm),
       allocator_(shm.size, helper, shm.ptr) {
 }
 
 MappedMemoryManager::MappedMemoryManager(CommandBufferHelper* helper)
     : chunk_size_multiple_(1),
-      helper_(helper) {
+      helper_(helper),
+      allocated_memory_(0),
+      memory_limit_(kNoLimit) {
+}
+
+MappedMemoryManager::MappedMemoryManager(CommandBufferHelper* helper,

[no sievers, 2013/08/19 21:57:44]

Let's not add a new constructor for that. It just causes surface for bugs.

[kaanb, 2013/08/20 01:23:43]

Done.

+                                         size_t memory_limit)
+    : chunk_size_multiple_(1),
+      helper_(helper),
+      allocated_memory_(0),
+      memory_limit_(memory_limit) {
 }
 
 MappedMemoryManager::~MappedMemoryManager() {
   CommandBuffer* cmd_buf = helper_->command_buffer();
   for (MemoryChunkVector::iterator iter = chunks_.begin();
        iter != chunks_.end(); ++iter) {
     MemoryChunk* chunk = *iter;
     cmd_buf->DestroyTransferBuffer(chunk->shm_id());
   }
 }
 
 void* MappedMemoryManager::Alloc(
     unsigned int size, int32* shm_id, unsigned int* shm_offset) {
   GPU_DCHECK(shm_id);
   GPU_DCHECK(shm_offset);
-  // See if any of the chucks can satisfy this request.
+  // See if any of the chunks can satisfy this request.
   for (size_t ii = 0; ii < chunks_.size(); ++ii) {
     MemoryChunk* chunk = chunks_[ii];
     chunk->FreeUnused();
     if (chunk->GetLargestFreeSizeWithoutWaiting() >= size) {
       void* mem = chunk->Alloc(size);
       GPU_DCHECK(mem);
       *shm_id = chunk->shm_id();
       *shm_offset = chunk->GetOffset(mem);
       return mem;
     }
   }
 
+  // If there is a memory limit being enforced and the allocated memory
+  // is above the limit, try existing chunks again with waiting.

[epenner, 2013/08/19 22:05:52]

This should be rare right? Should we add a trace around this potentially-slow
path?

[kaanb, 2013/08/20 01:23:43]

See line 76

+  if (memory_limit_ != kNoLimit && allocated_memory_ >= memory_limit_) {

[no sievers, 2013/08/19 21:57:44]

What do you all think about looking at the free+free_pending_token memory here?

That way we can make this a well defined hard limit, for example
max_free_or_pending_memory_ instead of something very vague that you wouldn't
really know what to set it to (you would have to make it dependent on another
value in cc).

Together with the client's limit (i.e. cc's limit for pending raster jobs), this
would then allow us to set a hard limit for all shared memory used for texture
uploads in this path.

You could then probably also safely set it to some high limit for all platforms
and wouldn't have to deal with kNoLimit here.

[kaanb, 2013/08/20 01:23:43]

Done.

+    for (size_t ii = 0; ii < chunks_.size(); ++ii) {
+      MemoryChunk* chunk = chunks_[ii];
+      chunk->FreeUnused();
+      if (chunk->GetLargestFreeSizeWithWaiting() >= size) {
+        void* mem = chunk->Alloc(size);
+        GPU_DCHECK(mem);
+        *shm_id = chunk->shm_id();
+        *shm_offset = chunk->GetOffset(mem);
+        return mem;
+      }
+    }
+    LOG(INFO) << "Exceeding memory limit: " << memory_limit_;
+  }
+
   // Make a new chunk to satisfy the request.
   CommandBuffer* cmd_buf = helper_->command_buffer();
   unsigned int chunk_size =
       ((size + chunk_size_multiple_ - 1) / chunk_size_multiple_) *
       chunk_size_multiple_;
   int32 id = -1;
   gpu::Buffer shm = cmd_buf->CreateTransferBuffer(chunk_size, &id);
   if (id  < 0)
     return NULL;
   MemoryChunk* mc = new MemoryChunk(id, shm, helper_);
+  allocated_memory_ += mc->GetSize();
   chunks_.push_back(mc);
   void* mem = mc->Alloc(size);
   GPU_DCHECK(mem);
   *shm_id = mc->shm_id();
   *shm_offset = mc->GetOffset(mem);
   return mem;
 }
 
 void MappedMemoryManager::Free(void* pointer) {
   for (size_t ii = 0; ii < chunks_.size(); ++ii) {
@@ skipping 18 matching lines @@
 }
 
 void MappedMemoryManager::FreeUnused() {
   CommandBuffer* cmd_buf = helper_->command_buffer();
   MemoryChunkVector::iterator iter = chunks_.begin();
   while (iter != chunks_.end()) {
     MemoryChunk* chunk = *iter;
     chunk->FreeUnused();
     if (!chunk->InUse()) {
       cmd_buf->DestroyTransferBuffer(chunk->shm_id());
+      allocated_memory_ -= chunk->GetSize();
       iter = chunks_.erase(iter);
     } else {
       ++iter;
     }
   }
 }
 
 }  // namespace gpu
-
-
-