1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "OpenGLRenderer"
18
19 #include <utils/JenkinsHash.h>
20 #include <utils/Log.h>
21
22 #include "Caches.h"
23 #include "Patch.h"
24 #include "PatchCache.h"
25 #include "Properties.h"
26 #include "renderstate/RenderState.h"
27
28 namespace android {
29 namespace uirenderer {
30
31 ///////////////////////////////////////////////////////////////////////////////
32 // Constructors/destructor
33 ///////////////////////////////////////////////////////////////////////////////
34
PatchCache(RenderState & renderState)35 PatchCache::PatchCache(RenderState& renderState)
36 : mRenderState(renderState)
37 , mSize(0)
38 , mCache(LruCache<PatchDescription, Patch*>::kUnlimitedCapacity)
39 , mMeshBuffer(0)
40 , mFreeBlocks(nullptr)
41 , mGenerationId(0) {
42 char property[PROPERTY_VALUE_MAX];
43 if (property_get(PROPERTY_PATCH_CACHE_SIZE, property, nullptr) > 0) {
44 INIT_LOGD(" Setting patch cache size to %skB", property);
45 mMaxSize = KB(atoi(property));
46 } else {
47 INIT_LOGD(" Using default patch cache size of %.2fkB", DEFAULT_PATCH_CACHE_SIZE);
48 mMaxSize = KB(DEFAULT_PATCH_CACHE_SIZE);
49 }
50 }
51
~PatchCache()52 PatchCache::~PatchCache() {
53 clear();
54 }
55
init()56 void PatchCache::init() {
57 bool created = false;
58 if (!mMeshBuffer) {
59 glGenBuffers(1, &mMeshBuffer);
60 created = true;
61 }
62
63 mRenderState.meshState().bindMeshBuffer(mMeshBuffer);
64 mRenderState.meshState().resetVertexPointers();
65
66 if (created) {
67 createVertexBuffer();
68 }
69 }
70
71 ///////////////////////////////////////////////////////////////////////////////
72 // Caching
73 ///////////////////////////////////////////////////////////////////////////////
74
hash() const75 hash_t PatchCache::PatchDescription::hash() const {
76 uint32_t hash = JenkinsHashMix(0, android::hash_type(mPatch));
77 hash = JenkinsHashMix(hash, mBitmapWidth);
78 hash = JenkinsHashMix(hash, mBitmapHeight);
79 hash = JenkinsHashMix(hash, mPixelWidth);
80 hash = JenkinsHashMix(hash, mPixelHeight);
81 return JenkinsHashWhiten(hash);
82 }
83
compare(const PatchCache::PatchDescription & lhs,const PatchCache::PatchDescription & rhs)84 int PatchCache::PatchDescription::compare(const PatchCache::PatchDescription& lhs,
85 const PatchCache::PatchDescription& rhs) {
86 return memcmp(&lhs, &rhs, sizeof(PatchDescription));
87 }
88
clear()89 void PatchCache::clear() {
90 clearCache();
91
92 if (mMeshBuffer) {
93 mRenderState.meshState().unbindMeshBuffer();
94 glDeleteBuffers(1, &mMeshBuffer);
95 mMeshBuffer = 0;
96 mSize = 0;
97 }
98 }
99
clearCache()100 void PatchCache::clearCache() {
101 LruCache<PatchDescription, Patch*>::Iterator i(mCache);
102 while (i.next()) {
103 delete i.value();
104 }
105 mCache.clear();
106
107 BufferBlock* block = mFreeBlocks;
108 while (block) {
109 BufferBlock* next = block->next;
110 delete block;
111 block = next;
112 }
113 mFreeBlocks = nullptr;
114 }
115
remove(Vector<patch_pair_t> & patchesToRemove,Res_png_9patch * patch)116 void PatchCache::remove(Vector<patch_pair_t>& patchesToRemove, Res_png_9patch* patch) {
117 LruCache<PatchDescription, Patch*>::Iterator i(mCache);
118 while (i.next()) {
119 const PatchDescription& key = i.key();
120 if (key.getPatch() == patch) {
121 patchesToRemove.push(patch_pair_t(&key, i.value()));
122 }
123 }
124 }
125
removeDeferred(Res_png_9patch * patch)126 void PatchCache::removeDeferred(Res_png_9patch* patch) {
127 Mutex::Autolock _l(mLock);
128
129 // Assert that patch is not already garbage
130 size_t count = mGarbage.size();
131 for (size_t i = 0; i < count; i++) {
132 if (patch == mGarbage[i]) {
133 patch = nullptr;
134 break;
135 }
136 }
137 LOG_ALWAYS_FATAL_IF(patch == nullptr);
138
139 mGarbage.push(patch);
140 }
141
clearGarbage()142 void PatchCache::clearGarbage() {
143 Vector<patch_pair_t> patchesToRemove;
144
145 { // scope for the mutex
146 Mutex::Autolock _l(mLock);
147 size_t count = mGarbage.size();
148 for (size_t i = 0; i < count; i++) {
149 Res_png_9patch* patch = mGarbage[i];
150 remove(patchesToRemove, patch);
151 // A Res_png_9patch is actually an array of byte that's larger
152 // than sizeof(Res_png_9patch). It must be freed as an array.
153 delete[] (int8_t*) patch;
154 }
155 mGarbage.clear();
156 }
157
158 // TODO: We could sort patchesToRemove by offset to merge
159 // adjacent free blocks
160 for (size_t i = 0; i < patchesToRemove.size(); i++) {
161 const patch_pair_t& pair = patchesToRemove[i];
162
163 // Release the patch and mark the space in the free list
164 Patch* patch = pair.getSecond();
165 BufferBlock* block = new BufferBlock(patch->positionOffset, patch->getSize());
166 block->next = mFreeBlocks;
167 mFreeBlocks = block;
168
169 mSize -= patch->getSize();
170
171 mCache.remove(*pair.getFirst());
172 delete patch;
173 }
174
175 #if DEBUG_PATCHES
176 if (patchesToRemove.size() > 0) {
177 dumpFreeBlocks("Removed garbage");
178 }
179 #endif
180 }
181
createVertexBuffer()182 void PatchCache::createVertexBuffer() {
183 glBufferData(GL_ARRAY_BUFFER, mMaxSize, nullptr, GL_DYNAMIC_DRAW);
184 mSize = 0;
185 mFreeBlocks = new BufferBlock(0, mMaxSize);
186 mGenerationId++;
187 }
188
189 /**
190 * Sets the mesh's offsets and copies its associated vertices into
191 * the mesh buffer (VBO).
192 */
setupMesh(Patch * newMesh)193 void PatchCache::setupMesh(Patch* newMesh) {
194 // This call ensures the VBO exists and that it is bound
195 init();
196
197 // If we're running out of space, let's clear the entire cache
198 uint32_t size = newMesh->getSize();
199 if (mSize + size > mMaxSize) {
200 clearCache();
201 createVertexBuffer();
202 }
203
204 // Find a block where we can fit the mesh
205 BufferBlock* previous = nullptr;
206 BufferBlock* block = mFreeBlocks;
207 while (block) {
208 // The mesh fits
209 if (block->size >= size) {
210 break;
211 }
212 previous = block;
213 block = block->next;
214 }
215
216 // We have enough space left in the buffer, but it's
217 // too fragmented, let's clear the cache
218 if (!block) {
219 clearCache();
220 createVertexBuffer();
221 previous = nullptr;
222 block = mFreeBlocks;
223 }
224
225 // Copy the 9patch mesh in the VBO
226 newMesh->positionOffset = (GLintptr) (block->offset);
227 newMesh->textureOffset = newMesh->positionOffset + kMeshTextureOffset;
228 glBufferSubData(GL_ARRAY_BUFFER, newMesh->positionOffset, size, newMesh->vertices.get());
229
230 // Remove the block since we've used it entirely
231 if (block->size == size) {
232 if (previous) {
233 previous->next = block->next;
234 } else {
235 mFreeBlocks = block->next;
236 }
237 delete block;
238 } else {
239 // Resize the block now that it's occupied
240 block->offset += size;
241 block->size -= size;
242 }
243
244 mSize += size;
245 }
246
247 static const UvMapper sIdentity;
248
get(const AssetAtlas::Entry * entry,const uint32_t bitmapWidth,const uint32_t bitmapHeight,const float pixelWidth,const float pixelHeight,const Res_png_9patch * patch)249 const Patch* PatchCache::get(const AssetAtlas::Entry* entry,
250 const uint32_t bitmapWidth, const uint32_t bitmapHeight,
251 const float pixelWidth, const float pixelHeight, const Res_png_9patch* patch) {
252
253 const PatchDescription description(bitmapWidth, bitmapHeight, pixelWidth, pixelHeight, patch);
254 const Patch* mesh = mCache.get(description);
255
256 if (!mesh) {
257 const UvMapper& mapper = entry ? entry->uvMapper : sIdentity;
258 Patch* newMesh = new Patch(bitmapWidth, bitmapHeight,
259 pixelWidth, pixelHeight, mapper, patch);
260
261 if (newMesh->vertices) {
262 setupMesh(newMesh);
263 }
264
265 #if DEBUG_PATCHES
266 dumpFreeBlocks("Adding patch");
267 #endif
268
269 mCache.put(description, newMesh);
270 return newMesh;
271 }
272
273 return mesh;
274 }
275
276 #if DEBUG_PATCHES
dumpFreeBlocks(const char * prefix)277 void PatchCache::dumpFreeBlocks(const char* prefix) {
278 String8 dump;
279 BufferBlock* block = mFreeBlocks;
280 while (block) {
281 dump.appendFormat("->(%d, %d)", block->positionOffset, block->size);
282 block = block->next;
283 }
284 ALOGD("%s: Free blocks%s", prefix, dump.string());
285 }
286 #endif
287
288 }; // namespace uirenderer
289 }; // namespace android
290