gpu/command_buffer/client/mapped_memory.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/client/mapped_memory.h"
   6
   7 #include <algorithm>
   8 #include <functional>
   9
  10 #include "base/debug/trace_event.h"
  11 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
  12
  13 namespace gpu {
  14
  15 MemoryChunk::MemoryChunk(
  16     int32 shm_id, gpu::Buffer shm, CommandBufferHelper* helper)
  17     : shm_id_(shm_id),
  18       shm_(shm),
  19       allocator_(shm.size, helper, shm.ptr) {
  20 }
  21
  22 MappedMemoryManager::MappedMemoryManager(CommandBufferHelper* helper,
  23                                          size_t unused_memory_reclaim_limit)
  24     : chunk_size_multiple_(1),
  25       helper_(helper),
  26       allocated_memory_(0),
  27       max_free_bytes_(unused_memory_reclaim_limit) {
  28 }
  29
  30 MappedMemoryManager::~MappedMemoryManager() {
  31   CommandBuffer* cmd_buf = helper_->command_buffer();
  32   for (MemoryChunkVector::iterator iter = chunks_.begin();
  33        iter != chunks_.end(); ++iter) {
  34     MemoryChunk* chunk = *iter;
  35     cmd_buf->DestroyTransferBuffer(chunk->shm_id());
  36   }
  37 }
  38
  39 void* MappedMemoryManager::Alloc(
  40     unsigned int size, int32* shm_id, unsigned int* shm_offset) {
  41   GPU_DCHECK(shm_id);
  42   GPU_DCHECK(shm_offset);
  43   if (size <= allocated_memory_) {
  44     size_t total_bytes_in_use = 0;
  45     // See if any of the chunks can satisfy this request.
  46     for (size_t ii = 0; ii < chunks_.size(); ++ii) {
  47       MemoryChunk* chunk = chunks_[ii];
  48       chunk->FreeUnused();
  49       total_bytes_in_use += chunk->bytes_in_use();
  50       if (chunk->GetLargestFreeSizeWithoutWaiting() >= size) {
  51         void* mem = chunk->Alloc(size);
  52         GPU_DCHECK(mem);
  53         *shm_id = chunk->shm_id();
  54         *shm_offset = chunk->GetOffset(mem);
  55         return mem;
  56       }
  57     }
  58
  59     // If there is a memory limit being enforced and total free
  60     // memory (allocated_memory_ - total_bytes_in_use) is larger than
  61     // the limit try waiting.
  62     if (max_free_bytes_ != kNoLimit &&
  63         (allocated_memory_ - total_bytes_in_use) >= max_free_bytes_) {
  64       TRACE_EVENT0("gpu", "MappedMemoryManager::Alloc::wait");
  65       for (size_t ii = 0; ii < chunks_.size(); ++ii) {
  66         MemoryChunk* chunk = chunks_[ii];
  67         if (chunk->GetLargestFreeSizeWithWaiting() >= size) {
  68           void* mem = chunk->Alloc(size);
  69           GPU_DCHECK(mem);
  70           *shm_id = chunk->shm_id();
  71           *shm_offset = chunk->GetOffset(mem);
  72           return mem;
  73         }
  74       }
  75     }
  76   }
  77
  78   // Make a new chunk to satisfy the request.
  79   CommandBuffer* cmd_buf = helper_->command_buffer();
  80   unsigned int chunk_size =
  81       ((size + chunk_size_multiple_ - 1) / chunk_size_multiple_) *
  82       chunk_size_multiple_;
  83   int32 id = -1;
  84   gpu::Buffer shm = cmd_buf->CreateTransferBuffer(chunk_size, &id);
  85   if (id  < 0)
  86     return NULL;
  87   MemoryChunk* mc = new MemoryChunk(id, shm, helper_);
  88   allocated_memory_ += mc->GetSize();
  89   chunks_.push_back(mc);
  90   void* mem = mc->Alloc(size);
  91   GPU_DCHECK(mem);
  92   *shm_id = mc->shm_id();
  93   *shm_offset = mc->GetOffset(mem);
  94   return mem;
  95 }
  96
  97 void MappedMemoryManager::Free(void* pointer) {
  98   for (size_t ii = 0; ii < chunks_.size(); ++ii) {
  99     MemoryChunk* chunk = chunks_[ii];
 100     if (chunk->IsInChunk(pointer)) {
 101       chunk->Free(pointer);
 102       return;
 103     }
 104   }
 105   GPU_NOTREACHED();
 106 }
 107
 108 void MappedMemoryManager::FreePendingToken(void* pointer, int32 token) {
 109   for (size_t ii = 0; ii < chunks_.size(); ++ii) {
 110     MemoryChunk* chunk = chunks_[ii];
 111     if (chunk->IsInChunk(pointer)) {
 112       chunk->FreePendingToken(pointer, token);
 113       return;
 114     }
 115   }
 116   GPU_NOTREACHED();
 117 }
 118
 119 void MappedMemoryManager::FreeUnused() {
 120   CommandBuffer* cmd_buf = helper_->command_buffer();
 121   MemoryChunkVector::iterator iter = chunks_.begin();
 122   while (iter != chunks_.end()) {
 123     MemoryChunk* chunk = *iter;
 124     chunk->FreeUnused();
 125     if (!chunk->InUse()) {
 126       cmd_buf->DestroyTransferBuffer(chunk->shm_id());
 127       allocated_memory_ -= chunk->GetSize();
 128       iter = chunks_.erase(iter);
 129     } else {
 130       ++iter;
 131     }
 132   }
 133 }
 134
 135 }  // namespace gpu