Add mechanism to proactively purge old 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 20 matching lines @@
  *         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();
     ~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    = 1024;
+
     /** Used to access functionality needed by GrGpuResource for lifetime management. */
     class ResourceAccess;
     ResourceAccess resourceAccess();
 
     /**
-     * Sets the cache limits in terms of number of resources and max gpu memory byte size.
+     * 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);
+    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.
@@ skipping 64 matching lines @@
 
     /**
      * 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() {
-        SkTArray<GrUniqueKeyInvalidatedMessage> invalidKeyMsgs;
-        fInvalidUniqueKeyInbox.poll(&invalidKeyMsgs);
-        if (invalidKeyMsgs.count()) {
-            this->processInvalidUniqueKeys(invalidKeyMsgs);
-        }
-        if (fBudgetedCount <= fMaxCount && fBudgetedBytes <= fMaxBytes) {
-            return;
-        }
-        this->internalPurgeAsNeeded();
-    }
+    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_GPU_STATS
     void dumpStats(SkString*) const;
 #endif
 
     // This function is for unit testing and is only defined in test tools.
     void changeTimestamp(uint32_t newTimestamp);
 
 private:
     ///////////////////////////////////////////////////////////////////////////
     /// @name Methods accessible via ResourceAccess
     ////
     void insertResource(GrGpuResource*);
     void removeResource(GrGpuResource*);
-    void notifyPurgeable(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 internalPurgeAsNeeded();
+    void resetFlushTimestamps();
     void processInvalidUniqueKeys(const SkTArray<GrUniqueKeyInvalidatedMessage>&);
     void addToNonpurgeableArray(GrGpuResource*);
     void removeFromNonpurgeableArray(GrGpuResource*);
     bool overBudget() const { return fBudgetedBytes > fMaxBytes || fBudgetedCount > fMaxCount; }
 
     uint32_t getNextTimestamp();
 
 #ifdef SK_DEBUG
     bool isInCache(const GrGpuResource* r) const;
     void validate() const;
@@ skipping 41 matching lines @@
     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;)
 };
 
 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); }
 
     /**
-     * Called by GrGpuResources when they detects that they are newly purgeable.
+     * Notifications that should be sent to the cache when the ref/io cnt status of resources
+     * changes.
      */
-    void notifyPurgeable(GrGpuResource* resource) { fCache->notifyPurgeable(resource); }
+    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.
@@ skipping 27 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