submodule/skia/tests/SkResourceCacheTest.cpp

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