• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "SkDiscardableMemory.h"
9 #include "SkResourceCache.h"
10 #include "Test.h"
11 
12 namespace {
13 static void* gGlobalAddress;
14 struct TestingKey : public SkResourceCache::Key {
15     intptr_t    fValue;
16 
TestingKey__anon79b429970111::TestingKey17     TestingKey(intptr_t value, uint64_t sharedID = 0) : fValue(value) {
18         this->init(&gGlobalAddress, sharedID, sizeof(fValue));
19     }
20 };
21 struct TestingRec : public SkResourceCache::Rec {
TestingRec__anon79b429970111::TestingRec22     TestingRec(const TestingKey& key, uint32_t value) : fKey(key), fValue(value) {}
23 
24     TestingKey  fKey;
25     intptr_t    fValue;
26 
getKey__anon79b429970111::TestingRec27     const Key& getKey() const override { return fKey; }
bytesUsed__anon79b429970111::TestingRec28     size_t bytesUsed() const override { return sizeof(fKey) + sizeof(fValue); }
getCategory__anon79b429970111::TestingRec29     const char* getCategory() const override { return "test_cache"; }
diagnostic_only_getDiscardable__anon79b429970111::TestingRec30     SkDiscardableMemory* diagnostic_only_getDiscardable() const override { return nullptr; }
31 
Visitor__anon79b429970111::TestingRec32     static bool Visitor(const SkResourceCache::Rec& baseRec, void* context) {
33         const TestingRec& rec = static_cast<const TestingRec&>(baseRec);
34         intptr_t* result = (intptr_t*)context;
35 
36         *result = rec.fValue;
37         return true;
38     }
39 };
40 }
41 
42 static const int COUNT = 10;
43 static const int DIM = 256;
44 
test_cache(skiatest::Reporter * reporter,SkResourceCache & cache,bool testPurge)45 static void test_cache(skiatest::Reporter* reporter, SkResourceCache& cache, bool testPurge) {
46     for (int i = 0; i < COUNT; ++i) {
47         TestingKey key(i);
48         intptr_t value = -1;
49 
50         REPORTER_ASSERT(reporter, !cache.find(key, TestingRec::Visitor, &value));
51         REPORTER_ASSERT(reporter, -1 == value);
52 
53         cache.add(new TestingRec(key, i));
54 
55         REPORTER_ASSERT(reporter, cache.find(key, TestingRec::Visitor, &value));
56         REPORTER_ASSERT(reporter, i == value);
57     }
58 
59     if (testPurge) {
60         // stress test, should trigger purges
61         for (int i = 0; i < COUNT * 100; ++i) {
62             TestingKey key(i);
63             cache.add(new TestingRec(key, i));
64         }
65     }
66 
67     // test the originals after all that purging
68     for (int i = 0; i < COUNT; ++i) {
69         intptr_t value;
70         (void)cache.find(TestingKey(i), TestingRec::Visitor, &value);
71     }
72 
73     cache.setTotalByteLimit(0);
74 }
75 
test_cache_purge_shared_id(skiatest::Reporter * reporter,SkResourceCache & cache)76 static void test_cache_purge_shared_id(skiatest::Reporter* reporter, SkResourceCache& cache) {
77     for (int i = 0; i < COUNT; ++i) {
78         TestingKey key(i, i & 1);   // every other key will have a 1 for its sharedID
79         cache.add(new TestingRec(key, i));
80     }
81 
82     // Ensure that everyone is present
83     for (int i = 0; i < COUNT; ++i) {
84         TestingKey key(i, i & 1);   // every other key will have a 1 for its sharedID
85         intptr_t value = -1;
86 
87         REPORTER_ASSERT(reporter, cache.find(key, TestingRec::Visitor, &value));
88         REPORTER_ASSERT(reporter, value == i);
89     }
90 
91     // Now purge the ones that had a non-zero sharedID (the odd-indexed ones)
92     cache.purgeSharedID(1);
93 
94     // Ensure that only the even ones are still present
95     for (int i = 0; i < COUNT; ++i) {
96         TestingKey key(i, i & 1);   // every other key will have a 1 for its sharedID
97         intptr_t value = -1;
98 
99         if (i & 1) {
100             REPORTER_ASSERT(reporter, !cache.find(key, TestingRec::Visitor, &value));
101         } else {
102             REPORTER_ASSERT(reporter, cache.find(key, TestingRec::Visitor, &value));
103             REPORTER_ASSERT(reporter, value == i);
104         }
105     }
106 }
107 
108 #include "SkDiscardableMemoryPool.h"
109 
110 static SkDiscardableMemoryPool* gPool;
pool_factory(size_t bytes)111 static SkDiscardableMemory* pool_factory(size_t bytes) {
112     SkASSERT(gPool);
113     return gPool->create(bytes);
114 }
115 
DEF_TEST(ImageCache,reporter)116 DEF_TEST(ImageCache, reporter) {
117     static const size_t defLimit = DIM * DIM * 4 * COUNT + 1024;    // 1K slop
118 
119     {
120         SkResourceCache cache(defLimit);
121         test_cache(reporter, cache, true);
122     }
123     {
124         SkAutoTUnref<SkDiscardableMemoryPool> pool(
125                 SkDiscardableMemoryPool::Create(defLimit, nullptr));
126         gPool = pool.get();
127         SkResourceCache cache(pool_factory);
128         test_cache(reporter, cache, true);
129     }
130     {
131         SkResourceCache cache(SkDiscardableMemory::Create);
132         test_cache(reporter, cache, false);
133     }
134     {
135         SkResourceCache cache(defLimit);
136         test_cache_purge_shared_id(reporter, cache);
137     }
138 }
139 
DEF_TEST(ImageCache_doubleAdd,r)140 DEF_TEST(ImageCache_doubleAdd, r) {
141     // Adding the same key twice should be safe.
142     SkResourceCache cache(4096);
143 
144     TestingKey key(1);
145 
146     cache.add(new TestingRec(key, 2));
147     cache.add(new TestingRec(key, 3));
148 
149     // Lookup can return either value.
150     intptr_t value = -1;
151     REPORTER_ASSERT(r, cache.find(key, TestingRec::Visitor, &value));
152     REPORTER_ASSERT(r, 2 == value || 3 == value);
153 }
154