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