blob: 16accbbb030326cfc207bd9326940335e15ceb88 [file] [log] [blame]
bsalomonc8dc1f72014-08-21 13:02:13 -07001/*
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
bsalomon0ea80f42015-02-11 10:49:59 -08008#ifndef GrResourceCache_DEFINED
9#define GrResourceCache_DEFINED
bsalomonc8dc1f72014-08-21 13:02:13 -070010
bsalomon744998e2014-08-28 09:54:34 -070011#include "GrGpuResource.h"
bsalomon9f2d1572015-02-17 11:47:40 -080012#include "GrGpuResourceCacheAccess.h"
bsalomon3582d3e2015-02-13 14:20:05 -080013#include "GrGpuResourcePriv.h"
bsalomon744998e2014-08-28 09:54:34 -070014#include "GrResourceKey.h"
bsalomon23e619c2015-02-06 11:54:28 -080015#include "SkMessageBus.h"
bsalomon8b79d232014-11-10 10:19:06 -080016#include "SkRefCnt.h"
bsalomon23e619c2015-02-06 11:54:28 -080017#include "SkTArray.h"
bsalomon9f2d1572015-02-17 11:47:40 -080018#include "SkTDPQueue.h"
bsalomonc8dc1f72014-08-21 13:02:13 -070019#include "SkTInternalLList.h"
bsalomon744998e2014-08-28 09:54:34 -070020#include "SkTMultiMap.h"
bsalomonc8dc1f72014-08-21 13:02:13 -070021
robertphillips63926682015-08-20 09:39:02 -070022class GrCaps;
Robert Phillips1afd4cd2018-01-08 13:40:32 -050023class GrProxyProvider;
mtkleinb9eb4ac2015-02-02 18:26:03 -080024class SkString;
ericrk0a5fa482015-09-15 14:16:10 -070025class SkTraceMemoryDump;
mtkleinb9eb4ac2015-02-02 18:26:03 -080026
Brian Osman13dddce2017-05-09 13:19:50 -040027struct GrGpuResourceFreedMessage {
28 GrGpuResource* fResource;
29 uint32_t fOwningUniqueID;
30};
31
Chris Dalton9a986cf2018-10-18 15:27:59 -060032static inline bool SkShouldPostMessageToBus(
33 const GrGpuResourceFreedMessage& msg, uint32_t msgBusUniqueID) {
34 // The inbox's ID is the unique ID of the owning GrContext.
35 return msgBusUniqueID == msg.fOwningUniqueID;
36}
37
bsalomonc8dc1f72014-08-21 13:02:13 -070038/**
bsalomon71cb0c22014-11-14 12:10:14 -080039 * Manages the lifetime of all GrGpuResource instances.
40 *
41 * Resources may have optionally have two types of keys:
42 * 1) A scratch key. This is for resources whose allocations are cached but not their contents.
43 * Multiple resources can share the same scratch key. This is so a caller can have two
bsalomon84c8e622014-11-17 09:33:27 -080044 * resource instances with the same properties (e.g. multipass rendering that ping-pongs
bsalomon8718aaf2015-02-19 07:24:21 -080045 * between two temporary surfaces). The scratch key is set at resource creation time and
bsalomon71cb0c22014-11-14 12:10:14 -080046 * should never change. Resources need not have a scratch key.
bsalomon8718aaf2015-02-19 07:24:21 -080047 * 2) A unique key. This key's meaning is specific to the domain that created the key. Only one
bsalomonf99e9612015-02-19 08:24:16 -080048 * resource may have a given unique key. The unique key can be set, cleared, or changed
49 * anytime after resource creation.
50 *
bsalomon8718aaf2015-02-19 07:24:21 -080051 * A unique key always takes precedence over a scratch key when a resource has both types of keys.
bsalomon71cb0c22014-11-14 12:10:14 -080052 * If a resource has neither key type then it will be deleted as soon as the last reference to it
bsalomon8718aaf2015-02-19 07:24:21 -080053 * is dropped.
bsalomonc8dc1f72014-08-21 13:02:13 -070054 */
bsalomon0ea80f42015-02-11 10:49:59 -080055class GrResourceCache {
bsalomonc8dc1f72014-08-21 13:02:13 -070056public:
Robert Phillips1afd4cd2018-01-08 13:40:32 -050057 GrResourceCache(const GrCaps*, uint32_t contextUniqueID);
bsalomon0ea80f42015-02-11 10:49:59 -080058 ~GrResourceCache();
bsalomonc8dc1f72014-08-21 13:02:13 -070059
bsalomon3f324322015-04-08 11:01:54 -070060 // Default maximum number of budgeted resources in the cache.
61 static const int kDefaultMaxCount = 2 * (1 << 12);
62 // Default maximum number of bytes of gpu memory of budgeted resources in the cache.
63 static const size_t kDefaultMaxSize = 96 * (1 << 20);
bsalomon3f324322015-04-08 11:01:54 -070064
bsalomon71cb0c22014-11-14 12:10:14 -080065 /** Used to access functionality needed by GrGpuResource for lifetime management. */
66 class ResourceAccess;
67 ResourceAccess resourceAccess();
bsalomonc8dc1f72014-08-21 13:02:13 -070068
Brian Salomon238069b2018-07-11 15:58:57 -040069 /** Unique ID of the owning GrContext. */
70 uint32_t contextUniqueID() const { return fContextUniqueID; }
71
Brian Salomon43b882b2018-09-07 16:29:14 -040072 /** Sets the cache limits in terms of number of resources and max gpu memory byte size. */
73 void setLimits(int count, size_t bytes);
bsalomonc8dc1f72014-08-21 13:02:13 -070074
bsalomon71cb0c22014-11-14 12:10:14 -080075 /**
bsalomondace19e2014-11-17 07:34:06 -080076 * Returns the number of resources.
bsalomon71cb0c22014-11-14 12:10:14 -080077 */
bsalomonf320e042015-02-17 15:09:34 -080078 int getResourceCount() const {
79 return fPurgeableQueue.count() + fNonpurgeableResources.count();
80 }
bsalomon8b79d232014-11-10 10:19:06 -080081
bsalomon71cb0c22014-11-14 12:10:14 -080082 /**
bsalomondace19e2014-11-17 07:34:06 -080083 * Returns the number of resources that count against the budget.
84 */
85 int getBudgetedResourceCount() const { return fBudgetedCount; }
86
87 /**
88 * Returns the number of bytes consumed by resources.
bsalomon71cb0c22014-11-14 12:10:14 -080089 */
90 size_t getResourceBytes() const { return fBytes; }
91
92 /**
Derek Sollenbergeree479142017-05-24 11:41:33 -040093 * Returns the number of bytes held by unlocked reosources which are available for purging.
94 */
95 size_t getPurgeableBytes() const { return fPurgeableBytes; }
96
97 /**
bsalomondace19e2014-11-17 07:34:06 -080098 * Returns the number of bytes consumed by budgeted resources.
99 */
100 size_t getBudgetedResourceBytes() const { return fBudgetedBytes; }
101
102 /**
bsalomon71cb0c22014-11-14 12:10:14 -0800103 * Returns the cached resources count budget.
104 */
105 int getMaxResourceCount() const { return fMaxCount; }
106
107 /**
108 * Returns the number of bytes consumed by cached resources.
109 */
110 size_t getMaxResourceBytes() const { return fMaxBytes; }
111
112 /**
113 * Abandons the backend API resources owned by all GrGpuResource objects and removes them from
114 * the cache.
115 */
bsalomonc8dc1f72014-08-21 13:02:13 -0700116 void abandonAll();
117
bsalomon71cb0c22014-11-14 12:10:14 -0800118 /**
119 * Releases the backend API resources owned by all GrGpuResource objects and removes them from
120 * the cache.
121 */
bsalomonc8dc1f72014-08-21 13:02:13 -0700122 void releaseAll();
123
Chris Daltond004e0b2018-09-27 09:28:03 -0600124 enum class ScratchFlags {
125 kNone = 0,
bsalomon000f8292014-10-15 19:04:14 -0700126 /** Preferentially returns scratch resources with no pending IO. */
Chris Daltond004e0b2018-09-27 09:28:03 -0600127 kPreferNoPendingIO = 0x1,
bsalomon000f8292014-10-15 19:04:14 -0700128 /** Will not return any resources that match but have pending IO. */
Chris Daltond004e0b2018-09-27 09:28:03 -0600129 kRequireNoPendingIO = 0x2,
bsalomon000f8292014-10-15 19:04:14 -0700130 };
bsalomon71cb0c22014-11-14 12:10:14 -0800131
132 /**
133 * Find a resource that matches a scratch key.
134 */
Chris Daltond004e0b2018-09-27 09:28:03 -0600135 GrGpuResource* findAndRefScratchResource(const GrScratchKey& scratchKey, size_t resourceSize,
136 ScratchFlags);
halcanary9d524f22016-03-29 09:03:52 -0700137
bsalomon8b79d232014-11-10 10:19:06 -0800138#ifdef SK_DEBUG
139 // This is not particularly fast and only used for validation, so debug only.
bsalomon7775c852014-12-30 12:50:52 -0800140 int countScratchEntriesForKey(const GrScratchKey& scratchKey) const {
bsalomon8b79d232014-11-10 10:19:06 -0800141 return fScratchMap.countForKey(scratchKey);
142 }
143#endif
144
bsalomon71cb0c22014-11-14 12:10:14 -0800145 /**
bsalomon8718aaf2015-02-19 07:24:21 -0800146 * Find a resource that matches a unique key.
bsalomon71cb0c22014-11-14 12:10:14 -0800147 */
robertphillipsee843b22016-10-04 05:30:20 -0700148 GrGpuResource* findAndRefUniqueResource(const GrUniqueKey& key) {
149 GrGpuResource* resource = fUniqueHash.find(key);
150 if (resource) {
151 this->refAndMakeResourceMRU(resource);
152 }
153 return resource;
154 }
bsalomon8b79d232014-11-10 10:19:06 -0800155
Greg Danielcd871402017-09-26 12:49:26 -0400156 /**
bsalomon8718aaf2015-02-19 07:24:21 -0800157 * Query whether a unique key exists in the cache.
bsalomon71cb0c22014-11-14 12:10:14 -0800158 */
bsalomon8718aaf2015-02-19 07:24:21 -0800159 bool hasUniqueKey(const GrUniqueKey& key) const {
160 return SkToBool(fUniqueHash.find(key));
bsalomon8b79d232014-11-10 10:19:06 -0800161 }
bsalomonbcf0a522014-10-08 08:40:09 -0700162
bsalomon8718aaf2015-02-19 07:24:21 -0800163 /** Purges resources to become under budget and processes resources with invalidated unique
bsalomon23e619c2015-02-06 11:54:28 -0800164 keys. */
robertphillipsee843b22016-10-04 05:30:20 -0700165 void purgeAsNeeded();
bsalomon23e619c2015-02-06 11:54:28 -0800166
bsalomon71cb0c22014-11-14 12:10:14 -0800167 /** Purges all resources that don't have external owners. */
Robert Phillips6eba0632018-03-28 12:25:42 -0400168 void purgeAllUnlocked() { this->purgeUnlockedResources(false); }
169
170 // Purge unlocked resources. If 'scratchResourcesOnly' is true the purgeable resources
171 // containing persistent data are spared. If it is false then all purgeable resources will
172 // be deleted.
173 void purgeUnlockedResources(bool scratchResourcesOnly);
bsalomon71cb0c22014-11-14 12:10:14 -0800174
Brian Salomon5e150852017-03-22 14:53:13 -0400175 /** Purge all resources not used since the passed in time. */
176 void purgeResourcesNotUsedSince(GrStdSteadyClock::time_point);
177
Robert Phillipseafd48a2017-11-16 07:52:08 -0500178 bool overBudget() const { return fBudgetedBytes > fMaxBytes || fBudgetedCount > fMaxCount; }
179
Derek Sollenberger5480a182017-05-25 16:43:59 -0400180 /**
181 * Purge unlocked resources from the cache until the the provided byte count has been reached
182 * or we have purged all unlocked resources. The default policy is to purge in LRU order, but
183 * can be overridden to prefer purging scratch resources (in LRU order) prior to purging other
184 * resource types.
185 *
186 * @param maxBytesToPurge the desired number of bytes to be purged.
187 * @param preferScratchResources If true scratch resources will be purged prior to other
188 * resource types.
189 */
190 void purgeUnlockedResources(size_t bytesToPurge, bool preferScratchResources);
191
bsalomonb77a9072016-09-07 10:02:04 -0700192 /** Returns true if the cache would like a flush to occur in order to make more resources
193 purgeable. */
Brian Salomon57d2beab2018-09-10 09:35:41 -0400194 bool requestsFlush() const { return this->overBudget() && !fPurgeableQueue.count(); }
bsalomon71cb0c22014-11-14 12:10:14 -0800195
Brian Osman13dddce2017-05-09 13:19:50 -0400196 /** Maintain a ref to this resource until we receive a GrGpuResourceFreedMessage. */
197 void insertCrossContextGpuResource(GrGpuResource* resource);
198
robertphillips60029a52015-11-09 13:51:06 -0800199#if GR_CACHE_STATS
200 struct Stats {
201 int fTotal;
202 int fNumPurgeable;
203 int fNumNonPurgeable;
204
205 int fScratch;
kkinnunen2e6055b2016-04-22 01:48:29 -0700206 int fWrapped;
robertphillips60029a52015-11-09 13:51:06 -0800207 size_t fUnbudgetedSize;
208
209 Stats() { this->reset(); }
210
211 void reset() {
212 fTotal = 0;
213 fNumPurgeable = 0;
214 fNumNonPurgeable = 0;
215 fScratch = 0;
kkinnunen2e6055b2016-04-22 01:48:29 -0700216 fWrapped = 0;
robertphillips60029a52015-11-09 13:51:06 -0800217 fUnbudgetedSize = 0;
218 }
219
220 void update(GrGpuResource* resource) {
221 if (resource->cacheAccess().isScratch()) {
222 ++fScratch;
223 }
kkinnunen2e6055b2016-04-22 01:48:29 -0700224 if (resource->resourcePriv().refsWrappedObjects()) {
225 ++fWrapped;
robertphillips60029a52015-11-09 13:51:06 -0800226 }
bsalomon5ec26ae2016-02-25 08:33:02 -0800227 if (SkBudgeted::kNo == resource->resourcePriv().isBudgeted()) {
robertphillips60029a52015-11-09 13:51:06 -0800228 fUnbudgetedSize += resource->gpuMemorySize();
229 }
230 }
231 };
232
233 void getStats(Stats*) const;
234
mtkleinb9eb4ac2015-02-02 18:26:03 -0800235 void dumpStats(SkString*) const;
joshualittdc5685a2015-12-02 14:08:25 -0800236
237 void dumpStatsKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* value) const;
bsalomon71cb0c22014-11-14 12:10:14 -0800238#endif
239
Brian Salomon1090da62017-01-06 12:04:19 -0500240#ifdef SK_DEBUG
241 int countUniqueKeysWithTag(const char* tag) const;
242#endif
243
bsalomonddf30e62015-02-19 11:38:44 -0800244 // This function is for unit testing and is only defined in test tools.
245 void changeTimestamp(uint32_t newTimestamp);
246
ericrk0a5fa482015-09-15 14:16:10 -0700247 // Enumerates all cached resources and dumps their details to traceMemoryDump.
248 void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;
249
Robert Phillips1afd4cd2018-01-08 13:40:32 -0500250 void setProxyProvider(GrProxyProvider* proxyProvider) { fProxyProvider = proxyProvider; }
Robert Phillipsae7d3f32017-09-21 08:26:08 -0400251
bsalomonc8dc1f72014-08-21 13:02:13 -0700252private:
bsalomon71cb0c22014-11-14 12:10:14 -0800253 ///////////////////////////////////////////////////////////////////////////
254 /// @name Methods accessible via ResourceAccess
255 ////
256 void insertResource(GrGpuResource*);
257 void removeResource(GrGpuResource*);
bsalomon3f324322015-04-08 11:01:54 -0700258 void notifyCntReachedZero(GrGpuResource*, uint32_t flags);
bsalomonf99e9612015-02-19 08:24:16 -0800259 void changeUniqueKey(GrGpuResource*, const GrUniqueKey&);
260 void removeUniqueKey(GrGpuResource*);
bsalomon10e23ca2014-11-25 05:52:06 -0800261 void willRemoveScratchKey(const GrGpuResource*);
bsalomon84c8e622014-11-17 09:33:27 -0800262 void didChangeBudgetStatus(GrGpuResource*);
bsalomon9f2d1572015-02-17 11:47:40 -0800263 void refAndMakeResourceMRU(GrGpuResource*);
bsalomon71cb0c22014-11-14 12:10:14 -0800264 /// @}
265
bsalomon8718aaf2015-02-19 07:24:21 -0800266 void processInvalidUniqueKeys(const SkTArray<GrUniqueKeyInvalidatedMessage>&);
Brian Osman13dddce2017-05-09 13:19:50 -0400267 void processFreedGpuResources();
bsalomonf320e042015-02-17 15:09:34 -0800268 void addToNonpurgeableArray(GrGpuResource*);
269 void removeFromNonpurgeableArray(GrGpuResource*);
bsalomon71cb0c22014-11-14 12:10:14 -0800270
robertphillips6e83ac72015-08-13 05:19:14 -0700271 bool wouldFit(size_t bytes) {
halcanary9d524f22016-03-29 09:03:52 -0700272 return fBudgetedBytes+bytes <= fMaxBytes && fBudgetedCount+1 <= fMaxCount;
robertphillips6e83ac72015-08-13 05:19:14 -0700273 }
274
bsalomonddf30e62015-02-19 11:38:44 -0800275 uint32_t getNextTimestamp();
276
bsalomon16961262014-08-26 14:01:07 -0700277#ifdef SK_DEBUG
bsalomonf320e042015-02-17 15:09:34 -0800278 bool isInCache(const GrGpuResource* r) const;
bsalomon71cb0c22014-11-14 12:10:14 -0800279 void validate() const;
280#else
281 void validate() const {}
bsalomon16961262014-08-26 14:01:07 -0700282#endif
283
bsalomon71cb0c22014-11-14 12:10:14 -0800284 class AutoValidate;
285
bsalomonbcf0a522014-10-08 08:40:09 -0700286 class AvailableForScratchUse;
bsalomon744998e2014-08-28 09:54:34 -0700287
robertphillipsee843b22016-10-04 05:30:20 -0700288 struct ScratchMapTraits {
bsalomon7775c852014-12-30 12:50:52 -0800289 static const GrScratchKey& GetKey(const GrGpuResource& r) {
bsalomon3582d3e2015-02-13 14:20:05 -0800290 return r.resourcePriv().getScratchKey();
bsalomon744998e2014-08-28 09:54:34 -0700291 }
robertphillipsee843b22016-10-04 05:30:20 -0700292
293 static uint32_t Hash(const GrScratchKey& key) { return key.hash(); }
Robert Phillipsf8e25022017-11-08 15:24:31 -0500294 static void OnFree(GrGpuResource*) { }
bsalomon744998e2014-08-28 09:54:34 -0700295 };
bsalomon7775c852014-12-30 12:50:52 -0800296 typedef SkTMultiMap<GrGpuResource, GrScratchKey, ScratchMapTraits> ScratchMap;
bsalomon744998e2014-08-28 09:54:34 -0700297
robertphillipsee843b22016-10-04 05:30:20 -0700298 struct UniqueHashTraits {
bsalomon8718aaf2015-02-19 07:24:21 -0800299 static const GrUniqueKey& GetKey(const GrGpuResource& r) { return r.getUniqueKey(); }
robertphillipsee843b22016-10-04 05:30:20 -0700300
301 static uint32_t Hash(const GrUniqueKey& key) { return key.hash(); }
bsalomon8b79d232014-11-10 10:19:06 -0800302 };
bsalomon8718aaf2015-02-19 07:24:21 -0800303 typedef SkTDynamicHash<GrGpuResource, GrUniqueKey, UniqueHashTraits> UniqueHash;
bsalomon8b79d232014-11-10 10:19:06 -0800304
bsalomon9f2d1572015-02-17 11:47:40 -0800305 static bool CompareTimestamp(GrGpuResource* const& a, GrGpuResource* const& b) {
306 return a->cacheAccess().timestamp() < b->cacheAccess().timestamp();
307 }
bsalomon23e619c2015-02-06 11:54:28 -0800308
bsalomon9f2d1572015-02-17 11:47:40 -0800309 static int* AccessResourceIndex(GrGpuResource* const& res) {
310 return res->cacheAccess().accessCacheIndex();
311 }
312
bsalomon8718aaf2015-02-19 07:24:21 -0800313 typedef SkMessageBus<GrUniqueKeyInvalidatedMessage>::Inbox InvalidUniqueKeyInbox;
Brian Osman13dddce2017-05-09 13:19:50 -0400314 typedef SkMessageBus<GrGpuResourceFreedMessage>::Inbox FreedGpuResourceInbox;
bsalomon9f2d1572015-02-17 11:47:40 -0800315 typedef SkTDPQueue<GrGpuResource*, CompareTimestamp, AccessResourceIndex> PurgeableQueue;
bsalomonf320e042015-02-17 15:09:34 -0800316 typedef SkTDArray<GrGpuResource*> ResourceArray;
bsalomon9f2d1572015-02-17 11:47:40 -0800317
Robert Phillips1afd4cd2018-01-08 13:40:32 -0500318 GrProxyProvider* fProxyProvider;
bsalomon9f2d1572015-02-17 11:47:40 -0800319 // Whenever a resource is added to the cache or the result of a cache lookup, fTimestamp is
320 // assigned as the resource's timestamp and then incremented. fPurgeableQueue orders the
321 // purgeable resources by this value, and thus is used to purge resources in LRU order.
322 uint32_t fTimestamp;
323 PurgeableQueue fPurgeableQueue;
bsalomonf320e042015-02-17 15:09:34 -0800324 ResourceArray fNonpurgeableResources;
bsalomon9f2d1572015-02-17 11:47:40 -0800325
bsalomon744998e2014-08-28 09:54:34 -0700326 // This map holds all resources that can be used as scratch resources.
bsalomon8b79d232014-11-10 10:19:06 -0800327 ScratchMap fScratchMap;
bsalomon8718aaf2015-02-19 07:24:21 -0800328 // This holds all resources that have unique keys.
329 UniqueHash fUniqueHash;
bsalomon71cb0c22014-11-14 12:10:14 -0800330
331 // our budget, used in purgeAsNeeded()
332 int fMaxCount;
333 size_t fMaxBytes;
334
335#if GR_CACHE_STATS
336 int fHighWaterCount;
337 size_t fHighWaterBytes;
bsalomondace19e2014-11-17 07:34:06 -0800338 int fBudgetedHighWaterCount;
339 size_t fBudgetedHighWaterBytes;
bsalomon71cb0c22014-11-14 12:10:14 -0800340#endif
341
bsalomondace19e2014-11-17 07:34:06 -0800342 // our current stats for all resources
bsalomonf320e042015-02-17 15:09:34 -0800343 SkDEBUGCODE(int fCount;)
bsalomon71cb0c22014-11-14 12:10:14 -0800344 size_t fBytes;
345
bsalomondace19e2014-11-17 07:34:06 -0800346 // our current stats for resources that count against the budget
347 int fBudgetedCount;
348 size_t fBudgetedBytes;
Derek Sollenbergeree479142017-05-24 11:41:33 -0400349 size_t fPurgeableBytes;
bsalomondace19e2014-11-17 07:34:06 -0800350
bsalomon8718aaf2015-02-19 07:24:21 -0800351 InvalidUniqueKeyInbox fInvalidUniqueKeyInbox;
Brian Osman13dddce2017-05-09 13:19:50 -0400352 FreedGpuResourceInbox fFreedGpuResourceInbox;
353
Greg Danielc27eb722018-08-10 09:48:08 -0400354 SkTDArray<GrGpuResource*> fResourcesWaitingForFreeMsg;
355
Brian Osman13dddce2017-05-09 13:19:50 -0400356 uint32_t fContextUniqueID;
bsalomon3f324322015-04-08 11:01:54 -0700357
358 // This resource is allowed to be in the nonpurgeable array for the sake of validate() because
359 // we're in the midst of converting it to purgeable status.
360 SkDEBUGCODE(GrGpuResource* fNewlyPurgeableResourceForValidation;)
robertphillips63926682015-08-20 09:39:02 -0700361
362 bool fPreferVRAMUseOverFlushes;
bsalomonc8dc1f72014-08-21 13:02:13 -0700363};
364
Chris Daltond004e0b2018-09-27 09:28:03 -0600365GR_MAKE_BITFIELD_CLASS_OPS(GrResourceCache::ScratchFlags);
366
bsalomon0ea80f42015-02-11 10:49:59 -0800367class GrResourceCache::ResourceAccess {
bsalomon71cb0c22014-11-14 12:10:14 -0800368private:
bsalomon0ea80f42015-02-11 10:49:59 -0800369 ResourceAccess(GrResourceCache* cache) : fCache(cache) { }
bsalomon71cb0c22014-11-14 12:10:14 -0800370 ResourceAccess(const ResourceAccess& that) : fCache(that.fCache) { }
371 ResourceAccess& operator=(const ResourceAccess&); // unimpl
372
373 /**
374 * Insert a resource into the cache.
375 */
376 void insertResource(GrGpuResource* resource) { fCache->insertResource(resource); }
377
378 /**
379 * Removes a resource from the cache.
380 */
381 void removeResource(GrGpuResource* resource) { fCache->removeResource(resource); }
382
383 /**
bsalomon3f324322015-04-08 11:01:54 -0700384 * Notifications that should be sent to the cache when the ref/io cnt status of resources
385 * changes.
bsalomon71cb0c22014-11-14 12:10:14 -0800386 */
bsalomon3f324322015-04-08 11:01:54 -0700387 enum RefNotificationFlags {
388 /** All types of refs on the resource have reached zero. */
389 kAllCntsReachedZero_RefNotificationFlag = 0x1,
390 /** The normal (not pending IO type) ref cnt has reached zero. */
391 kRefCntReachedZero_RefNotificationFlag = 0x2,
392 };
393 /**
394 * Called by GrGpuResources when they detect that their ref/io cnts have reached zero. When the
395 * normal ref cnt reaches zero the flags that are set should be:
396 * a) kRefCntReachedZero if a pending IO cnt is still non-zero.
397 * b) (kRefCntReachedZero | kAllCntsReachedZero) when all pending IO cnts are also zero.
398 * kAllCntsReachedZero is set by itself if a pending IO cnt is decremented to zero and all the
399 * the other cnts are already zero.
400 */
401 void notifyCntReachedZero(GrGpuResource* resource, uint32_t flags) {
402 fCache->notifyCntReachedZero(resource, flags);
403 }
bsalomon71cb0c22014-11-14 12:10:14 -0800404
405 /**
bsalomonf99e9612015-02-19 08:24:16 -0800406 * Called by GrGpuResources to change their unique keys.
bsalomon71cb0c22014-11-14 12:10:14 -0800407 */
bsalomonf99e9612015-02-19 08:24:16 -0800408 void changeUniqueKey(GrGpuResource* resource, const GrUniqueKey& newKey) {
409 fCache->changeUniqueKey(resource, newKey);
410 }
bsalomon71cb0c22014-11-14 12:10:14 -0800411
bsalomon10e23ca2014-11-25 05:52:06 -0800412 /**
bsalomonf99e9612015-02-19 08:24:16 -0800413 * Called by a GrGpuResource to remove its unique key.
bsalomon23e619c2015-02-06 11:54:28 -0800414 */
bsalomonf99e9612015-02-19 08:24:16 -0800415 void removeUniqueKey(GrGpuResource* resource) { fCache->removeUniqueKey(resource); }
bsalomon23e619c2015-02-06 11:54:28 -0800416
417 /**
418 * Called by a GrGpuResource when it removes its scratch key.
bsalomon10e23ca2014-11-25 05:52:06 -0800419 */
420 void willRemoveScratchKey(const GrGpuResource* resource) {
421 fCache->willRemoveScratchKey(resource);
422 }
bsalomon84c8e622014-11-17 09:33:27 -0800423
424 /**
425 * Called by GrGpuResources when they change from budgeted to unbudgeted or vice versa.
426 */
427 void didChangeBudgetStatus(GrGpuResource* resource) { fCache->didChangeBudgetStatus(resource); }
428
bsalomon71cb0c22014-11-14 12:10:14 -0800429 // No taking addresses of this type.
430 const ResourceAccess* operator&() const;
431 ResourceAccess* operator&();
432
bsalomon0ea80f42015-02-11 10:49:59 -0800433 GrResourceCache* fCache;
bsalomon71cb0c22014-11-14 12:10:14 -0800434
435 friend class GrGpuResource; // To access all the proxy inline methods.
bsalomon0ea80f42015-02-11 10:49:59 -0800436 friend class GrResourceCache; // To create this type.
bsalomon71cb0c22014-11-14 12:10:14 -0800437};
438
bsalomon0ea80f42015-02-11 10:49:59 -0800439inline GrResourceCache::ResourceAccess GrResourceCache::resourceAccess() {
bsalomon71cb0c22014-11-14 12:10:14 -0800440 return ResourceAccess(this);
441}
442
bsalomonc8dc1f72014-08-21 13:02:13 -0700443#endif