Use an array of nonpurgeable resources in GrResourceCache

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
@@ skipping 37 matching lines @@
     ResourceAccess resourceAccess();
 
     /**
      * Sets the cache limits in terms of number of resources and max gpu memory byte size.
      */
     void setLimits(int count, size_t bytes);
 
     /**
      * Returns the number of resources.
      */
-    int getResourceCount() const { return fCount; }
+    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; }
@@ skipping 109 matching lines @@
     void didChangeGpuMemorySize(const GrGpuResource*, size_t oldSize);
     bool didSetContentKey(GrGpuResource*);
     void willRemoveScratchKey(const GrGpuResource*);
     void willRemoveContentKey(const GrGpuResource*);
     void didChangeBudgetStatus(GrGpuResource*);
     void refAndMakeResourceMRU(GrGpuResource*);
     /// @}
 
     void internalPurgeAsNeeded();
     void processInvalidContentKeys(const SkTArray<GrContentKeyInvalidatedMessage>&);
+    void addToNonpurgeableArray(GrGpuResource*);
+    void removeFromNonpurgeableArray(GrGpuResource*);

[robertphillips, 2015/02/17 18:32:23]

<= for underBudget ?

[bsalomon, 2015/02/17 19:32:51]

I made it < since this is used to check if there is room for more (that is were
not at the budget but really under the budget). However, it was unused in the
updated patchset, so it is removed.

+    bool underBudget() const { return fBudgetedBytes < fMaxBytes && fBudgetedCount < fMaxCount; }
+    bool overBudget() const { return fBudgetedBytes > fMaxBytes || fBudgetedCount > fMaxCount; }
 
 #ifdef SK_DEBUG
-    bool isInCache(const GrGpuResource* r) const { return fResources.isInList(r); }
+    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 ContentHashTraits {
         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;
+    typedef SkTDArray<GrGpuResource*> ResourceArray;
 
     uint32_t                            fTimestamp;
     PurgeableQueue                      fPurgeableQueue;
-
-    // TODO: Replace this with an array of nonpurgeable resources
-    ResourceList                        fResources;
+    ResourceArray                       fNonpurgeableResources;
 
     // 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;
+    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;
 
     InvalidContentKeyInbox              fInvalidContentKeyInbox;
@@ skipping 64 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