1 /*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #if SK_SUPPORT_GPU
9
10 #include "GrContextFactory.h"
11 #include "GrResourceCache.h"
12 #include "SkGpuDevice.h"
13 #include "Test.h"
14
15 static const int gWidth = 640;
16 static const int gHeight = 480;
17
18 ////////////////////////////////////////////////////////////////////////////////
test_cache(skiatest::Reporter * reporter,GrContext * context,SkCanvas * canvas)19 static void test_cache(skiatest::Reporter* reporter,
20 GrContext* context,
21 SkCanvas* canvas) {
22 const SkIRect size = SkIRect::MakeWH(gWidth, gHeight);
23
24 SkBitmap src;
25 src.allocN32Pixels(size.width(), size.height());
26 src.eraseColor(SK_ColorBLACK);
27 size_t srcSize = src.getSize();
28
29 size_t initialCacheSize;
30 context->getResourceCacheUsage(NULL, &initialCacheSize);
31
32 int oldMaxNum;
33 size_t oldMaxBytes;
34 context->getResourceCacheLimits(&oldMaxNum, &oldMaxBytes);
35
36 // Set the cache limits so we can fit 10 "src" images and the
37 // max number of textures doesn't matter
38 size_t maxCacheSize = initialCacheSize + 10*srcSize;
39 context->setResourceCacheLimits(1000, maxCacheSize);
40
41 SkBitmap readback;
42 readback.allocN32Pixels(size.width(), size.height());
43
44 for (int i = 0; i < 100; ++i) {
45 canvas->drawBitmap(src, 0, 0);
46 canvas->readPixels(size, &readback);
47
48 // "modify" the src texture
49 src.notifyPixelsChanged();
50
51 size_t curCacheSize;
52 context->getResourceCacheUsage(NULL, &curCacheSize);
53
54 // we should never go over the size limit
55 REPORTER_ASSERT(reporter, curCacheSize <= maxCacheSize);
56 }
57
58 context->setResourceCacheLimits(oldMaxNum, oldMaxBytes);
59 }
60
61 class TestResource : public GrCacheable {
62 static const size_t kDefaultSize = 100;
63
64 public:
65 SK_DECLARE_INST_COUNT(TestResource);
TestResource(size_t size=kDefaultSize)66 TestResource(size_t size = kDefaultSize)
67 : fCache(NULL)
68 , fToDelete(NULL)
69 , fSize(size) {
70 ++fAlive;
71 }
72
~TestResource()73 ~TestResource() {
74 --fAlive;
75 if (NULL != fToDelete) {
76 // Breaks our little 2-element cycle below.
77 fToDelete->setDeleteWhenDestroyed(NULL, NULL);
78 fCache->deleteResource(fToDelete->getCacheEntry());
79 }
80 }
81
setSize(size_t size)82 void setSize(size_t size) {
83 fSize = size;
84 this->didChangeGpuMemorySize();
85 }
86
gpuMemorySize() const87 size_t gpuMemorySize() const SK_OVERRIDE { return fSize; }
88
isValidOnGpu() const89 bool isValidOnGpu() const SK_OVERRIDE { return true; }
90
alive()91 static int alive() { return fAlive; }
92
setDeleteWhenDestroyed(GrResourceCache * cache,TestResource * resource)93 void setDeleteWhenDestroyed(GrResourceCache* cache, TestResource* resource) {
94 fCache = cache;
95 fToDelete = resource;
96 }
97
98 private:
99 GrResourceCache* fCache;
100 TestResource* fToDelete;
101 size_t fSize;
102 static int fAlive;
103
104 typedef GrCacheable INHERITED;
105 };
106 int TestResource::fAlive = 0;
107
test_purge_invalidated(skiatest::Reporter * reporter,GrContext * context)108 static void test_purge_invalidated(skiatest::Reporter* reporter, GrContext* context) {
109 GrCacheID::Domain domain = GrCacheID::GenerateDomain();
110 GrCacheID::Key keyData;
111 keyData.fData64[0] = 5;
112 keyData.fData64[1] = 18;
113 GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
114 GrResourceKey key(GrCacheID(domain, keyData), t, 0);
115
116 GrResourceCache cache(5, 30000);
117
118 // Add two resources with the same key that delete each other from the cache when destroyed.
119 TestResource* a = new TestResource();
120 TestResource* b = new TestResource();
121 cache.addResource(key, a);
122 cache.addResource(key, b);
123 // Circle back.
124 a->setDeleteWhenDestroyed(&cache, b);
125 b->setDeleteWhenDestroyed(&cache, a);
126 a->unref();
127 b->unref();
128
129 // Add a third independent resource also with the same key.
130 GrCacheable* r = new TestResource();
131 cache.addResource(key, r);
132 r->unref();
133
134 // Invalidate all three, all three should be purged and destroyed.
135 REPORTER_ASSERT(reporter, 3 == TestResource::alive());
136 const GrResourceInvalidatedMessage msg = { key };
137 SkMessageBus<GrResourceInvalidatedMessage>::Post(msg);
138 cache.purgeAsNeeded();
139 REPORTER_ASSERT(reporter, 0 == TestResource::alive());
140 }
141
test_cache_delete_on_destruction(skiatest::Reporter * reporter,GrContext * context)142 static void test_cache_delete_on_destruction(skiatest::Reporter* reporter,
143 GrContext* context) {
144 GrCacheID::Domain domain = GrCacheID::GenerateDomain();
145 GrCacheID::Key keyData;
146 keyData.fData64[0] = 5;
147 keyData.fData64[1] = 0;
148 GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
149
150 GrResourceKey key(GrCacheID(domain, keyData), t, 0);
151
152 {
153 {
154 GrResourceCache cache(3, 30000);
155 TestResource* a = new TestResource();
156 TestResource* b = new TestResource();
157 cache.addResource(key, a);
158 cache.addResource(key, b);
159
160 a->setDeleteWhenDestroyed(&cache, b);
161 b->setDeleteWhenDestroyed(&cache, a);
162
163 a->unref();
164 b->unref();
165 REPORTER_ASSERT(reporter, 2 == TestResource::alive());
166 }
167 REPORTER_ASSERT(reporter, 0 == TestResource::alive());
168 }
169 {
170 GrResourceCache cache(3, 30000);
171 TestResource* a = new TestResource();
172 TestResource* b = new TestResource();
173 cache.addResource(key, a);
174 cache.addResource(key, b);
175
176 a->setDeleteWhenDestroyed(&cache, b);
177 b->setDeleteWhenDestroyed(&cache, a);
178
179 a->unref();
180 b->unref();
181
182 cache.deleteResource(a->getCacheEntry());
183
184 REPORTER_ASSERT(reporter, 0 == TestResource::alive());
185 }
186 }
187
test_resource_size_changed(skiatest::Reporter * reporter,GrContext * context)188 static void test_resource_size_changed(skiatest::Reporter* reporter,
189 GrContext* context) {
190 GrCacheID::Domain domain = GrCacheID::GenerateDomain();
191 GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType();
192
193 GrCacheID::Key key1Data;
194 key1Data.fData64[0] = 0;
195 key1Data.fData64[1] = 0;
196 GrResourceKey key1(GrCacheID(domain, key1Data), t, 0);
197
198 GrCacheID::Key key2Data;
199 key2Data.fData64[0] = 1;
200 key2Data.fData64[1] = 0;
201 GrResourceKey key2(GrCacheID(domain, key2Data), t, 0);
202
203 // Test changing resources sizes (both increase & decrease).
204 {
205 GrResourceCache cache(2, 300);
206
207 TestResource* a = new TestResource(0);
208 a->setSize(100); // Test didChangeGpuMemorySize() when not in the cache.
209 cache.addResource(key1, a);
210 a->unref();
211
212 TestResource* b = new TestResource(0);
213 b->setSize(100);
214 cache.addResource(key2, b);
215 b->unref();
216
217 REPORTER_ASSERT(reporter, 200 == cache.getCachedResourceBytes());
218 REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
219
220 static_cast<TestResource*>(cache.find(key2))->setSize(200);
221 static_cast<TestResource*>(cache.find(key1))->setSize(50);
222
223 REPORTER_ASSERT(reporter, 250 == cache.getCachedResourceBytes());
224 REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
225 }
226
227 // Test increasing a resources size beyond the cache budget.
228 {
229 GrResourceCache cache(2, 300);
230
231 TestResource* a = new TestResource(100);
232 cache.addResource(key1, a);
233 a->unref();
234
235 TestResource* b = new TestResource(100);
236 cache.addResource(key2, b);
237 b->unref();
238
239 REPORTER_ASSERT(reporter, 200 == cache.getCachedResourceBytes());
240 REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
241
242 static_cast<TestResource*>(cache.find(key2))->setSize(201);
243 REPORTER_ASSERT(reporter, NULL == cache.find(key1));
244
245 REPORTER_ASSERT(reporter, 201 == cache.getCachedResourceBytes());
246 REPORTER_ASSERT(reporter, 1 == cache.getCachedResourceCount());
247 }
248
249 // Test changing the size of an exclusively-held resource.
250 {
251 GrResourceCache cache(2, 300);
252
253 TestResource* a = new TestResource(100);
254 cache.addResource(key1, a);
255 cache.makeExclusive(a->getCacheEntry());
256
257 TestResource* b = new TestResource(100);
258 cache.addResource(key2, b);
259 b->unref();
260
261 REPORTER_ASSERT(reporter, 200 == cache.getCachedResourceBytes());
262 REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
263 REPORTER_ASSERT(reporter, NULL == cache.find(key1));
264
265 a->setSize(200);
266
267 REPORTER_ASSERT(reporter, 300 == cache.getCachedResourceBytes());
268 REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
269 // Internal resource cache validation will test the detached size (debug mode only).
270
271 cache.makeNonExclusive(a->getCacheEntry());
272 a->unref();
273
274 REPORTER_ASSERT(reporter, 300 == cache.getCachedResourceBytes());
275 REPORTER_ASSERT(reporter, 2 == cache.getCachedResourceCount());
276 REPORTER_ASSERT(reporter, NULL != cache.find(key1));
277 // Internal resource cache validation will test the detached size (debug mode only).
278 }
279 }
280
281 ////////////////////////////////////////////////////////////////////////////////
DEF_GPUTEST(ResourceCache,reporter,factory)282 DEF_GPUTEST(ResourceCache, reporter, factory) {
283 for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
284 GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
285 if (!GrContextFactory::IsRenderingGLContext(glType)) {
286 continue;
287 }
288 GrContext* context = factory->get(glType);
289 if (NULL == context) {
290 continue;
291 }
292
293 GrTextureDesc desc;
294 desc.fConfig = kSkia8888_GrPixelConfig;
295 desc.fFlags = kRenderTarget_GrTextureFlagBit;
296 desc.fWidth = gWidth;
297 desc.fHeight = gHeight;
298
299 SkAutoTUnref<GrTexture> texture(context->createUncachedTexture(desc, NULL, 0));
300 SkAutoTUnref<SkGpuDevice> device(SkNEW_ARGS(SkGpuDevice, (context, texture.get())));
301 SkCanvas canvas(device.get());
302
303 test_cache(reporter, context, &canvas);
304 test_purge_invalidated(reporter, context);
305 test_cache_delete_on_destruction(reporter, context);
306 test_resource_size_changed(reporter, context);
307 }
308 }
309
310 #endif
311