1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
// Copyright 2012 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 "cc/resources/resource_pool.h"
#include "cc/resources/resource_provider.h"
namespace cc {
ResourcePool::Resource::Resource(cc::ResourceProvider* resource_provider,
gfx::Size size,
GLenum format)
: cc::Resource(resource_provider->CreateManagedResource(
size,
format,
ResourceProvider::TextureUsageAny),
size,
format),
resource_provider_(resource_provider) {
DCHECK(id());
}
ResourcePool::Resource::~Resource() {
DCHECK(id());
DCHECK(resource_provider_);
resource_provider_->DeleteResource(id());
}
ResourcePool::ResourcePool(ResourceProvider* resource_provider)
: resource_provider_(resource_provider),
max_memory_usage_bytes_(0),
max_unused_memory_usage_bytes_(0),
memory_usage_bytes_(0),
unused_memory_usage_bytes_(0),
num_resources_limit_(0) {
}
ResourcePool::~ResourcePool() {
SetMemoryUsageLimits(0, 0, 0);
}
scoped_ptr<ResourcePool::Resource> ResourcePool::AcquireResource(
gfx::Size size, GLenum format) {
for (ResourceList::iterator it = resources_.begin();
it != resources_.end(); ++it) {
Resource* resource = *it;
// TODO(epenner): It would be nice to DCHECK that this
// doesn't happen two frames in a row for any resource
// in this pool.
if (!resource_provider_->CanLockForWrite(resource->id()))
continue;
if (resource->size() != size)
continue;
if (resource->format() != format)
continue;
resources_.erase(it);
unused_memory_usage_bytes_ -= resource->bytes();
return make_scoped_ptr(resource);
}
// Create new resource.
Resource* resource = new Resource(
resource_provider_, size, format);
// Extend all read locks on all resources until the resource is
// finished being used, such that we know when resources are
// truly safe to recycle.
resource_provider_->EnableReadLockFences(resource->id(), true);
memory_usage_bytes_ += resource->bytes();
return make_scoped_ptr(resource);
}
void ResourcePool::ReleaseResource(
scoped_ptr<ResourcePool::Resource> resource) {
if (MemoryUsageTooHigh()) {
memory_usage_bytes_ -= resource->bytes();
return;
}
unused_memory_usage_bytes_ += resource->bytes();
resources_.push_back(resource.release());
}
void ResourcePool::SetMemoryUsageLimits(
size_t max_memory_usage_bytes,
size_t max_unused_memory_usage_bytes,
size_t num_resources_limit) {
max_memory_usage_bytes_ = max_memory_usage_bytes;
max_unused_memory_usage_bytes_ = max_unused_memory_usage_bytes;
num_resources_limit_ = num_resources_limit;
while (!resources_.empty()) {
if (!MemoryUsageTooHigh())
break;
// MRU eviction pattern as least recently used is less likely to
// be blocked by read lock fence.
Resource* resource = resources_.back();
resources_.pop_back();
memory_usage_bytes_ -= resource->bytes();
unused_memory_usage_bytes_ -= resource->bytes();
delete resource;
}
}
bool ResourcePool::MemoryUsageTooHigh() {
if (resources_.size() > num_resources_limit_)
return true;
if (memory_usage_bytes_ > max_memory_usage_bytes_)
return true;
if (unused_memory_usage_bytes_ > max_unused_memory_usage_bytes_)
return true;
return false;
}
} // namespace cc
|
