Change implementation of flush-count based GrGpuResource purging

src/gpu/GrResourceCache.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrResourceCache.h"
 
@@ skipping 56 matching lines @@
 #if GR_CACHE_STATS
     , fHighWaterCount(0)
     , fHighWaterBytes(0)
     , fBudgetedHighWaterCount(0)
     , fBudgetedHighWaterBytes(0)
 #endif
     , fBytes(0)
     , fBudgetedCount(0)
     , fBudgetedBytes(0)
     , fRequestFlush(false)
-    , fFlushTimestamps(nullptr)
-    , fLastFlushTimestampIndex(0)
+    , fExternalFlushCnt(0)
     , fPreferVRAMUseOverFlushes(caps->preferVRAMUseOverFlushes()) {
     SkDEBUGCODE(fCount = 0;)
     SkDEBUGCODE(fNewlyPurgeableResourceForValidation = nullptr;)
-    this->resetFlushTimestamps();
 }
 
 GrResourceCache::~GrResourceCache() {
     this->releaseAll();
-    delete[] fFlushTimestamps;
 }
 
 void GrResourceCache::setLimits(int count, size_t bytes, int maxUnusedFlushes) {
     fMaxCount = count;
     fMaxBytes = bytes;
     fMaxUnusedFlushes = maxUnusedFlushes;
-    this->resetFlushTimestamps();
     this->purgeAsNeeded();
 }
 
-void GrResourceCache::resetFlushTimestamps() {
-    delete[] fFlushTimestamps;
-
-    // We assume this number is a power of two when wrapping indices into the timestamp array.
-    fMaxUnusedFlushes = SkNextPow2(fMaxUnusedFlushes);
-
-    // Since our implementation is to store the timestamps of the last fMaxUnusedFlushes flush calls
-    // we just turn the feature off if that array would be large.
-    static const int kMaxSupportedTimestampHistory = 128;
-
-    if (fMaxUnusedFlushes > kMaxSupportedTimestampHistory) {
-        fFlushTimestamps = nullptr;
-        return;
-    }
-
-    fFlushTimestamps = new uint32_t[fMaxUnusedFlushes];
-    fLastFlushTimestampIndex = 0;
-    // Set all the historical flush timestamps to initially be at the beginning of time (timestamp
-    // 0).
-    sk_bzero(fFlushTimestamps, fMaxUnusedFlushes * sizeof(uint32_t));
-}
-
 void GrResourceCache::insertResource(GrGpuResource* resource) {
     SkASSERT(resource);
     SkASSERT(!this->isInCache(resource));
     SkASSERT(!resource->wasDestroyed());
     SkASSERT(!resource->isPurgeable());
 
     // We must set the timestamp before adding to the array in case the timestamp wraps and we wind
     // up iterating over all the resources that already have timestamps.
     resource->cacheAccess().setTimestamp(this->getNextTimestamp());
 
@@ skipping 253 matching lines @@
     }
 
     if (!SkToBool(ResourceAccess::kAllCntsReachedZero_RefNotificationFlag & flags)) {
         SkASSERT(!resource->isPurgeable());
         return;
     }
 
     SkASSERT(resource->isPurgeable());
     this->removeFromNonpurgeableArray(resource);
     fPurgeableQueue.insert(resource);
