SkResourceCacheTest.cpp 9.9 KB

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