halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2014 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 | */ |
reed | 30ad530 | 2014-09-16 10:39:55 -0700 | [diff] [blame] | 7 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "include/core/SkCanvas.h" |
| 9 | #include "include/core/SkGraphics.h" |
| 10 | #include "include/core/SkPicture.h" |
| 11 | #include "include/core/SkPictureRecorder.h" |
| 12 | #include "include/core/SkSurface.h" |
| 13 | #include "src/core/SkBitmapCache.h" |
| 14 | #include "src/core/SkBitmapProvider.h" |
| 15 | #include "src/core/SkMakeUnique.h" |
| 16 | #include "src/core/SkMipMap.h" |
| 17 | #include "src/core/SkResourceCache.h" |
| 18 | #include "src/lazy/SkDiscardableMemoryPool.h" |
| 19 | #include "tests/Test.h" |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 20 | |
reed | 30ad530 | 2014-09-16 10:39:55 -0700 | [diff] [blame] | 21 | //////////////////////////////////////////////////////////////////////////////////////// |
mtklein | 26abcf1 | 2014-09-04 10:50:53 -0700 | [diff] [blame] | 22 | |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 23 | enum LockedState { |
| 24 | kNotLocked, |
| 25 | kLocked, |
| 26 | }; |
| 27 | |
| 28 | enum CachedState { |
| 29 | kNotInCache, |
| 30 | kInCache, |
| 31 | }; |
| 32 | |
| 33 | static void check_data(skiatest::Reporter* reporter, const SkCachedData* data, |
| 34 | int refcnt, CachedState cacheState, LockedState lockedState) { |
| 35 | REPORTER_ASSERT(reporter, data->testing_only_getRefCnt() == refcnt); |
| 36 | REPORTER_ASSERT(reporter, data->testing_only_isInCache() == (kInCache == cacheState)); |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 37 | bool isLocked = (data->data() != nullptr); |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 38 | REPORTER_ASSERT(reporter, isLocked == (lockedState == kLocked)); |
| 39 | } |
| 40 | |
| 41 | static void test_mipmapcache(skiatest::Reporter* reporter, SkResourceCache* cache) { |
| 42 | cache->purgeAll(); |
| 43 | |
| 44 | SkBitmap src; |
| 45 | src.allocN32Pixels(5, 5); |
| 46 | src.setImmutable(); |
Brian Osman | 3a16073 | 2018-10-15 15:32:06 -0400 | [diff] [blame] | 47 | sk_sp<SkImage> img = SkImage::MakeFromBitmap(src); |
| 48 | SkBitmapProvider provider(img.get()); |
| 49 | const auto desc = provider.makeCacheDesc(); |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 50 | |
Brian Osman | 3a16073 | 2018-10-15 15:32:06 -0400 | [diff] [blame] | 51 | const SkMipMap* mipmap = SkMipMapCache::FindAndRef(desc, cache); |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 52 | REPORTER_ASSERT(reporter, nullptr == mipmap); |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 53 | |
Brian Osman | 3a16073 | 2018-10-15 15:32:06 -0400 | [diff] [blame] | 54 | mipmap = SkMipMapCache::AddAndRef(provider, cache); |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 55 | REPORTER_ASSERT(reporter, mipmap); |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 56 | |
| 57 | { |
Brian Osman | 3a16073 | 2018-10-15 15:32:06 -0400 | [diff] [blame] | 58 | const SkMipMap* mm = SkMipMapCache::FindAndRef(desc, cache); |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 59 | REPORTER_ASSERT(reporter, mm); |
| 60 | REPORTER_ASSERT(reporter, mm == mipmap); |
| 61 | mm->unref(); |
| 62 | } |
| 63 | |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 64 | check_data(reporter, mipmap, 2, kInCache, kLocked); |
| 65 | |
| 66 | mipmap->unref(); |
| 67 | // tricky, since technically after this I'm no longer an owner, but since the cache is |
| 68 | // local, I know it won't get purged behind my back |
| 69 | check_data(reporter, mipmap, 1, kInCache, kNotLocked); |
| 70 | |
| 71 | // find us again |
Brian Osman | 3a16073 | 2018-10-15 15:32:06 -0400 | [diff] [blame] | 72 | mipmap = SkMipMapCache::FindAndRef(desc, cache); |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 73 | check_data(reporter, mipmap, 2, kInCache, kLocked); |
| 74 | |
| 75 | cache->purgeAll(); |
| 76 | check_data(reporter, mipmap, 1, kNotInCache, kLocked); |
| 77 | |
| 78 | mipmap->unref(); |
| 79 | } |
| 80 | |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 81 | static void test_mipmap_notify(skiatest::Reporter* reporter, SkResourceCache* cache) { |
| 82 | const int N = 3; |
reed | 6644d93 | 2016-06-10 11:41:47 -0700 | [diff] [blame] | 83 | |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 84 | SkBitmap src[N]; |
Brian Osman | 3a16073 | 2018-10-15 15:32:06 -0400 | [diff] [blame] | 85 | sk_sp<SkImage> img[N]; |
| 86 | SkBitmapCacheDesc desc[N]; |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 87 | for (int i = 0; i < N; ++i) { |
| 88 | src[i].allocN32Pixels(5, 5); |
| 89 | src[i].setImmutable(); |
Brian Osman | 3a16073 | 2018-10-15 15:32:06 -0400 | [diff] [blame] | 90 | img[i] = SkImage::MakeFromBitmap(src[i]); |
| 91 | SkBitmapProvider provider(img[i].get()); |
| 92 | SkMipMapCache::AddAndRef(provider, cache)->unref(); |
| 93 | desc[i] = provider.makeCacheDesc(); |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 94 | } |
| 95 | |
| 96 | for (int i = 0; i < N; ++i) { |
Brian Osman | 3a16073 | 2018-10-15 15:32:06 -0400 | [diff] [blame] | 97 | const SkMipMap* mipmap = SkMipMapCache::FindAndRef(desc[i], cache); |
| 98 | // We're always using a local cache, so we know we won't be purged by other threads |
| 99 | REPORTER_ASSERT(reporter, mipmap); |
| 100 | SkSafeUnref(mipmap); |
| 101 | |
| 102 | img[i].reset(); // delete the image, which *should not* remove us from the cache |
| 103 | mipmap = SkMipMapCache::FindAndRef(desc[i], cache); |
| 104 | REPORTER_ASSERT(reporter, mipmap); |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 105 | SkSafeUnref(mipmap); |
| 106 | |
Brian Osman | 087c917 | 2018-10-15 10:33:54 -0400 | [diff] [blame] | 107 | src[i].reset(); // delete the underlying pixelref, which *should* remove us from the cache |
Brian Osman | 3a16073 | 2018-10-15 15:32:06 -0400 | [diff] [blame] | 108 | mipmap = SkMipMapCache::FindAndRef(desc[i], cache); |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 109 | REPORTER_ASSERT(reporter, !mipmap); |
| 110 | } |
| 111 | } |
| 112 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 113 | #include "src/lazy/SkDiscardableMemoryPool.h" |
aleksandar.stojiljkovic | 07e2692 | 2015-11-10 04:55:15 -0800 | [diff] [blame] | 114 | |
Ben Wagner | a93a14a | 2017-08-28 10:34:05 -0400 | [diff] [blame] | 115 | static SkDiscardableMemoryPool* gPool = nullptr; |
aleksandar.stojiljkovic | 07e2692 | 2015-11-10 04:55:15 -0800 | [diff] [blame] | 116 | static SkDiscardableMemory* pool_factory(size_t bytes) { |
| 117 | SkASSERT(gPool); |
| 118 | return gPool->create(bytes); |
| 119 | } |
| 120 | |
| 121 | static void testBitmapCache_discarded_bitmap(skiatest::Reporter* reporter, SkResourceCache* cache, |
| 122 | SkResourceCache::DiscardableFactory factory) { |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 123 | test_mipmapcache(reporter, cache); |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 124 | test_mipmap_notify(reporter, cache); |
danakj | 790ffe3 | 2014-09-11 10:49:52 -0700 | [diff] [blame] | 125 | } |
fmalita | 3b0d532 | 2015-09-18 08:07:31 -0700 | [diff] [blame] | 126 | |
aleksandar.stojiljkovic | 07e2692 | 2015-11-10 04:55:15 -0800 | [diff] [blame] | 127 | DEF_TEST(BitmapCache_discarded_bitmap, reporter) { |
| 128 | const size_t byteLimit = 100 * 1024; |
| 129 | { |
| 130 | SkResourceCache cache(byteLimit); |
| 131 | testBitmapCache_discarded_bitmap(reporter, &cache, nullptr); |
| 132 | } |
| 133 | { |
Hal Canary | 788c3c4 | 2017-04-25 08:58:57 -0400 | [diff] [blame] | 134 | sk_sp<SkDiscardableMemoryPool> pool(SkDiscardableMemoryPool::Make(byteLimit)); |
aleksandar.stojiljkovic | 07e2692 | 2015-11-10 04:55:15 -0800 | [diff] [blame] | 135 | gPool = pool.get(); |
| 136 | SkResourceCache::DiscardableFactory factory = pool_factory; |
| 137 | SkResourceCache cache(factory); |
| 138 | testBitmapCache_discarded_bitmap(reporter, &cache, factory); |
| 139 | } |
| 140 | } |
| 141 | |
fmalita | 3b0d532 | 2015-09-18 08:07:31 -0700 | [diff] [blame] | 142 | static void test_discarded_image(skiatest::Reporter* reporter, const SkMatrix& transform, |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 143 | sk_sp<SkImage> (*buildImage)()) { |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 144 | auto surface(SkSurface::MakeRasterN32Premul(10, 10)); |
fmalita | 3b0d532 | 2015-09-18 08:07:31 -0700 | [diff] [blame] | 145 | SkCanvas* canvas = surface->getCanvas(); |
| 146 | |
| 147 | // SkBitmapCache is global, so other threads could be evicting our bitmaps. Loop a few times |
| 148 | // to mitigate this risk. |
| 149 | const unsigned kRepeatCount = 42; |
| 150 | for (unsigned i = 0; i < kRepeatCount; ++i) { |
| 151 | SkAutoCanvasRestore acr(canvas, true); |
| 152 | |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 153 | sk_sp<SkImage> image(buildImage()); |
fmalita | 3b0d532 | 2015-09-18 08:07:31 -0700 | [diff] [blame] | 154 | |
| 155 | // always use high quality to ensure caching when scaled |
| 156 | SkPaint paint; |
| 157 | paint.setFilterQuality(kHigh_SkFilterQuality); |
| 158 | |
| 159 | // draw the image (with a transform, to tickle different code paths) to ensure |
| 160 | // any associated resources get cached |
| 161 | canvas->concat(transform); |
| 162 | canvas->drawImage(image, 0, 0, &paint); |
| 163 | |
Mike Reed | 5fa3d6d | 2017-03-25 09:51:00 -0400 | [diff] [blame] | 164 | const auto desc = SkBitmapCacheDesc::Make(image.get()); |
fmalita | 3b0d532 | 2015-09-18 08:07:31 -0700 | [diff] [blame] | 165 | |
| 166 | // delete the image |
| 167 | image.reset(nullptr); |
| 168 | |
| 169 | // all resources should have been purged |
| 170 | SkBitmap result; |
Mike Reed | 5fa3d6d | 2017-03-25 09:51:00 -0400 | [diff] [blame] | 171 | REPORTER_ASSERT(reporter, !SkBitmapCache::Find(desc, &result)); |
fmalita | 3b0d532 | 2015-09-18 08:07:31 -0700 | [diff] [blame] | 172 | } |
| 173 | } |
| 174 | |
| 175 | |
| 176 | // Verify that associated bitmap cache entries are purged on SkImage destruction. |
| 177 | DEF_TEST(BitmapCache_discarded_image, reporter) { |
| 178 | // Cache entries associated with SkImages fall into two categories: |
| 179 | // |
| 180 | // 1) generated image bitmaps (managed by the image cacherator) |
| 181 | // 2) scaled/resampled bitmaps (cached when HQ filters are used) |
| 182 | // |
| 183 | // To exercise the first cache type, we use generated/picture-backed SkImages. |
| 184 | // To exercise the latter, we draw scaled bitmap images using HQ filters. |
| 185 | |
| 186 | const SkMatrix xforms[] = { |
| 187 | SkMatrix::MakeScale(1, 1), |
| 188 | SkMatrix::MakeScale(1.7f, 0.5f), |
| 189 | }; |
| 190 | |
| 191 | for (size_t i = 0; i < SK_ARRAY_COUNT(xforms); ++i) { |
| 192 | test_discarded_image(reporter, xforms[i], []() { |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 193 | auto surface(SkSurface::MakeRasterN32Premul(10, 10)); |
fmalita | 3b0d532 | 2015-09-18 08:07:31 -0700 | [diff] [blame] | 194 | surface->getCanvas()->clear(SK_ColorCYAN); |
reed | 9ce9d67 | 2016-03-17 10:51:11 -0700 | [diff] [blame] | 195 | return surface->makeImageSnapshot(); |
fmalita | 3b0d532 | 2015-09-18 08:07:31 -0700 | [diff] [blame] | 196 | }); |
| 197 | |
| 198 | test_discarded_image(reporter, xforms[i], []() { |
| 199 | SkPictureRecorder recorder; |
| 200 | SkCanvas* canvas = recorder.beginRecording(10, 10); |
| 201 | canvas->clear(SK_ColorCYAN); |
reed | ca2622b | 2016-03-18 07:25:55 -0700 | [diff] [blame] | 202 | return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(), |
Brian Osman | 138ea97 | 2016-12-16 11:55:18 -0500 | [diff] [blame] | 203 | SkISize::Make(10, 10), nullptr, nullptr, |
Matt Sarett | e94255d | 2017-01-09 12:38:59 -0500 | [diff] [blame] | 204 | SkImage::BitDepth::kU8, |
Matt Sarett | 77a7a1b | 2017-02-07 13:56:11 -0500 | [diff] [blame] | 205 | SkColorSpace::MakeSRGB()); |
fmalita | 3b0d532 | 2015-09-18 08:07:31 -0700 | [diff] [blame] | 206 | }); |
| 207 | } |
| 208 | } |
Mike Reed | 7a542c5 | 2017-04-11 12:03:44 -0400 | [diff] [blame] | 209 | |
| 210 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 211 | |
| 212 | static void* gTestNamespace; |
| 213 | |
| 214 | struct TestKey : SkResourceCache::Key { |
| 215 | int32_t fData; |
| 216 | |
| 217 | TestKey(int sharedID, int32_t data) : fData(data) { |
| 218 | this->init(&gTestNamespace, sharedID, sizeof(fData)); |
| 219 | } |
| 220 | }; |
| 221 | |
| 222 | struct TestRec : SkResourceCache::Rec { |
| 223 | enum { |
| 224 | kDidInstall = 1 << 0, |
| 225 | }; |
| 226 | |
| 227 | TestKey fKey; |
| 228 | int* fFlags; |
| 229 | bool fCanBePurged; |
| 230 | |
| 231 | TestRec(int sharedID, int32_t data, int* flagPtr) : fKey(sharedID, data), fFlags(flagPtr) { |
| 232 | fCanBePurged = false; |
| 233 | } |
| 234 | |
| 235 | const Key& getKey() const override { return fKey; } |
| 236 | size_t bytesUsed() const override { return 1024; /* just need a value */ } |
| 237 | bool canBePurged() override { return fCanBePurged; } |
| 238 | void postAddInstall(void*) override { |
| 239 | *fFlags |= kDidInstall; |
| 240 | } |
| 241 | const char* getCategory() const override { return "test-category"; } |
| 242 | }; |
| 243 | |
| 244 | static void test_duplicate_add(SkResourceCache* cache, skiatest::Reporter* reporter, |
| 245 | bool purgable) { |
| 246 | int sharedID = 1; |
| 247 | int data = 0; |
| 248 | |
| 249 | int flags0 = 0, flags1 = 0; |
| 250 | |
| 251 | auto rec0 = skstd::make_unique<TestRec>(sharedID, data, &flags0); |
| 252 | auto rec1 = skstd::make_unique<TestRec>(sharedID, data, &flags1); |
| 253 | SkASSERT(rec0->getKey() == rec1->getKey()); |
| 254 | |
| 255 | TestRec* r0 = rec0.get(); // save the bare-pointer since we will release rec0 |
| 256 | r0->fCanBePurged = purgable; |
| 257 | |
| 258 | REPORTER_ASSERT(reporter, !(flags0 & TestRec::kDidInstall)); |
| 259 | REPORTER_ASSERT(reporter, !(flags1 & TestRec::kDidInstall)); |
| 260 | |
| 261 | cache->add(rec0.release(), nullptr); |
| 262 | REPORTER_ASSERT(reporter, flags0 & TestRec::kDidInstall); |
| 263 | REPORTER_ASSERT(reporter, !(flags1 & TestRec::kDidInstall)); |
| 264 | flags0 = 0; // reset the flag |
| 265 | |
| 266 | cache->add(rec1.release(), nullptr); |
| 267 | if (purgable) { |
| 268 | // we purged rec0, and did install rec1 |
| 269 | REPORTER_ASSERT(reporter, !(flags0 & TestRec::kDidInstall)); |
| 270 | REPORTER_ASSERT(reporter, flags1 & TestRec::kDidInstall); |
| 271 | } else { |
| 272 | // we re-used rec0 and did not install rec1 |
| 273 | REPORTER_ASSERT(reporter, flags0 & TestRec::kDidInstall); |
| 274 | REPORTER_ASSERT(reporter, !(flags1 & TestRec::kDidInstall)); |
| 275 | r0->fCanBePurged = true; // so we can cleanup the cache |
| 276 | } |
| 277 | } |
| 278 | |
| 279 | /* |
| 280 | * Test behavior when the same key is added more than once. |
| 281 | */ |
| 282 | DEF_TEST(ResourceCache_purge, reporter) { |
| 283 | for (bool purgable : { false, true }) { |
| 284 | { |
| 285 | SkResourceCache cache(1024 * 1024); |
| 286 | test_duplicate_add(&cache, reporter, purgable); |
| 287 | } |
| 288 | { |
| 289 | SkResourceCache cache(SkDiscardableMemory::Create); |
| 290 | test_duplicate_add(&cache, reporter, purgable); |
| 291 | } |
| 292 | } |
| 293 | } |