| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