+    resource->cacheAccess().setFlushCntWhenResourceBecamePurgeable(fExternalFlushCnt);
 
     if (SkBudgeted::kNo == resource->resourcePriv().isBudgeted()) {
         // Check whether this resource could still be used as a scratch resource.
         if (!resource->resourcePriv().refsWrappedObjects() &&
             resource->resourcePriv().getScratchKey().isValid()) {
             // We won't purge an existing resource to make room for this one.
             if (fBudgetedCount < fMaxCount &&
                 fBudgetedBytes + resource->gpuMemorySize() <= fMaxBytes) {
                 resource->resourcePriv().makeBudgeted();
                 return;
@@ skipping 64 matching lines @@
     this->validate();
 }
 
 void GrResourceCache::purgeAsNeeded() {
     SkTArray<GrUniqueKeyInvalidatedMessage> invalidKeyMsgs;
     fInvalidUniqueKeyInbox.poll(&invalidKeyMsgs);
     if (invalidKeyMsgs.count()) {
         this->processInvalidUniqueKeys(invalidKeyMsgs);
     }
 
-    if (fFlushTimestamps) {
-        // Assuming kNumFlushesToDeleteUnusedResource is a power of 2.
-        SkASSERT(SkIsPow2(fMaxUnusedFlushes));
-        int oldestFlushIndex = (fLastFlushTimestampIndex + 1) & (fMaxUnusedFlushes - 1);
-
-        uint32_t oldestAllowedTimestamp = fFlushTimestamps[oldestFlushIndex];
-        while (fPurgeableQueue.count()) {
-            uint32_t oldestResourceTimestamp = fPurgeableQueue.peek()->cacheAccess().timestamp();
-            if (oldestAllowedTimestamp < oldestResourceTimestamp) {
-                break;
+    if (fMaxUnusedFlushes > 0) {
+        // We want to know how many complete flushes have occurred without the resource being used.
+        // If the resource was tagged when fExternalFlushCnt was N then this means it became
+        // purgeable during activity that became the N+1th flush. So when the flush count is N+2
+        // it has sat in the purgeable queue for one entire flush.
+        uint32_t oldestAllowedFlushCnt = fExternalFlushCnt - fMaxUnusedFlushes - 1;
+        // check for underflow
+        if (oldestAllowedFlushCnt < fExternalFlushCnt) {
+            while (fPurgeableQueue.count()) {
+                uint32_t flushWhenResourceBecamePurgeable =
+                        fPurgeableQueue.peek()->cacheAccess().flushCntWhenResourceBecamePurgeable();
+                if (oldestAllowedFlushCnt < flushWhenResourceBecamePurgeable) {
+                    // Resources were given both LRU timestamps and tagged with a flush cnt when
+                    // they first became purgeable. The LRU timestamp won't change again until the
+                    // resource is made non-purgeable again. So, at this point all the remaining
+                    // resources in the timestamp-sorted queue will have a flush count >= to this
+                    // one.
+                    break;
+                }
+                GrGpuResource* resource = fPurgeableQueue.peek();
+                SkASSERT(resource->isPurgeable());
+                resource->cacheAccess().release();
             }
-            GrGpuResource* resource = fPurgeableQueue.peek();
-            SkASSERT(resource->isPurgeable());
-            resource->cacheAccess().release();
         }
     }
 
     bool stillOverbudget = this->overBudget();
     while (stillOverbudget && fPurgeableQueue.count()) {
         GrGpuResource* resource = fPurgeableQueue.peek();
         SkASSERT(resource->isPurgeable());
         resource->cacheAccess().release();
         stillOverbudget = this->overBudget();
     }
@@ skipping 58 matching lines @@
             // sequential timestamps beginning with 0. This is O(n*lg(n)) but it should be extremely
             // rare.
             SkTDArray<GrGpuResource*> sortedPurgeableResources;
             sortedPurgeableResources.setReserve(fPurgeableQueue.count());
 
             while (fPurgeableQueue.count()) {
                 *sortedPurgeableResources.append() = fPurgeableQueue.peek();
                 fPurgeableQueue.pop();
             }
 
-            struct Less {
-                bool operator()(GrGpuResource* a, GrGpuResource* b) {
-                    return CompareTimestamp(a,b);
-                }
-            };
-            Less less;
-            SkTQSort(fNonpurgeableResources.begin(), fNonpurgeableResources.end() - 1, less);
+            SkTQSort(fNonpurgeableResources.begin(), fNonpurgeableResources.end() - 1,
+                     CompareTimestamp);
 
             // Pick resources out of the purgeable and non-purgeable arrays based on lowest
             // timestamp and assign new timestamps.
             int currP = 0;
             int currNP = 0;
             while (currP < sortedPurgeableResources.count() &&
                    currNP < fNonpurgeableResources.count()) {
                 uint32_t tsP = sortedPurgeableResources[currP]->cacheAccess().timestamp();
                 uint32_t tsNP = fNonpurgeableResources[currNP]->cacheAccess().timestamp();
                 SkASSERT(tsP != tsNP);
@@ skipping 18 matching lines @@
             // Rebuild the queue.
             for (int i = 0; i < sortedPurgeableResources.count(); ++i) {
                 fPurgeableQueue.insert(sortedPurgeableResources[i]);
             }
 
             this->validate();
             SkASSERT(count == this->getResourceCount());
 
             // count should be the next timestamp we return.
             SkASSERT(fTimestamp == SkToU32(count));
-
-            // The historical timestamps of flushes are now invalid.
-            this->resetFlushTimestamps();
         }
     }
     return fTimestamp++;
 }
 
 void GrResourceCache::notifyFlushOccurred(FlushType type) {
     switch (type) {
         case FlushType::kImmediateMode:
             break;
         case FlushType::kCacheRequested:
             SkASSERT(fRequestFlush);
             fRequestFlush = false;
             break;
         case FlushType::kExternal:
-            if (fFlushTimestamps) {
-                SkASSERT(SkIsPow2(fMaxUnusedFlushes));
-                fLastFlushTimestampIndex = (fLastFlushTimestampIndex + 1) & (fMaxUnusedFlushes - 1);
-                // get the timestamp before accessing fFlushTimestamps because getNextTimestamp will
-                // reallocate fFlushTimestamps on timestamp overflow.
-                uint32_t timestamp = this->getNextTimestamp();
-                fFlushTimestamps[fLastFlushTimestampIndex] = timestamp;
+            ++fExternalFlushCnt;
+            if (0 == fExternalFlushCnt) {
+                // When this wraps just reset all the purgeable resources' last used flush state.
+                for (int i = 0; i < fPurgeableQueue.count(); ++i) {
+                    fPurgeableQueue.at(i)->cacheAccess().setFlushCntWhenResourceBecamePurgeable(0);
+                }
             }
             break;
     }
     this->purgeAsNeeded();
 }
 
 void GrResourceCache::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
     for (int i = 0; i < fNonpurgeableResources.count(); ++i) {
         fNonpurgeableResources[i]->dumpMemoryStatistics(traceMemoryDump);
     }
@@ skipping 131 matching lines @@
         return true;
     }
     if (index < fNonpurgeableResources.count() && fNonpurgeableResources[index] == resource) {
         return true;
     }
     SkDEBUGFAIL("Resource index should be -1 or the resource should be in the cache.");
     return false;
 }
 
 #endif