src/gpu/GrResourceCache.h - platform/external/skia - Gitiles

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #ifndef GrResourceCache_DEFINED
 #define GrResourceCache_DEFINED

 #include "GrGpuResource.h"
 #include "GrGpuResourceCacheAccess.h"
 #include "GrGpuResourcePriv.h"
 #include "GrResourceKey.h"
 #include "SkMessageBus.h"
 #include "SkRefCnt.h"
 #include "SkTArray.h"
 #include "SkTDPQueue.h"
 #include "SkTInternalLList.h"
 #include "SkTMultiMap.h"

 class GrCaps;
 class SkString;
 class SkTraceMemoryDump;

 /**
  * Manages the lifetime of all GrGpuResource instances.
  *
  * Resources may have optionally have two types of keys:
  *      1) A scratch key. This is for resources whose allocations are cached but not their contents.
  *         Multiple resources can share the same scratch key. This is so a caller can have two
  *         resource instances with the same properties (e.g. multipass rendering that ping-pongs
  *         between two temporary surfaces). The scratch key is set at resource creation time and
  *         should never change. Resources need not have a scratch key.
  *      2) A unique key. This key's meaning is specific to the domain that created the key. Only one
  *         resource may have a given unique key. The unique key can be set, cleared, or changed
  *         anytime after resource creation.
  *
  * A unique key always takes precedence over a scratch key when a resource has both types of keys.
  * If a resource has neither key type then it will be deleted as soon as the last reference to it
  * is dropped.
  *
  * When proactive purging is enabled, on every flush, the timestamp of that flush is stored in a
  * n-sized ring buffer. When purging occurs each purgeable resource's timestamp is compared to the
  * timestamp of the n-th prior flush. If the resource's last use timestamp is older than the old
  * flush then the resource is proactively purged even when the cache is under budget. By default
  * this feature is disabled, though it can be enabled by calling GrResourceCache::setLimits.
  */
 class GrResourceCache {
 public:
     GrResourceCache(const GrCaps* caps);
     ~GrResourceCache();

     // Default maximum number of budgeted resources in the cache.
     static const int    kDefaultMaxCount            = 2 * (1 << 12);
     // Default maximum number of bytes of gpu memory of budgeted resources in the cache.
     static const size_t kDefaultMaxSize             = 96 * (1 << 20);
     // Default number of flushes a budgeted resources can go unused in the cache before it is
     // purged. Large values disable the feature (as the ring buffer of flush timestamps would be
     // large). This is currently the default until we decide to enable this feature
     // of the cache by default.
     static const int    kDefaultMaxUnusedFlushes    = 64;

     /** Used to access functionality needed by GrGpuResource for lifetime management. */
     class ResourceAccess;
     ResourceAccess resourceAccess();

     /**
      * Sets the cache limits in terms of number of resources, max gpu memory byte size, and number
      * of GrContext flushes that a resource can be unused before it is evicted. The latter value is
      * a suggestion and there is no promise that a resource will be purged immediately after it
      * hasn't been used in maxUnusedFlushes flushes.
      */
     void setLimits(int count, size_t bytes, int maxUnusedFlushes = kDefaultMaxUnusedFlushes);

     /**
      * Returns the number of resources.
      */
     int getResourceCount() const {
         return fPurgeableQueue.count() + fNonpurgeableResources.count();
     }

     /**
      * Returns the number of resources that count against the budget.
      */
     int getBudgetedResourceCount() const { return fBudgetedCount; }

     /**
      * Returns the number of bytes consumed by resources.
      */
     size_t getResourceBytes() const { return fBytes; }

     /**
      * Returns the number of bytes consumed by budgeted resources.
      */
     size_t getBudgetedResourceBytes() const { return fBudgetedBytes; }

     /**
      * Returns the cached resources count budget.
      */
     int getMaxResourceCount() const { return fMaxCount; }

     /**
      * Returns the number of bytes consumed by cached resources.
      */
     size_t getMaxResourceBytes() const { return fMaxBytes; }

     /**
      * Abandons the backend API resources owned by all GrGpuResource objects and removes them from
      * the cache.
      */
     void abandonAll();

     /**
      * Releases the backend API resources owned by all GrGpuResource objects and removes them from
      * the cache.
      */
     void releaseAll();

     enum {
         /** Preferentially returns scratch resources with no pending IO. */
         kPreferNoPendingIO_ScratchFlag = 0x1,
         /** Will not return any resources that match but have pending IO. */
         kRequireNoPendingIO_ScratchFlag = 0x2,
     };

     /**
      * Find a resource that matches a scratch key.
      */
     GrGpuResource* findAndRefScratchResource(const GrScratchKey& scratchKey,
                                              size_t resourceSize,
                                              uint32_t flags);

 #ifdef SK_DEBUG
     // This is not particularly fast and only used for validation, so debug only.
     int countScratchEntriesForKey(const GrScratchKey& scratchKey) const {
         return fScratchMap.countForKey(scratchKey);
     }
 #endif

     /**
      * Find a resource that matches a unique key.
      */
     GrGpuResource* findAndRefUniqueResource(const GrUniqueKey& key) {
         GrGpuResource* resource = fUniqueHash.find(key);
         if (resource) {
             this->refAndMakeResourceMRU(resource);
         }
         return resource;
     }

     /**
      * Query whether a unique key exists in the cache.
      */
     bool hasUniqueKey(const GrUniqueKey& key) const {
         return SkToBool(fUniqueHash.find(key));
     }

     /** Purges resources to become under budget and processes resources with invalidated unique
         keys. */
     void purgeAsNeeded();

     /** Purges all resources that don't have external owners. */
     void purgeAllUnlocked();

     /**
      * The callback function used by the cache when it is still over budget after a purge. The
      * passed in 'data' is the same 'data' handed to setOverbudgetCallback.
      */
     typedef void (*PFOverBudgetCB)(void* data);

     /**
      * Set the callback the cache should use when it is still over budget after a purge. The 'data'
      * provided here will be passed back to the callback. Note that the cache will attempt to purge
      * any resources newly freed by the callback.
      */
     void setOverBudgetCallback(PFOverBudgetCB overBudgetCB, void* data) {
         fOverBudgetCB = overBudgetCB;
         fOverBudgetData = data;
     }

     void notifyFlushOccurred();

 #if GR_CACHE_STATS
     struct Stats {
         int fTotal;
         int fNumPurgeable;
         int fNumNonPurgeable;

         int fScratch;
         int fExternal;
         int fBorrowed;
         int fAdopted;
         size_t fUnbudgetedSize;

         Stats() { this->reset(); }

         void reset() {
             fTotal = 0;
             fNumPurgeable = 0;
             fNumNonPurgeable = 0;
             fScratch = 0;
             fExternal = 0;
             fBorrowed = 0;
             fAdopted = 0;
             fUnbudgetedSize = 0;
         }

         void update(GrGpuResource* resource) {
             if (resource->cacheAccess().isScratch()) {
                 ++fScratch;
             }
             if (resource->resourcePriv().isExternal()) {
                 ++fExternal;
             }
             if (resource->cacheAccess().isBorrowed()) {
                 ++fBorrowed;
             }
             if (resource->cacheAccess().isAdopted()) {
                 ++fAdopted;
             }
             if (SkBudgeted::kNo  == resource->resourcePriv().isBudgeted()) {
                 fUnbudgetedSize += resource->gpuMemorySize();
             }
         }
     };

     void getStats(Stats*) const;

     void dumpStats(SkString*) const;

     void dumpStatsKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* value) const;
 #endif

     // This function is for unit testing and is only defined in test tools.
     void changeTimestamp(uint32_t newTimestamp);

     // Enumerates all cached resources and dumps their details to traceMemoryDump.
     void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;

 private:
     ///////////////////////////////////////////////////////////////////////////
     /// @name Methods accessible via ResourceAccess
     ////
     void insertResource(GrGpuResource*);
     void removeResource(GrGpuResource*);
     void notifyCntReachedZero(GrGpuResource*, uint32_t flags);
     void didChangeGpuMemorySize(const GrGpuResource*, size_t oldSize);
     void changeUniqueKey(GrGpuResource*, const GrUniqueKey&);
     void removeUniqueKey(GrGpuResource*);
     void willRemoveScratchKey(const GrGpuResource*);
     void didChangeBudgetStatus(GrGpuResource*);
     void refAndMakeResourceMRU(GrGpuResource*);
     /// @}

     void resetFlushTimestamps();
     void processInvalidUniqueKeys(const SkTArray<GrUniqueKeyInvalidatedMessage>&);
     void addToNonpurgeableArray(GrGpuResource*);
     void removeFromNonpurgeableArray(GrGpuResource*);
     bool overBudget() const { return fBudgetedBytes > fMaxBytes || fBudgetedCount > fMaxCount; }

     bool wouldFit(size_t bytes) {
         return fBudgetedBytes+bytes <= fMaxBytes && fBudgetedCount+1 <= fMaxCount;
     }

     uint32_t getNextTimestamp();

 #ifdef SK_DEBUG
     bool isInCache(const GrGpuResource* r) const;
     void validate() const;
 #else
     void validate() const {}
 #endif

     class AutoValidate;

     class AvailableForScratchUse;

     struct ScratchMapTraits {
         static const GrScratchKey& GetKey(const GrGpuResource& r) {
             return r.resourcePriv().getScratchKey();
         }

         static uint32_t Hash(const GrScratchKey& key) { return key.hash(); }
     };
     typedef SkTMultiMap<GrGpuResource, GrScratchKey, ScratchMapTraits> ScratchMap;

     struct UniqueHashTraits {
         static const GrUniqueKey& GetKey(const GrGpuResource& r) { return r.getUniqueKey(); }

         static uint32_t Hash(const GrUniqueKey& key) { return key.hash(); }
     };
     typedef SkTDynamicHash<GrGpuResource, GrUniqueKey, UniqueHashTraits> UniqueHash;

     static bool CompareTimestamp(GrGpuResource* const& a, GrGpuResource* const& b) {
         return a->cacheAccess().timestamp() < b->cacheAccess().timestamp();
     }

     static int* AccessResourceIndex(GrGpuResource* const& res) {
         return res->cacheAccess().accessCacheIndex();
     }

     typedef SkMessageBus<GrUniqueKeyInvalidatedMessage>::Inbox InvalidUniqueKeyInbox;
     typedef SkTDPQueue<GrGpuResource*, CompareTimestamp, AccessResourceIndex> PurgeableQueue;
     typedef SkTDArray<GrGpuResource*> ResourceArray;

     // Whenever a resource is added to the cache or the result of a cache lookup, fTimestamp is
     // assigned as the resource's timestamp and then incremented. fPurgeableQueue orders the
     // purgeable resources by this value, and thus is used to purge resources in LRU order.
     uint32_t                            fTimestamp;
     PurgeableQueue                      fPurgeableQueue;
     ResourceArray                       fNonpurgeableResources;

     // This map holds all resources that can be used as scratch resources.
     ScratchMap                          fScratchMap;
     // This holds all resources that have unique keys.
     UniqueHash                          fUniqueHash;

     // our budget, used in purgeAsNeeded()
     int                                 fMaxCount;
     size_t                              fMaxBytes;
     int                                 fMaxUnusedFlushes;

 #if GR_CACHE_STATS
     int                                 fHighWaterCount;
     size_t                              fHighWaterBytes;
     int                                 fBudgetedHighWaterCount;
     size_t                              fBudgetedHighWaterBytes;
 #endif

     // our current stats for all resources
     SkDEBUGCODE(int                     fCount;)
     size_t                              fBytes;

     // our current stats for resources that count against the budget
     int                                 fBudgetedCount;
     size_t                              fBudgetedBytes;

     PFOverBudgetCB                      fOverBudgetCB;
     void*                               fOverBudgetData;

     // We keep track of the "timestamps" of the last n flushes. If a resource hasn't been used in
     // that time then we well preemptively purge it to reduce memory usage.
     uint32_t*                           fFlushTimestamps;
     int                                 fLastFlushTimestampIndex;

     InvalidUniqueKeyInbox               fInvalidUniqueKeyInbox;

     // This resource is allowed to be in the nonpurgeable array for the sake of validate() because
     // we're in the midst of converting it to purgeable status.
     SkDEBUGCODE(GrGpuResource*          fNewlyPurgeableResourceForValidation;)

     bool                                fPreferVRAMUseOverFlushes;
 };

 class GrResourceCache::ResourceAccess {
 private:
     ResourceAccess(GrResourceCache* cache) : fCache(cache) { }
     ResourceAccess(const ResourceAccess& that) : fCache(that.fCache) { }
     ResourceAccess& operator=(const ResourceAccess&); // unimpl

     /**
      * Insert a resource into the cache.
      */
     void insertResource(GrGpuResource* resource) { fCache->insertResource(resource); }

     /**
      * Removes a resource from the cache.
      */
     void removeResource(GrGpuResource* resource) { fCache->removeResource(resource); }

     /**
      * Notifications that should be sent to the cache when the ref/io cnt status of resources
      * changes.
      */
     enum RefNotificationFlags {
         /** All types of refs on the resource have reached zero. */
         kAllCntsReachedZero_RefNotificationFlag = 0x1,
         /** The normal (not pending IO type) ref cnt has reached zero. */
         kRefCntReachedZero_RefNotificationFlag  = 0x2,
     };
     /**
      * Called by GrGpuResources when they detect that their ref/io cnts have reached zero. When the
      * normal ref cnt reaches zero the flags that are set should be:
      *     a) kRefCntReachedZero if a pending IO cnt is still non-zero.
      *     b) (kRefCntReachedZero | kAllCntsReachedZero) when all pending IO cnts are also zero.
      * kAllCntsReachedZero is set by itself if a pending IO cnt is decremented to zero and all the
      * the other cnts are already zero.
      */
     void notifyCntReachedZero(GrGpuResource* resource, uint32_t flags) {
         fCache->notifyCntReachedZero(resource, flags);
     }

     /**
      * Called by GrGpuResources when their sizes change.
      */
     void didChangeGpuMemorySize(const GrGpuResource* resource, size_t oldSize) {
         fCache->didChangeGpuMemorySize(resource, oldSize);
     }

     /**
      * Called by GrGpuResources to change their unique keys.
      */
     void changeUniqueKey(GrGpuResource* resource, const GrUniqueKey& newKey) {
          fCache->changeUniqueKey(resource, newKey);
     }

     /**
      * Called by a GrGpuResource to remove its unique key.
      */
     void removeUniqueKey(GrGpuResource* resource) { fCache->removeUniqueKey(resource); }

     /**
      * Called by a GrGpuResource when it removes its scratch key.
      */
     void willRemoveScratchKey(const GrGpuResource* resource) {
         fCache->willRemoveScratchKey(resource);
     }

     /**
      * Called by GrGpuResources when they change from budgeted to unbudgeted or vice versa.
      */
     void didChangeBudgetStatus(GrGpuResource* resource) { fCache->didChangeBudgetStatus(resource); }

     // No taking addresses of this type.
     const ResourceAccess* operator&() const;
     ResourceAccess* operator&();

     GrResourceCache* fCache;

     friend class GrGpuResource; // To access all the proxy inline methods.
     friend class GrResourceCache; // To create this type.
 };

 inline GrResourceCache::ResourceAccess GrResourceCache::resourceAccess() {
     return ResourceAccess(this);
 }

 #endif
	/*
	* Copyright 2014 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#ifndef GrResourceCache_DEFINED
	#define GrResourceCache_DEFINED

	#include "GrGpuResource.h"
	#include "GrGpuResourceCacheAccess.h"
	#include "GrGpuResourcePriv.h"
	#include "GrResourceKey.h"
	#include "SkMessageBus.h"
	#include "SkRefCnt.h"
	#include "SkTArray.h"
	#include "SkTDPQueue.h"
	#include "SkTInternalLList.h"
	#include "SkTMultiMap.h"

	class GrCaps;
	class SkString;
	class SkTraceMemoryDump;

	/**
	* Manages the lifetime of all GrGpuResource instances.
	*
	* Resources may have optionally have two types of keys:
	* 1) A scratch key. This is for resources whose allocations are cached but not their contents.
	* Multiple resources can share the same scratch key. This is so a caller can have two
	* resource instances with the same properties (e.g. multipass rendering that ping-pongs
	* between two temporary surfaces). The scratch key is set at resource creation time and
	* should never change. Resources need not have a scratch key.
	* 2) A unique key. This key's meaning is specific to the domain that created the key. Only one
	* resource may have a given unique key. The unique key can be set, cleared, or changed
	* anytime after resource creation.
	*
	* A unique key always takes precedence over a scratch key when a resource has both types of keys.
	* If a resource has neither key type then it will be deleted as soon as the last reference to it
	* is dropped.
	*
	* When proactive purging is enabled, on every flush, the timestamp of that flush is stored in a
	* n-sized ring buffer. When purging occurs each purgeable resource's timestamp is compared to the
	* timestamp of the n-th prior flush. If the resource's last use timestamp is older than the old
	* flush then the resource is proactively purged even when the cache is under budget. By default
	* this feature is disabled, though it can be enabled by calling GrResourceCache::setLimits.
	*/
	class GrResourceCache {
	public:
	GrResourceCache(const GrCaps* caps);
	~GrResourceCache();

	// Default maximum number of budgeted resources in the cache.
	static const int kDefaultMaxCount = 2 * (1 << 12);
	// Default maximum number of bytes of gpu memory of budgeted resources in the cache.
	static const size_t kDefaultMaxSize = 96 * (1 << 20);
	// Default number of flushes a budgeted resources can go unused in the cache before it is
	// purged. Large values disable the feature (as the ring buffer of flush timestamps would be
	// large). This is currently the default until we decide to enable this feature
	// of the cache by default.
	static const int kDefaultMaxUnusedFlushes = 64;

	/** Used to access functionality needed by GrGpuResource for lifetime management. */
	class ResourceAccess;
	ResourceAccess resourceAccess();

	/**
	* Sets the cache limits in terms of number of resources, max gpu memory byte size, and number
	* of GrContext flushes that a resource can be unused before it is evicted. The latter value is
	* a suggestion and there is no promise that a resource will be purged immediately after it
	* hasn't been used in maxUnusedFlushes flushes.
	*/
	void setLimits(int count, size_t bytes, int maxUnusedFlushes = kDefaultMaxUnusedFlushes);

	/**
	* Returns the number of resources.
	*/
	int getResourceCount() const {
	return fPurgeableQueue.count() + fNonpurgeableResources.count();
	}

	/**
	* Returns the number of resources that count against the budget.
	*/
	int getBudgetedResourceCount() const { return fBudgetedCount; }

	/**
	* Returns the number of bytes consumed by resources.
	*/
	size_t getResourceBytes() const { return fBytes; }

	/**
	* Returns the number of bytes consumed by budgeted resources.
	*/
	size_t getBudgetedResourceBytes() const { return fBudgetedBytes; }

	/**
	* Returns the cached resources count budget.
	*/
	int getMaxResourceCount() const { return fMaxCount; }

	/**
	* Returns the number of bytes consumed by cached resources.
	*/
	size_t getMaxResourceBytes() const { return fMaxBytes; }

	/**
	* Abandons the backend API resources owned by all GrGpuResource objects and removes them from
	* the cache.
	*/
	void abandonAll();

	/**
	* Releases the backend API resources owned by all GrGpuResource objects and removes them from
	* the cache.
	*/
	void releaseAll();

	enum {
	/** Preferentially returns scratch resources with no pending IO. */
	kPreferNoPendingIO_ScratchFlag = 0x1,
	/** Will not return any resources that match but have pending IO. */
	kRequireNoPendingIO_ScratchFlag = 0x2,
	};

	/**
	* Find a resource that matches a scratch key.
	*/
	GrGpuResource* findAndRefScratchResource(const GrScratchKey& scratchKey,
	size_t resourceSize,
	uint32_t flags);

	#ifdef SK_DEBUG
	// This is not particularly fast and only used for validation, so debug only.
	int countScratchEntriesForKey(const GrScratchKey& scratchKey) const {
	return fScratchMap.countForKey(scratchKey);
	}
	#endif

	/**
	* Find a resource that matches a unique key.
	*/
	GrGpuResource* findAndRefUniqueResource(const GrUniqueKey& key) {
	GrGpuResource* resource = fUniqueHash.find(key);
	if (resource) {
	this->refAndMakeResourceMRU(resource);
	}
	return resource;
	}

	/**
	* Query whether a unique key exists in the cache.
	*/
	bool hasUniqueKey(const GrUniqueKey& key) const {
	return SkToBool(fUniqueHash.find(key));
	}

	/** Purges resources to become under budget and processes resources with invalidated unique
	keys. */
	void purgeAsNeeded();

	/** Purges all resources that don't have external owners. */
	void purgeAllUnlocked();

	/**
	* The callback function used by the cache when it is still over budget after a purge. The
	* passed in 'data' is the same 'data' handed to setOverbudgetCallback.
	*/
	typedef void (PFOverBudgetCB)(void data);

	/**
	* Set the callback the cache should use when it is still over budget after a purge. The 'data'
	* provided here will be passed back to the callback. Note that the cache will attempt to purge
	* any resources newly freed by the callback.
	*/
	void setOverBudgetCallback(PFOverBudgetCB overBudgetCB, void* data) {
	fOverBudgetCB = overBudgetCB;
	fOverBudgetData = data;
	}

	void notifyFlushOccurred();

	#if GR_CACHE_STATS
	struct Stats {
	int fTotal;
	int fNumPurgeable;
	int fNumNonPurgeable;

	int fScratch;
	int fExternal;
	int fBorrowed;
	int fAdopted;
	size_t fUnbudgetedSize;

	Stats() { this->reset(); }

	void reset() {
	fTotal = 0;
	fNumPurgeable = 0;
	fNumNonPurgeable = 0;
	fScratch = 0;
	fExternal = 0;
	fBorrowed = 0;
	fAdopted = 0;
	fUnbudgetedSize = 0;
	}

	void update(GrGpuResource* resource) {
	if (resource->cacheAccess().isScratch()) {
	++fScratch;
	}
	if (resource->resourcePriv().isExternal()) {
	++fExternal;
	}
	if (resource->cacheAccess().isBorrowed()) {
	++fBorrowed;
	}
	if (resource->cacheAccess().isAdopted()) {
	++fAdopted;
	}
	if (SkBudgeted::kNo == resource->resourcePriv().isBudgeted()) {
	fUnbudgetedSize += resource->gpuMemorySize();
	}
	}
	};

	void getStats(Stats*) const;

	void dumpStats(SkString*) const;

	void dumpStatsKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* value) const;
	#endif

	// This function is for unit testing and is only defined in test tools.
	void changeTimestamp(uint32_t newTimestamp);

	// Enumerates all cached resources and dumps their details to traceMemoryDump.
	void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;

	private:
	///////////////////////////////////////////////////////////////////////////
	/// @name Methods accessible via ResourceAccess
	////
	void insertResource(GrGpuResource*);
	void removeResource(GrGpuResource*);
	void notifyCntReachedZero(GrGpuResource*, uint32_t flags);
	void didChangeGpuMemorySize(const GrGpuResource*, size_t oldSize);
	void changeUniqueKey(GrGpuResource*, const GrUniqueKey&);
	void removeUniqueKey(GrGpuResource*);
	void willRemoveScratchKey(const GrGpuResource*);
	void didChangeBudgetStatus(GrGpuResource*);
	void refAndMakeResourceMRU(GrGpuResource*);
	/// @}

	void resetFlushTimestamps();
	void processInvalidUniqueKeys(const SkTArray<GrUniqueKeyInvalidatedMessage>&);
	void addToNonpurgeableArray(GrGpuResource*);
	void removeFromNonpurgeableArray(GrGpuResource*);
	bool overBudget() const { return fBudgetedBytes > fMaxBytes \|\| fBudgetedCount > fMaxCount; }

	bool wouldFit(size_t bytes) {
	return fBudgetedBytes+bytes <= fMaxBytes && fBudgetedCount+1 <= fMaxCount;
	}

	uint32_t getNextTimestamp();

	#ifdef SK_DEBUG
	bool isInCache(const GrGpuResource* r) const;
	void validate() const;
	#else
	void validate() const {}
	#endif

	class AutoValidate;

	class AvailableForScratchUse;

	struct ScratchMapTraits {
	static const GrScratchKey& GetKey(const GrGpuResource& r) {
	return r.resourcePriv().getScratchKey();
	}

	static uint32_t Hash(const GrScratchKey& key) { return key.hash(); }
	};
	typedef SkTMultiMap<GrGpuResource, GrScratchKey, ScratchMapTraits> ScratchMap;

	struct UniqueHashTraits {
	static const GrUniqueKey& GetKey(const GrGpuResource& r) { return r.getUniqueKey(); }

	static uint32_t Hash(const GrUniqueKey& key) { return key.hash(); }
	};
	typedef SkTDynamicHash<GrGpuResource, GrUniqueKey, UniqueHashTraits> UniqueHash;

	static bool CompareTimestamp(GrGpuResource* const& a, GrGpuResource* const& b) {
	return a->cacheAccess().timestamp() < b->cacheAccess().timestamp();
	}

	static int* AccessResourceIndex(GrGpuResource* const& res) {
	return res->cacheAccess().accessCacheIndex();
	}

	typedef SkMessageBus<GrUniqueKeyInvalidatedMessage>::Inbox InvalidUniqueKeyInbox;
	typedef SkTDPQueue<GrGpuResource*, CompareTimestamp, AccessResourceIndex> PurgeableQueue;
	typedef SkTDArray<GrGpuResource*> ResourceArray;

	// Whenever a resource is added to the cache or the result of a cache lookup, fTimestamp is
	// assigned as the resource's timestamp and then incremented. fPurgeableQueue orders the
	// purgeable resources by this value, and thus is used to purge resources in LRU order.
	uint32_t fTimestamp;
	PurgeableQueue fPurgeableQueue;
	ResourceArray fNonpurgeableResources;

	// This map holds all resources that can be used as scratch resources.
	ScratchMap fScratchMap;
	// This holds all resources that have unique keys.
	UniqueHash fUniqueHash;

	// our budget, used in purgeAsNeeded()
	int fMaxCount;
	size_t fMaxBytes;
	int fMaxUnusedFlushes;

	#if GR_CACHE_STATS
	int fHighWaterCount;
	size_t fHighWaterBytes;
	int fBudgetedHighWaterCount;
	size_t fBudgetedHighWaterBytes;
	#endif

	// our current stats for all resources
	SkDEBUGCODE(int fCount;)
	size_t fBytes;

	// our current stats for resources that count against the budget
	int fBudgetedCount;
	size_t fBudgetedBytes;

	PFOverBudgetCB fOverBudgetCB;
	void* fOverBudgetData;

	// We keep track of the "timestamps" of the last n flushes. If a resource hasn't been used in
	// that time then we well preemptively purge it to reduce memory usage.
	uint32_t* fFlushTimestamps;
	int fLastFlushTimestampIndex;

	InvalidUniqueKeyInbox fInvalidUniqueKeyInbox;

	// This resource is allowed to be in the nonpurgeable array for the sake of validate() because
	// we're in the midst of converting it to purgeable status.
	SkDEBUGCODE(GrGpuResource* fNewlyPurgeableResourceForValidation;)

	bool fPreferVRAMUseOverFlushes;
	};

	class GrResourceCache::ResourceAccess {
	private:
	ResourceAccess(GrResourceCache* cache) : fCache(cache) { }
	ResourceAccess(const ResourceAccess& that) : fCache(that.fCache) { }
	ResourceAccess& operator=(const ResourceAccess&); // unimpl

	/**
	* Insert a resource into the cache.
	*/
	void insertResource(GrGpuResource* resource) { fCache->insertResource(resource); }

	/**
	* Removes a resource from the cache.
	*/
	void removeResource(GrGpuResource* resource) { fCache->removeResource(resource); }

	/**
	* Notifications that should be sent to the cache when the ref/io cnt status of resources
	* changes.
	*/
	enum RefNotificationFlags {
	/** All types of refs on the resource have reached zero. */
	kAllCntsReachedZero_RefNotificationFlag = 0x1,
	/** The normal (not pending IO type) ref cnt has reached zero. */
	kRefCntReachedZero_RefNotificationFlag = 0x2,
	};
	/**
	* Called by GrGpuResources when they detect that their ref/io cnts have reached zero. When the
	* normal ref cnt reaches zero the flags that are set should be:
	* a) kRefCntReachedZero if a pending IO cnt is still non-zero.
	* b) (kRefCntReachedZero \| kAllCntsReachedZero) when all pending IO cnts are also zero.
	* kAllCntsReachedZero is set by itself if a pending IO cnt is decremented to zero and all the
	* the other cnts are already zero.
	*/
	void notifyCntReachedZero(GrGpuResource* resource, uint32_t flags) {
	fCache->notifyCntReachedZero(resource, flags);
	}

	/**
	* Called by GrGpuResources when their sizes change.
	*/
	void didChangeGpuMemorySize(const GrGpuResource* resource, size_t oldSize) {
	fCache->didChangeGpuMemorySize(resource, oldSize);
	}

	/**
	* Called by GrGpuResources to change their unique keys.
	*/
	void changeUniqueKey(GrGpuResource* resource, const GrUniqueKey& newKey) {
	fCache->changeUniqueKey(resource, newKey);
	}

	/**
	* Called by a GrGpuResource to remove its unique key.
	*/
	void removeUniqueKey(GrGpuResource* resource) { fCache->removeUniqueKey(resource); }

	/**
	* Called by a GrGpuResource when it removes its scratch key.
	*/
	void willRemoveScratchKey(const GrGpuResource* resource) {
	fCache->willRemoveScratchKey(resource);
	}

	/**
	* Called by GrGpuResources when they change from budgeted to unbudgeted or vice versa.
	*/
	void didChangeBudgetStatus(GrGpuResource* resource) { fCache->didChangeBudgetStatus(resource); }

	// No taking addresses of this type.
	const ResourceAccess* operator&() const;
	ResourceAccess* operator&();

	GrResourceCache* fCache;

	friend class GrGpuResource; // To access all the proxy inline methods.
	friend class GrResourceCache; // To create this type.
	};

	inline GrResourceCache::ResourceAccess GrResourceCache::resourceAccess() {
	return ResourceAccess(this);
	}

	#endif