cc/resources/resource_pool.cc

   1 // Copyright 2012 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 "cc/resources/resource_pool.h"
   6
   7 #include "cc/resources/resource_provider.h"
   8 #include "cc/resources/scoped_resource.h"
   9
  10 namespace cc {
  11
  12 ResourcePool::ResourcePool(ResourceProvider* resource_provider, GLenum target)
  13     : resource_provider_(resource_provider),
  14       target_(target),
  15       max_memory_usage_bytes_(0),
  16       max_unused_memory_usage_bytes_(0),
  17       max_resource_count_(0),
  18       memory_usage_bytes_(0),
  19       unused_memory_usage_bytes_(0),
  20       resource_count_(0) {}
  21
  22 ResourcePool::~ResourcePool() {
  23   while (!busy_resources_.empty()) {
  24     DidFinishUsingResource(busy_resources_.front());
  25     busy_resources_.pop_front();
  26   }
  27
  28   SetResourceUsageLimits(0, 0, 0);
  29   DCHECK_EQ(0u, unused_resources_.size());
  30   DCHECK_EQ(0u, memory_usage_bytes_);
  31   DCHECK_EQ(0u, unused_memory_usage_bytes_);
  32   DCHECK_EQ(0u, resource_count_);
  33 }
  34
  35 scoped_ptr<ScopedResource> ResourcePool::AcquireResource(
  36     const gfx::Size& size, ResourceFormat format) {
  37   for (ResourceList::iterator it = unused_resources_.begin();
  38        it != unused_resources_.end();
  39        ++it) {
  40     ScopedResource* resource = *it;
  41     DCHECK(resource_provider_->CanLockForWrite(resource->id()));
  42
  43     if (resource->format() != format)
  44       continue;
  45     if (resource->size() != size)
  46       continue;
  47
  48     unused_resources_.erase(it);
  49     unused_memory_usage_bytes_ -= resource->bytes();
  50     return make_scoped_ptr(resource);
  51   }
  52
  53   scoped_ptr<ScopedResource> resource =
  54       ScopedResource::Create(resource_provider_);
  55   resource->AllocateManaged(size, target_, format);
  56
  57   memory_usage_bytes_ += resource->bytes();
  58   ++resource_count_;
  59   return resource.Pass();
  60 }
  61
  62 void ResourcePool::ReleaseResource(scoped_ptr<ScopedResource> resource) {
  63   busy_resources_.push_back(resource.release());
  64 }
  65
  66 void ResourcePool::SetResourceUsageLimits(size_t max_memory_usage_bytes,
  67                                           size_t max_unused_memory_usage_bytes,
  68                                           size_t max_resource_count) {
  69   max_memory_usage_bytes_ = max_memory_usage_bytes;
  70   max_unused_memory_usage_bytes_ = max_unused_memory_usage_bytes;
  71   max_resource_count_ = max_resource_count;
  72
  73   ReduceResourceUsage();
  74 }
  75
  76 void ResourcePool::ReduceResourceUsage() {
  77   while (!unused_resources_.empty()) {
  78     if (!ResourceUsageTooHigh())
  79       break;
  80
  81     // LRU eviction pattern. Most recently used might be blocked by
  82     // a read lock fence but it's still better to evict the least
  83     // recently used as it prevents a resource that is hard to reuse
  84     // because of unique size from being kept around. Resources that
  85     // can't be locked for write might also not be truly free-able.
  86     // We can free the resource here but it doesn't mean that the
  87     // memory is necessarily returned to the OS.
  88     ScopedResource* resource = unused_resources_.front();
  89     unused_resources_.pop_front();
  90     memory_usage_bytes_ -= resource->bytes();
  91     unused_memory_usage_bytes_ -= resource->bytes();
  92     --resource_count_;
  93     delete resource;
  94   }
  95 }
  96
  97 bool ResourcePool::ResourceUsageTooHigh() {
  98   if (resource_count_ > max_resource_count_)
  99     return true;
 100   if (memory_usage_bytes_ > max_memory_usage_bytes_)
 101     return true;
 102   if (unused_memory_usage_bytes_ > max_unused_memory_usage_bytes_)
 103     return true;
 104   return false;
 105 }
 106
 107 void ResourcePool::CheckBusyResources(bool wait_if_needed) {
 108   ResourceList::iterator it = busy_resources_.begin();
 109
 110   while (it != busy_resources_.end()) {
 111     ScopedResource* resource = *it;
 112
 113     if (wait_if_needed)
 114       resource_provider_->WaitReadLockIfNeeded(resource->id());
 115
 116     if (resource_provider_->CanLockForWrite(resource->id())) {
 117       DidFinishUsingResource(resource);
 118       it = busy_resources_.erase(it);
 119     } else {
 120       ++it;
 121     }
 122   }
 123 }
 124
 125 void ResourcePool::DidFinishUsingResource(ScopedResource* resource) {
 126   unused_memory_usage_bytes_ += resource->bytes();
 127   unused_resources_.push_back(resource);
 128 }
 129
 130 }  // namespace cc