reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 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 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "src/core/SkResourceCache.h" |
Hal Canary | c640d0d | 2018-06-13 09:59:02 -0400 | [diff] [blame] | 9 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 10 | #include "include/core/SkTraceMemoryDump.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 11 | #include "include/private/SkMutex.h" |
| 12 | #include "include/private/SkTo.h" |
| 13 | #include "src/core/SkDiscardableMemory.h" |
Michael Ludwig | 8ee6cf3 | 2019-08-02 09:57:04 -0400 | [diff] [blame] | 14 | #include "src/core/SkImageFilter_Base.h" |
Ben Wagner | 21bca28 | 2019-05-15 10:15:52 -0400 | [diff] [blame] | 15 | #include "src/core/SkMessageBus.h" |
Mike Reed | 13711eb | 2020-07-14 17:16:32 -0400 | [diff] [blame] | 16 | #include "src/core/SkMipmap.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 17 | #include "src/core/SkOpts.h" |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 18 | |
fmalita | 171e5b7 | 2014-10-22 11:20:40 -0700 | [diff] [blame] | 19 | #include <stddef.h> |
bungeman | 60e0fee | 2015-08-26 05:15:46 -0700 | [diff] [blame] | 20 | #include <stdlib.h> |
fmalita | 171e5b7 | 2014-10-22 11:20:40 -0700 | [diff] [blame] | 21 | |
Robert Phillips | e7a959d | 2021-03-11 14:44:42 -0500 | [diff] [blame] | 22 | DECLARE_SKMESSAGEBUS_MESSAGE(SkResourceCache::PurgeSharedIDMessage, uint32_t, true) |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 23 | |
Chris Dalton | 9a986cf | 2018-10-18 15:27:59 -0600 | [diff] [blame] | 24 | static inline bool SkShouldPostMessageToBus( |
| 25 | const SkResourceCache::PurgeSharedIDMessage&, uint32_t) { |
| 26 | // SkResourceCache is typically used as a singleton and we don't label Inboxes so all messages |
| 27 | // go to all inboxes. |
| 28 | return true; |
| 29 | } |
| 30 | |
reed@google.com | e4eb122 | 2013-12-09 22:29:30 +0000 | [diff] [blame] | 31 | // This can be defined by the caller's build system |
| 32 | //#define SK_USE_DISCARDABLE_SCALEDIMAGECACHE |
| 33 | |
| 34 | #ifndef SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT |
| 35 | # define SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT 1024 |
| 36 | #endif |
| 37 | |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 38 | #ifndef SK_DEFAULT_IMAGE_CACHE_LIMIT |
reed | ae48877 | 2015-09-11 08:19:23 -0700 | [diff] [blame] | 39 | #define SK_DEFAULT_IMAGE_CACHE_LIMIT (32 * 1024 * 1024) |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 40 | #endif |
| 41 | |
bungeman | 70bb808 | 2016-02-17 10:13:49 -0800 | [diff] [blame] | 42 | void SkResourceCache::Key::init(void* nameSpace, uint64_t sharedID, size_t dataSize) { |
| 43 | SkASSERT(SkAlign4(dataSize) == dataSize); |
fmalita | 171e5b7 | 2014-10-22 11:20:40 -0700 | [diff] [blame] | 44 | |
| 45 | // fCount32 and fHash are not hashed |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 46 | static const int kUnhashedLocal32s = 2; // fCache32 + fHash |
| 47 | static const int kSharedIDLocal32s = 2; // fSharedID_lo + fSharedID_hi |
| 48 | static const int kHashedLocal32s = kSharedIDLocal32s + (sizeof(fNamespace) >> 2); |
| 49 | static const int kLocal32s = kUnhashedLocal32s + kHashedLocal32s; |
fmalita | 171e5b7 | 2014-10-22 11:20:40 -0700 | [diff] [blame] | 50 | |
bungeman | 99fe822 | 2015-08-20 07:57:51 -0700 | [diff] [blame] | 51 | static_assert(sizeof(Key) == (kLocal32s << 2), "unaccounted_key_locals"); |
| 52 | static_assert(sizeof(Key) == offsetof(Key, fNamespace) + sizeof(fNamespace), |
| 53 | "namespace_field_must_be_last"); |
fmalita | 171e5b7 | 2014-10-22 11:20:40 -0700 | [diff] [blame] | 54 | |
bungeman | 70bb808 | 2016-02-17 10:13:49 -0800 | [diff] [blame] | 55 | fCount32 = SkToS32(kLocal32s + (dataSize >> 2)); |
Brian Osman | 50ea3c0 | 2019-02-04 10:01:53 -0500 | [diff] [blame] | 56 | fSharedID_lo = (uint32_t)(sharedID & 0xFFFFFFFF); |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 57 | fSharedID_hi = (uint32_t)(sharedID >> 32); |
fmalita | 171e5b7 | 2014-10-22 11:20:40 -0700 | [diff] [blame] | 58 | fNamespace = nameSpace; |
mtklein | 4e97607 | 2016-08-08 09:06:27 -0700 | [diff] [blame] | 59 | // skip unhashed fields when computing the hash |
| 60 | fHash = SkOpts::hash(this->as32() + kUnhashedLocal32s, |
| 61 | (fCount32 - kUnhashedLocal32s) << 2); |
reed | 4f987e9 | 2014-08-20 13:41:56 -0700 | [diff] [blame] | 62 | } |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 63 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 64 | #include "include/private/SkTHash.h" |
Mike Klein | e4bf164 | 2016-12-13 16:26:32 -0500 | [diff] [blame] | 65 | |
| 66 | namespace { |
| 67 | struct HashTraits { |
| 68 | static uint32_t Hash(const SkResourceCache::Key& key) { return key.hash(); } |
| 69 | static const SkResourceCache::Key& GetKey(const SkResourceCache::Rec* rec) { |
| 70 | return rec->getKey(); |
| 71 | } |
| 72 | }; |
John Stiles | a6841be | 2020-08-06 14:11:56 -0400 | [diff] [blame] | 73 | } // namespace |
reed@google.com | 5d1e558 | 2013-07-25 14:36:15 +0000 | [diff] [blame] | 74 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 75 | class SkResourceCache::Hash : |
Mike Klein | e4bf164 | 2016-12-13 16:26:32 -0500 | [diff] [blame] | 76 | public SkTHashTable<SkResourceCache::Rec*, SkResourceCache::Key, HashTraits> {}; |
commit-bot@chromium.org | 158f646 | 2014-04-02 17:03:09 +0000 | [diff] [blame] | 77 | |
reed@google.com | 5d1e558 | 2013-07-25 14:36:15 +0000 | [diff] [blame] | 78 | |
| 79 | /////////////////////////////////////////////////////////////////////////////// |
| 80 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 81 | void SkResourceCache::init() { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 82 | fHead = nullptr; |
| 83 | fTail = nullptr; |
reed@google.com | 5d1e558 | 2013-07-25 14:36:15 +0000 | [diff] [blame] | 84 | fHash = new Hash; |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 85 | fTotalBytesUsed = 0; |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 86 | fCount = 0; |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 87 | fSingleAllocationByteLimit = 0; |
reed@google.com | e4eb122 | 2013-12-09 22:29:30 +0000 | [diff] [blame] | 88 | |
| 89 | // One of these should be explicit set by the caller after we return. |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 90 | fTotalByteLimit = 0; |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 91 | fDiscardableFactory = nullptr; |
reed@google.com | e4eb122 | 2013-12-09 22:29:30 +0000 | [diff] [blame] | 92 | } |
| 93 | |
Robert Phillips | e7a959d | 2021-03-11 14:44:42 -0500 | [diff] [blame] | 94 | SkResourceCache::SkResourceCache(DiscardableFactory factory) |
| 95 | : fPurgeSharedIDInbox(SK_InvalidUniqueID) { |
reed@google.com | e4eb122 | 2013-12-09 22:29:30 +0000 | [diff] [blame] | 96 | this->init(); |
| 97 | fDiscardableFactory = factory; |
reed@google.com | e4eb122 | 2013-12-09 22:29:30 +0000 | [diff] [blame] | 98 | } |
| 99 | |
Robert Phillips | e7a959d | 2021-03-11 14:44:42 -0500 | [diff] [blame] | 100 | SkResourceCache::SkResourceCache(size_t byteLimit) |
| 101 | : fPurgeSharedIDInbox(SK_InvalidUniqueID) { |
reed@google.com | e4eb122 | 2013-12-09 22:29:30 +0000 | [diff] [blame] | 102 | this->init(); |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 103 | fTotalByteLimit = byteLimit; |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 104 | } |
| 105 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 106 | SkResourceCache::~SkResourceCache() { |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 107 | Rec* rec = fHead; |
| 108 | while (rec) { |
| 109 | Rec* next = rec->fNext; |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 110 | delete rec; |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 111 | rec = next; |
| 112 | } |
reed@google.com | 5d1e558 | 2013-07-25 14:36:15 +0000 | [diff] [blame] | 113 | delete fHash; |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 114 | } |
| 115 | |
commit-bot@chromium.org | 7585479 | 2013-10-29 19:55:00 +0000 | [diff] [blame] | 116 | //////////////////////////////////////////////////////////////////////////////// |
| 117 | |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 118 | bool SkResourceCache::find(const Key& key, FindVisitor visitor, void* context) { |
| 119 | this->checkMessages(); |
| 120 | |
Mike Klein | e4bf164 | 2016-12-13 16:26:32 -0500 | [diff] [blame] | 121 | if (auto found = fHash->find(key)) { |
| 122 | Rec* rec = *found; |
reed | c90e014 | 2014-09-15 11:39:44 -0700 | [diff] [blame] | 123 | if (visitor(*rec, context)) { |
| 124 | this->moveToHead(rec); // for our LRU |
| 125 | return true; |
| 126 | } else { |
| 127 | this->remove(rec); // stale |
| 128 | return false; |
| 129 | } |
reed@google.com | 5d1e558 | 2013-07-25 14:36:15 +0000 | [diff] [blame] | 130 | } |
reed | c90e014 | 2014-09-15 11:39:44 -0700 | [diff] [blame] | 131 | return false; |
commit-bot@chromium.org | 7585479 | 2013-10-29 19:55:00 +0000 | [diff] [blame] | 132 | } |
| 133 | |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 134 | static void make_size_str(size_t size, SkString* str) { |
| 135 | const char suffix[] = { 'b', 'k', 'm', 'g', 't', 0 }; |
| 136 | int i = 0; |
| 137 | while (suffix[i] && (size > 1024)) { |
| 138 | i += 1; |
| 139 | size >>= 10; |
| 140 | } |
| 141 | str->printf("%zu%c", size, suffix[i]); |
| 142 | } |
| 143 | |
| 144 | static bool gDumpCacheTransactions; |
| 145 | |
Mike Reed | 7a542c5 | 2017-04-11 12:03:44 -0400 | [diff] [blame] | 146 | void SkResourceCache::add(Rec* rec, void* payload) { |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 147 | this->checkMessages(); |
mtklein | 1b24933 | 2015-07-07 12:21:21 -0700 | [diff] [blame] | 148 | |
reed | 680fb9e | 2014-08-26 09:08:04 -0700 | [diff] [blame] | 149 | SkASSERT(rec); |
| 150 | // See if we already have this key (racy inserts, etc.) |
Mike Reed | 7a542c5 | 2017-04-11 12:03:44 -0400 | [diff] [blame] | 151 | if (Rec** preexisting = fHash->find(rec->getKey())) { |
| 152 | Rec* prev = *preexisting; |
| 153 | if (prev->canBePurged()) { |
| 154 | // if it can be purged, the install may fail, so we have to remove it |
| 155 | this->remove(prev); |
| 156 | } else { |
| 157 | // if it cannot be purged, we reuse it and delete the new one |
| 158 | prev->postAddInstall(payload); |
| 159 | delete rec; |
| 160 | return; |
| 161 | } |
reed | 680fb9e | 2014-08-26 09:08:04 -0700 | [diff] [blame] | 162 | } |
mtklein | 1b24933 | 2015-07-07 12:21:21 -0700 | [diff] [blame] | 163 | |
reed | 680fb9e | 2014-08-26 09:08:04 -0700 | [diff] [blame] | 164 | this->addToHead(rec); |
Mike Klein | e4bf164 | 2016-12-13 16:26:32 -0500 | [diff] [blame] | 165 | fHash->set(rec); |
Mike Reed | 7a542c5 | 2017-04-11 12:03:44 -0400 | [diff] [blame] | 166 | rec->postAddInstall(payload); |
reed | 595aa05 | 2014-09-15 10:15:18 -0700 | [diff] [blame] | 167 | |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 168 | if (gDumpCacheTransactions) { |
| 169 | SkString bytesStr, totalStr; |
| 170 | make_size_str(rec->bytesUsed(), &bytesStr); |
| 171 | make_size_str(fTotalBytesUsed, &totalStr); |
| 172 | SkDebugf("RC: add %5s %12p key %08x -- total %5s, count %d\n", |
| 173 | bytesStr.c_str(), rec, rec->getHash(), totalStr.c_str(), fCount); |
| 174 | } |
| 175 | |
reed | c90e014 | 2014-09-15 11:39:44 -0700 | [diff] [blame] | 176 | // since the new rec may push us over-budget, we perform a purge check now |
| 177 | this->purgeAsNeeded(); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 178 | } |
| 179 | |
danakj | 790ffe3 | 2014-09-11 10:49:52 -0700 | [diff] [blame] | 180 | void SkResourceCache::remove(Rec* rec) { |
Mike Reed | 7a542c5 | 2017-04-11 12:03:44 -0400 | [diff] [blame] | 181 | SkASSERT(rec->canBePurged()); |
danakj | 790ffe3 | 2014-09-11 10:49:52 -0700 | [diff] [blame] | 182 | size_t used = rec->bytesUsed(); |
| 183 | SkASSERT(used <= fTotalBytesUsed); |
| 184 | |
mtklein | 18300a3 | 2016-03-16 13:53:35 -0700 | [diff] [blame] | 185 | this->release(rec); |
danakj | 790ffe3 | 2014-09-11 10:49:52 -0700 | [diff] [blame] | 186 | fHash->remove(rec->getKey()); |
danakj | 790ffe3 | 2014-09-11 10:49:52 -0700 | [diff] [blame] | 187 | |
danakj | 790ffe3 | 2014-09-11 10:49:52 -0700 | [diff] [blame] | 188 | fTotalBytesUsed -= used; |
| 189 | fCount -= 1; |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 190 | |
Mike Reed | 7a542c5 | 2017-04-11 12:03:44 -0400 | [diff] [blame] | 191 | //SkDebugf("-RC count [%3d] bytes %d\n", fCount, fTotalBytesUsed); |
| 192 | |
reed | 9d93c2e | 2014-10-08 05:17:12 -0700 | [diff] [blame] | 193 | if (gDumpCacheTransactions) { |
| 194 | SkString bytesStr, totalStr; |
| 195 | make_size_str(used, &bytesStr); |
| 196 | make_size_str(fTotalBytesUsed, &totalStr); |
| 197 | SkDebugf("RC: remove %5s %12p key %08x -- total %5s, count %d\n", |
| 198 | bytesStr.c_str(), rec, rec->getHash(), totalStr.c_str(), fCount); |
| 199 | } |
| 200 | |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 201 | delete rec; |
danakj | 790ffe3 | 2014-09-11 10:49:52 -0700 | [diff] [blame] | 202 | } |
| 203 | |
reed | 56b00d9 | 2014-09-11 12:22:34 -0700 | [diff] [blame] | 204 | void SkResourceCache::purgeAsNeeded(bool forcePurge) { |
reed@google.com | e4eb122 | 2013-12-09 22:29:30 +0000 | [diff] [blame] | 205 | size_t byteLimit; |
| 206 | int countLimit; |
skia.committer@gmail.com | 7f1af50 | 2013-07-24 07:01:12 +0000 | [diff] [blame] | 207 | |
reed@google.com | e4eb122 | 2013-12-09 22:29:30 +0000 | [diff] [blame] | 208 | if (fDiscardableFactory) { |
| 209 | countLimit = SK_DISCARDABLEMEMORY_SCALEDIMAGECACHE_COUNT_LIMIT; |
Ben Wagner | b089765 | 2018-06-15 15:37:57 +0000 | [diff] [blame] | 210 | byteLimit = UINT32_MAX; // no limit based on bytes |
reed@google.com | e4eb122 | 2013-12-09 22:29:30 +0000 | [diff] [blame] | 211 | } else { |
| 212 | countLimit = SK_MaxS32; // no limit based on count |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 213 | byteLimit = fTotalByteLimit; |
reed@google.com | e4eb122 | 2013-12-09 22:29:30 +0000 | [diff] [blame] | 214 | } |
| 215 | |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 216 | Rec* rec = fTail; |
| 217 | while (rec) { |
reed | 56b00d9 | 2014-09-11 12:22:34 -0700 | [diff] [blame] | 218 | if (!forcePurge && fTotalBytesUsed < byteLimit && fCount < countLimit) { |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 219 | break; |
| 220 | } |
reed@google.com | e4eb122 | 2013-12-09 22:29:30 +0000 | [diff] [blame] | 221 | |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 222 | Rec* prev = rec->fPrev; |
Mike Reed | 7a542c5 | 2017-04-11 12:03:44 -0400 | [diff] [blame] | 223 | if (rec->canBePurged()) { |
| 224 | this->remove(rec); |
| 225 | } |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 226 | rec = prev; |
| 227 | } |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 228 | } |
| 229 | |
reed | 83787d0 | 2015-02-25 07:17:11 -0800 | [diff] [blame] | 230 | //#define SK_TRACK_PURGE_SHAREDID_HITRATE |
| 231 | |
| 232 | #ifdef SK_TRACK_PURGE_SHAREDID_HITRATE |
| 233 | static int gPurgeCallCounter; |
| 234 | static int gPurgeHitCounter; |
| 235 | #endif |
| 236 | |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 237 | void SkResourceCache::purgeSharedID(uint64_t sharedID) { |
| 238 | if (0 == sharedID) { |
| 239 | return; |
| 240 | } |
| 241 | |
reed | 83787d0 | 2015-02-25 07:17:11 -0800 | [diff] [blame] | 242 | #ifdef SK_TRACK_PURGE_SHAREDID_HITRATE |
| 243 | gPurgeCallCounter += 1; |
| 244 | bool found = false; |
| 245 | #endif |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 246 | // go backwards, just like purgeAsNeeded, just to make the code similar. |
| 247 | // could iterate either direction and still be correct. |
| 248 | Rec* rec = fTail; |
| 249 | while (rec) { |
| 250 | Rec* prev = rec->fPrev; |
| 251 | if (rec->getKey().getSharedID() == sharedID) { |
Mike Reed | 7a542c5 | 2017-04-11 12:03:44 -0400 | [diff] [blame] | 252 | // even though the "src" is now dead, caches could still be in-flight, so |
| 253 | // we have to check if it can be removed. |
| 254 | if (rec->canBePurged()) { |
| 255 | this->remove(rec); |
| 256 | } |
reed | 83787d0 | 2015-02-25 07:17:11 -0800 | [diff] [blame] | 257 | #ifdef SK_TRACK_PURGE_SHAREDID_HITRATE |
| 258 | found = true; |
| 259 | #endif |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 260 | } |
| 261 | rec = prev; |
| 262 | } |
reed | 83787d0 | 2015-02-25 07:17:11 -0800 | [diff] [blame] | 263 | |
| 264 | #ifdef SK_TRACK_PURGE_SHAREDID_HITRATE |
| 265 | if (found) { |
| 266 | gPurgeHitCounter += 1; |
| 267 | } |
| 268 | |
| 269 | SkDebugf("PurgeShared calls=%d hits=%d rate=%g\n", gPurgeCallCounter, gPurgeHitCounter, |
| 270 | gPurgeHitCounter * 100.0 / gPurgeCallCounter); |
| 271 | #endif |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 272 | } |
| 273 | |
reed | 216b643 | 2015-08-19 12:25:40 -0700 | [diff] [blame] | 274 | void SkResourceCache::visitAll(Visitor visitor, void* context) { |
| 275 | // go backwards, just like purgeAsNeeded, just to make the code similar. |
| 276 | // could iterate either direction and still be correct. |
| 277 | Rec* rec = fTail; |
| 278 | while (rec) { |
| 279 | visitor(*rec, context); |
| 280 | rec = rec->fPrev; |
| 281 | } |
| 282 | } |
| 283 | |
| 284 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 285 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 286 | size_t SkResourceCache::setTotalByteLimit(size_t newLimit) { |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 287 | size_t prevLimit = fTotalByteLimit; |
| 288 | fTotalByteLimit = newLimit; |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 289 | if (newLimit < prevLimit) { |
| 290 | this->purgeAsNeeded(); |
| 291 | } |
| 292 | return prevLimit; |
| 293 | } |
| 294 | |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 295 | SkCachedData* SkResourceCache::newCachedData(size_t bytes) { |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 296 | this->checkMessages(); |
mtklein | 1b24933 | 2015-07-07 12:21:21 -0700 | [diff] [blame] | 297 | |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 298 | if (fDiscardableFactory) { |
| 299 | SkDiscardableMemory* dm = fDiscardableFactory(bytes); |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 300 | return dm ? new SkCachedData(bytes, dm) : nullptr; |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 301 | } else { |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 302 | return new SkCachedData(sk_malloc_throw(bytes), bytes); |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 303 | } |
| 304 | } |
| 305 | |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 306 | /////////////////////////////////////////////////////////////////////////////// |
| 307 | |
mtklein | 18300a3 | 2016-03-16 13:53:35 -0700 | [diff] [blame] | 308 | void SkResourceCache::release(Rec* rec) { |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 309 | Rec* prev = rec->fPrev; |
| 310 | Rec* next = rec->fNext; |
skia.committer@gmail.com | 7f1af50 | 2013-07-24 07:01:12 +0000 | [diff] [blame] | 311 | |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 312 | if (!prev) { |
| 313 | SkASSERT(fHead == rec); |
| 314 | fHead = next; |
| 315 | } else { |
| 316 | prev->fNext = next; |
| 317 | } |
skia.committer@gmail.com | 7f1af50 | 2013-07-24 07:01:12 +0000 | [diff] [blame] | 318 | |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 319 | if (!next) { |
| 320 | fTail = prev; |
| 321 | } else { |
| 322 | next->fPrev = prev; |
| 323 | } |
skia.committer@gmail.com | 7f1af50 | 2013-07-24 07:01:12 +0000 | [diff] [blame] | 324 | |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 325 | rec->fNext = rec->fPrev = nullptr; |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 326 | } |
| 327 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 328 | void SkResourceCache::moveToHead(Rec* rec) { |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 329 | if (fHead == rec) { |
| 330 | return; |
| 331 | } |
| 332 | |
| 333 | SkASSERT(fHead); |
| 334 | SkASSERT(fTail); |
| 335 | |
| 336 | this->validate(); |
| 337 | |
mtklein | 18300a3 | 2016-03-16 13:53:35 -0700 | [diff] [blame] | 338 | this->release(rec); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 339 | |
| 340 | fHead->fPrev = rec; |
| 341 | rec->fNext = fHead; |
| 342 | fHead = rec; |
skia.committer@gmail.com | 7f1af50 | 2013-07-24 07:01:12 +0000 | [diff] [blame] | 343 | |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 344 | this->validate(); |
| 345 | } |
| 346 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 347 | void SkResourceCache::addToHead(Rec* rec) { |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 348 | this->validate(); |
| 349 | |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 350 | rec->fPrev = nullptr; |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 351 | rec->fNext = fHead; |
| 352 | if (fHead) { |
| 353 | fHead->fPrev = rec; |
| 354 | } |
| 355 | fHead = rec; |
| 356 | if (!fTail) { |
| 357 | fTail = rec; |
| 358 | } |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 359 | fTotalBytesUsed += rec->bytesUsed(); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 360 | fCount += 1; |
| 361 | |
| 362 | this->validate(); |
| 363 | } |
| 364 | |
reed@google.com | fa7fd80 | 2013-12-12 21:37:25 +0000 | [diff] [blame] | 365 | /////////////////////////////////////////////////////////////////////////////// |
| 366 | |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 367 | #ifdef SK_DEBUG |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 368 | void SkResourceCache::validate() const { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 369 | if (nullptr == fHead) { |
| 370 | SkASSERT(nullptr == fTail); |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 371 | SkASSERT(0 == fTotalBytesUsed); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 372 | return; |
| 373 | } |
| 374 | |
| 375 | if (fHead == fTail) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 376 | SkASSERT(nullptr == fHead->fPrev); |
| 377 | SkASSERT(nullptr == fHead->fNext); |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 378 | SkASSERT(fHead->bytesUsed() == fTotalBytesUsed); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 379 | return; |
| 380 | } |
| 381 | |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 382 | SkASSERT(nullptr == fHead->fPrev); |
bsalomon | 49f085d | 2014-09-05 13:34:00 -0700 | [diff] [blame] | 383 | SkASSERT(fHead->fNext); |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 384 | SkASSERT(nullptr == fTail->fNext); |
bsalomon | 49f085d | 2014-09-05 13:34:00 -0700 | [diff] [blame] | 385 | SkASSERT(fTail->fPrev); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 386 | |
| 387 | size_t used = 0; |
| 388 | int count = 0; |
| 389 | const Rec* rec = fHead; |
| 390 | while (rec) { |
| 391 | count += 1; |
| 392 | used += rec->bytesUsed(); |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 393 | SkASSERT(used <= fTotalBytesUsed); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 394 | rec = rec->fNext; |
| 395 | } |
| 396 | SkASSERT(fCount == count); |
| 397 | |
| 398 | rec = fTail; |
| 399 | while (rec) { |
| 400 | SkASSERT(count > 0); |
| 401 | count -= 1; |
| 402 | SkASSERT(used >= rec->bytesUsed()); |
| 403 | used -= rec->bytesUsed(); |
| 404 | rec = rec->fPrev; |
| 405 | } |
skia.committer@gmail.com | 7f1af50 | 2013-07-24 07:01:12 +0000 | [diff] [blame] | 406 | |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 407 | SkASSERT(0 == count); |
| 408 | SkASSERT(0 == used); |
| 409 | } |
| 410 | #endif |
| 411 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 412 | void SkResourceCache::dump() const { |
reed@google.com | fa7fd80 | 2013-12-12 21:37:25 +0000 | [diff] [blame] | 413 | this->validate(); |
| 414 | |
Tyler Denniston | 283dba5 | 2021-06-25 13:32:45 +0000 | [diff] [blame^] | 415 | SkDebugf("SkResourceCache: count=%d bytes=%d %s\n", |
reed | c90e014 | 2014-09-15 11:39:44 -0700 | [diff] [blame] | 416 | fCount, fTotalBytesUsed, fDiscardableFactory ? "discardable" : "malloc"); |
reed@google.com | fa7fd80 | 2013-12-12 21:37:25 +0000 | [diff] [blame] | 417 | } |
| 418 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 419 | size_t SkResourceCache::setSingleAllocationByteLimit(size_t newLimit) { |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 420 | size_t oldLimit = fSingleAllocationByteLimit; |
| 421 | fSingleAllocationByteLimit = newLimit; |
| 422 | return oldLimit; |
| 423 | } |
| 424 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 425 | size_t SkResourceCache::getSingleAllocationByteLimit() const { |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 426 | return fSingleAllocationByteLimit; |
| 427 | } |
| 428 | |
reed | 1d9e80f | 2015-01-26 11:24:37 -0800 | [diff] [blame] | 429 | size_t SkResourceCache::getEffectiveSingleAllocationByteLimit() const { |
| 430 | // fSingleAllocationByteLimit == 0 means the caller is asking for our default |
| 431 | size_t limit = fSingleAllocationByteLimit; |
| 432 | |
| 433 | // if we're not discardable (i.e. we are fixed-budget) then cap the single-limit |
| 434 | // to our budget. |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 435 | if (nullptr == fDiscardableFactory) { |
reed | 1d9e80f | 2015-01-26 11:24:37 -0800 | [diff] [blame] | 436 | if (0 == limit) { |
| 437 | limit = fTotalByteLimit; |
| 438 | } else { |
Brian Osman | 788b916 | 2020-02-07 10:36:46 -0500 | [diff] [blame] | 439 | limit = std::min(limit, fTotalByteLimit); |
reed | 1d9e80f | 2015-01-26 11:24:37 -0800 | [diff] [blame] | 440 | } |
| 441 | } |
| 442 | return limit; |
| 443 | } |
| 444 | |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 445 | void SkResourceCache::checkMessages() { |
| 446 | SkTArray<PurgeSharedIDMessage> msgs; |
| 447 | fPurgeSharedIDInbox.poll(&msgs); |
| 448 | for (int i = 0; i < msgs.count(); ++i) { |
| 449 | this->purgeSharedID(msgs[i].fSharedID); |
| 450 | } |
| 451 | } |
| 452 | |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 453 | /////////////////////////////////////////////////////////////////////////////// |
| 454 | |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 455 | static SkResourceCache* gResourceCache = nullptr; |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 456 | static SkMutex& resource_cache_mutex() { |
| 457 | static SkMutex& mutex = *(new SkMutex); |
| 458 | return mutex; |
| 459 | } |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 460 | |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 461 | /** Must hold resource_cache_mutex() when calling. */ |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 462 | static SkResourceCache* get_cache() { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 463 | // resource_cache_mutex() is always held when this is called, so we don't need to be fancy in here. |
| 464 | resource_cache_mutex().assertHeld(); |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 465 | if (nullptr == gResourceCache) { |
commit-bot@chromium.org | 60c8d24 | 2014-05-27 16:28:43 +0000 | [diff] [blame] | 466 | #ifdef SK_USE_DISCARDABLE_SCALEDIMAGECACHE |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 467 | gResourceCache = new SkResourceCache(SkDiscardableMemory::Create); |
commit-bot@chromium.org | 60c8d24 | 2014-05-27 16:28:43 +0000 | [diff] [blame] | 468 | #else |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 469 | gResourceCache = new SkResourceCache(SK_DEFAULT_IMAGE_CACHE_LIMIT); |
commit-bot@chromium.org | 60c8d24 | 2014-05-27 16:28:43 +0000 | [diff] [blame] | 470 | #endif |
commit-bot@chromium.org | 60c8d24 | 2014-05-27 16:28:43 +0000 | [diff] [blame] | 471 | } |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 472 | return gResourceCache; |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 473 | } |
| 474 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 475 | size_t SkResourceCache::GetTotalBytesUsed() { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 476 | SkAutoMutexExclusive am(resource_cache_mutex()); |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 477 | return get_cache()->getTotalBytesUsed(); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 478 | } |
| 479 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 480 | size_t SkResourceCache::GetTotalByteLimit() { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 481 | SkAutoMutexExclusive am(resource_cache_mutex()); |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 482 | return get_cache()->getTotalByteLimit(); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 483 | } |
| 484 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 485 | size_t SkResourceCache::SetTotalByteLimit(size_t newLimit) { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 486 | SkAutoMutexExclusive am(resource_cache_mutex()); |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 487 | return get_cache()->setTotalByteLimit(newLimit); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 488 | } |
| 489 | |
reed | 30ad530 | 2014-09-16 10:39:55 -0700 | [diff] [blame] | 490 | SkResourceCache::DiscardableFactory SkResourceCache::GetDiscardableFactory() { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 491 | SkAutoMutexExclusive am(resource_cache_mutex()); |
reed | 30ad530 | 2014-09-16 10:39:55 -0700 | [diff] [blame] | 492 | return get_cache()->discardableFactory(); |
| 493 | } |
| 494 | |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 495 | SkCachedData* SkResourceCache::NewCachedData(size_t bytes) { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 496 | SkAutoMutexExclusive am(resource_cache_mutex()); |
qiankun.miao | d9aac34 | 2014-10-23 07:58:17 -0700 | [diff] [blame] | 497 | return get_cache()->newCachedData(bytes); |
| 498 | } |
| 499 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 500 | void SkResourceCache::Dump() { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 501 | SkAutoMutexExclusive am(resource_cache_mutex()); |
reed@google.com | fa7fd80 | 2013-12-12 21:37:25 +0000 | [diff] [blame] | 502 | get_cache()->dump(); |
| 503 | } |
| 504 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 505 | size_t SkResourceCache::SetSingleAllocationByteLimit(size_t size) { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 506 | SkAutoMutexExclusive am(resource_cache_mutex()); |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 507 | return get_cache()->setSingleAllocationByteLimit(size); |
| 508 | } |
| 509 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 510 | size_t SkResourceCache::GetSingleAllocationByteLimit() { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 511 | SkAutoMutexExclusive am(resource_cache_mutex()); |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 512 | return get_cache()->getSingleAllocationByteLimit(); |
| 513 | } |
| 514 | |
reed | 1d9e80f | 2015-01-26 11:24:37 -0800 | [diff] [blame] | 515 | size_t SkResourceCache::GetEffectiveSingleAllocationByteLimit() { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 516 | SkAutoMutexExclusive am(resource_cache_mutex()); |
reed | 1d9e80f | 2015-01-26 11:24:37 -0800 | [diff] [blame] | 517 | return get_cache()->getEffectiveSingleAllocationByteLimit(); |
| 518 | } |
| 519 | |
reed | 56b00d9 | 2014-09-11 12:22:34 -0700 | [diff] [blame] | 520 | void SkResourceCache::PurgeAll() { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 521 | SkAutoMutexExclusive am(resource_cache_mutex()); |
reed | 56b00d9 | 2014-09-11 12:22:34 -0700 | [diff] [blame] | 522 | return get_cache()->purgeAll(); |
| 523 | } |
| 524 | |
Mike Reed | b9bd12d | 2021-03-04 08:13:56 -0500 | [diff] [blame] | 525 | void SkResourceCache::CheckMessages() { |
| 526 | SkAutoMutexExclusive am(resource_cache_mutex()); |
| 527 | return get_cache()->checkMessages(); |
| 528 | } |
| 529 | |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 530 | bool SkResourceCache::Find(const Key& key, FindVisitor visitor, void* context) { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 531 | SkAutoMutexExclusive am(resource_cache_mutex()); |
reed | c90e014 | 2014-09-15 11:39:44 -0700 | [diff] [blame] | 532 | return get_cache()->find(key, visitor, context); |
reed | 680fb9e | 2014-08-26 09:08:04 -0700 | [diff] [blame] | 533 | } |
| 534 | |
Mike Reed | 7a542c5 | 2017-04-11 12:03:44 -0400 | [diff] [blame] | 535 | void SkResourceCache::Add(Rec* rec, void* payload) { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 536 | SkAutoMutexExclusive am(resource_cache_mutex()); |
Mike Reed | 7a542c5 | 2017-04-11 12:03:44 -0400 | [diff] [blame] | 537 | get_cache()->add(rec, payload); |
reed | 680fb9e | 2014-08-26 09:08:04 -0700 | [diff] [blame] | 538 | } |
| 539 | |
reed | 216b643 | 2015-08-19 12:25:40 -0700 | [diff] [blame] | 540 | void SkResourceCache::VisitAll(Visitor visitor, void* context) { |
Herb Derby | 9c71e7b | 2019-06-17 14:40:42 -0400 | [diff] [blame] | 541 | SkAutoMutexExclusive am(resource_cache_mutex()); |
reed | 216b643 | 2015-08-19 12:25:40 -0700 | [diff] [blame] | 542 | get_cache()->visitAll(visitor, context); |
| 543 | } |
| 544 | |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 545 | void SkResourceCache::PostPurgeSharedID(uint64_t sharedID) { |
| 546 | if (sharedID) { |
Robert Phillips | e7a959d | 2021-03-11 14:44:42 -0500 | [diff] [blame] | 547 | SkMessageBus<PurgeSharedIDMessage, uint32_t>::Post(PurgeSharedIDMessage(sharedID)); |
reed | 7eeba25 | 2015-02-24 13:54:23 -0800 | [diff] [blame] | 548 | } |
| 549 | } |
| 550 | |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 551 | /////////////////////////////////////////////////////////////////////////////// |
| 552 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 553 | #include "include/core/SkGraphics.h" |
| 554 | #include "include/core/SkImageFilter.h" |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 555 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 556 | size_t SkGraphics::GetResourceCacheTotalBytesUsed() { |
| 557 | return SkResourceCache::GetTotalBytesUsed(); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 558 | } |
| 559 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 560 | size_t SkGraphics::GetResourceCacheTotalByteLimit() { |
| 561 | return SkResourceCache::GetTotalByteLimit(); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 562 | } |
| 563 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 564 | size_t SkGraphics::SetResourceCacheTotalByteLimit(size_t newLimit) { |
| 565 | return SkResourceCache::SetTotalByteLimit(newLimit); |
reed@google.com | 602a1d7 | 2013-07-23 19:13:54 +0000 | [diff] [blame] | 566 | } |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 567 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 568 | size_t SkGraphics::GetResourceCacheSingleAllocationByteLimit() { |
| 569 | return SkResourceCache::GetSingleAllocationByteLimit(); |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 570 | } |
| 571 | |
reed | 011f39a | 2014-08-28 13:35:23 -0700 | [diff] [blame] | 572 | size_t SkGraphics::SetResourceCacheSingleAllocationByteLimit(size_t newLimit) { |
| 573 | return SkResourceCache::SetSingleAllocationByteLimit(newLimit); |
halcanary | 805ef15 | 2014-07-17 06:58:01 -0700 | [diff] [blame] | 574 | } |
| 575 | |
reed | 56b00d9 | 2014-09-11 12:22:34 -0700 | [diff] [blame] | 576 | void SkGraphics::PurgeResourceCache() { |
Michael Ludwig | 8ee6cf3 | 2019-08-02 09:57:04 -0400 | [diff] [blame] | 577 | SkImageFilter_Base::PurgeCache(); |
reed | 56b00d9 | 2014-09-11 12:22:34 -0700 | [diff] [blame] | 578 | return SkResourceCache::PurgeAll(); |
| 579 | } |
| 580 | |
reed | 216b643 | 2015-08-19 12:25:40 -0700 | [diff] [blame] | 581 | ///////////// |
| 582 | |
| 583 | static void dump_visitor(const SkResourceCache::Rec& rec, void*) { |
Tyler Denniston | 283dba5 | 2021-06-25 13:32:45 +0000 | [diff] [blame^] | 584 | SkDebugf("RC: %12s bytes %9lu discardable %p\n", |
reed | 216b643 | 2015-08-19 12:25:40 -0700 | [diff] [blame] | 585 | rec.getCategory(), rec.bytesUsed(), rec.diagnostic_only_getDiscardable()); |
| 586 | } |
| 587 | |
| 588 | void SkResourceCache::TestDumpMemoryStatistics() { |
| 589 | VisitAll(dump_visitor, nullptr); |
| 590 | } |
ssid | 33c594c | 2015-08-27 09:23:54 -0700 | [diff] [blame] | 591 | |
| 592 | static void sk_trace_dump_visitor(const SkResourceCache::Rec& rec, void* context) { |
| 593 | SkTraceMemoryDump* dump = static_cast<SkTraceMemoryDump*>(context); |
ssid | f0c9865 | 2015-09-30 04:31:23 -0700 | [diff] [blame] | 594 | SkString dumpName = SkStringPrintf("skia/sk_resource_cache/%s_%p", rec.getCategory(), &rec); |
ssid | 33c594c | 2015-08-27 09:23:54 -0700 | [diff] [blame] | 595 | SkDiscardableMemory* discardable = rec.diagnostic_only_getDiscardable(); |
| 596 | if (discardable) { |
ssid | f0c9865 | 2015-09-30 04:31:23 -0700 | [diff] [blame] | 597 | dump->setDiscardableMemoryBacking(dumpName.c_str(), *discardable); |
ssid | 60df542 | 2015-10-01 12:41:35 -0700 | [diff] [blame] | 598 | |
| 599 | // The discardable memory size will be calculated by dumper, but we also dump what we think |
| 600 | // the size of object in memory is irrespective of whether object is live or dead. |
| 601 | dump->dumpNumericValue(dumpName.c_str(), "discardable_size", "bytes", rec.bytesUsed()); |
ssid | 33c594c | 2015-08-27 09:23:54 -0700 | [diff] [blame] | 602 | } else { |
ssid | f0c9865 | 2015-09-30 04:31:23 -0700 | [diff] [blame] | 603 | dump->dumpNumericValue(dumpName.c_str(), "size", "bytes", rec.bytesUsed()); |
| 604 | dump->setMemoryBacking(dumpName.c_str(), "malloc", nullptr); |
ssid | 33c594c | 2015-08-27 09:23:54 -0700 | [diff] [blame] | 605 | } |
| 606 | } |
| 607 | |
| 608 | void SkResourceCache::DumpMemoryStatistics(SkTraceMemoryDump* dump) { |
ssid | f0c9865 | 2015-09-30 04:31:23 -0700 | [diff] [blame] | 609 | // Since resource could be backed by malloc or discardable, the cache always dumps detailed |
| 610 | // stats to be accurate. |
ssid | 33c594c | 2015-08-27 09:23:54 -0700 | [diff] [blame] | 611 | VisitAll(sk_trace_dump_visitor, dump); |
| 612 | } |