Make GrResourceCache use a priority queue of purgeable resources.

src/gpu/GrResourceCache.h

 
 /*
  * 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 SkString;
 
 /**
  * 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.
@@ skipping 82 matching lines @@
         return fScratchMap.countForKey(scratchKey);
     }
 #endif
 
     /**
      * Find a resource that matches a content key.
      */
     GrGpuResource* findAndRefContentResource(const GrContentKey& contentKey) {
         GrGpuResource* resource = fContentHash.find(contentKey);
         if (resource) {
-            resource->ref();
-            this->makeResourceMRU(resource);
+            this->refAndMakeResourceMRU(resource);
         }
         return resource;
     }
 
     /**
      * Query whether a content key exists in the cache.
      */
     bool hasContentKey(const GrContentKey& contentKey) const {
         return SkToBool(fContentHash.find(contentKey));
     }
 
     /** Purges resources to become under budget and processes resources with invalidated content
         keys. */
     void purgeAsNeeded() {
         SkTArray<GrContentKeyInvalidatedMessage> invalidKeyMsgs;
         fInvalidContentKeyInbox.poll(&invalidKeyMsgs);
         if (invalidKeyMsgs.count()) {
             this->processInvalidContentKeys(invalidKeyMsgs);
         }
-        if (fPurging || (fBudgetedCount <= fMaxCount && fBudgetedBytes <= fMaxBytes)) {
+        if (fBudgetedCount <= fMaxCount && fBudgetedBytes <= fMaxBytes) {
             return;
         }
         this->internalPurgeAsNeeded();
     }
 
     /** 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
@@ skipping 20 matching lines @@
     /// @name Methods accessible via ResourceAccess
     ////
     void insertResource(GrGpuResource*);
     void removeResource(GrGpuResource*);
     void notifyPurgeable(GrGpuResource*);
     void didChangeGpuMemorySize(const GrGpuResource*, size_t oldSize);
     bool didSetContentKey(GrGpuResource*);
     void willRemoveScratchKey(const GrGpuResource*);
     void willRemoveContentKey(const GrGpuResource*);
     void didChangeBudgetStatus(GrGpuResource*);
-    void makeResourceMRU(GrGpuResource*);
+    void refAndMakeResourceMRU(GrGpuResource*);
     /// @}
 
     void internalPurgeAsNeeded();
     void processInvalidContentKeys(const SkTArray<GrContentKeyInvalidatedMessage>&);
 
 #ifdef SK_DEBUG
     bool isInCache(const GrGpuResource* r) const { return fResources.isInList(r); }
     void validate() const;
 #else
     void validate() const {}
@@ skipping 16 matching lines @@
         static const GrContentKey& GetKey(const GrGpuResource& r) {
             return r.getContentKey();
         }
 
         static uint32_t Hash(const GrContentKey& key) { return key.hash(); }
     };
     typedef SkTDynamicHash<GrGpuResource, GrContentKey, ContentHashTraits> ContentHash;
 
     typedef SkTInternalLList<GrGpuResource> ResourceList;
 
+    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<GrContentKeyInvalidatedMessage>::Inbox InvalidContentKeyInbox;
+    typedef SkTDPQueue<GrGpuResource*, CompareTimestamp, AccessResourceIndex> PurgeableQueue;
 
+    // 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;
+
+    // TODO: Replace this with an array of nonpurgeable resources
     ResourceList                        fResources;
+
     // This map holds all resources that can be used as scratch resources.
     ScratchMap                          fScratchMap;
     // This holds all resources that have content keys.
     ContentHash                         fContentHash;
 
     // our budget, used in purgeAsNeeded()
     int                                 fMaxCount;
     size_t                              fMaxBytes;
 
 #if GR_CACHE_STATS
     int                                 fHighWaterCount;
     size_t                              fHighWaterBytes;
     int                                 fBudgetedHighWaterCount;
     size_t                              fBudgetedHighWaterBytes;
 #endif
 
     // our current stats for all resources
     int                                 fCount;
     size_t                              fBytes;
 
     // our current stats for resources that count against the budget
     int                                 fBudgetedCount;
     size_t                              fBudgetedBytes;
 
-    // prevents recursive purging
-    bool                                fPurging;
-    bool                                fNewlyPurgeableResourceWhilePurging;
-
     PFOverBudgetCB                      fOverBudgetCB;
     void*                               fOverBudgetData;
 
     InvalidContentKeyInbox              fInvalidContentKeyInbox;
-
 };
 
 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.
@@ skipping 54 matching lines @@
 
     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