Allow unbudgeted resources to be recycled by the cache as scratch.

src/gpu/GrResourceCache2.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 "GrResourceCache2.h"
@@ skipping 226 matching lines @@
     return true;
 }
 
 void GrResourceCache2::makeResourceMRU(GrGpuResource* resource) {
     SkASSERT(!fPurging);
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
     fResources.remove(resource);    
     fResources.addToHead(resource);
 }
 

[robertphillips, 2015/01/23 14:54:10]

Purgeable ?

 void GrResourceCache2::notifyPurgable(GrGpuResource* resource) {
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
     SkASSERT(resource->isPurgable());
 
     // We can't purge if in the middle of purging because purge is iterating. Instead record
     // that additional resources became purgable.
     if (fPurging) {
         fNewlyPurgableResourceWhilePurging = true;
         return;
     }
 
-    // Purge the resource if we're over budget
-    bool overBudget = fBudgetedCount > fMaxCount || fBudgetedBytes > fMaxBytes;
+    bool release = false;
 
-    // Also purge if the resource has neither a valid scratch key nor a content key.
-    bool noKey = !resource->cacheAccess().getScratchKey().isValid() &&
-                 !resource->cacheAccess().getContentKey().isValid();
+    if (resource->cacheAccess().isWrapped()) {
+        release = true;
+    } else if (!resource->cacheAccess().isBudgeted()) {
+        // Check whether this resource could still be used as a scratch resource.
+        if (resource->cacheAccess().getScratchKey().isValid()) {
+            // We won't purge an existing resource to make room for this one.
+            bool underBudget = fBudgetedCount < fMaxCount &&
+                               fBudgetedBytes + resource->gpuMemorySize() <= fMaxBytes;
+            if (underBudget) {
+                resource->cacheAccess().makeBudgeted();
+            } else {
+                release = true;
+            }
+        } else {
+            release = true;
+        }
+    } else {
+        // Purge the resource if we're over budget
+        bool overBudget = fBudgetedCount > fMaxCount || fBudgetedBytes > fMaxBytes;
 
-    // Only cached resources should ever have a key.
-    SkASSERT(noKey || resource->cacheAccess().isBudgeted());
+        // Also purge if the resource has neither a valid scratch key nor a content key.
+        bool noKey = !resource->cacheAccess().getScratchKey().isValid() &&
+                     !resource->cacheAccess().getContentKey().isValid();
+        if (overBudget || noKey) {
+            release = true;
+        }
+    }
 
-    if (overBudget || noKey) {
+    if (release) {
         SkDEBUGCODE(int beforeCount = fCount;)
         resource->cacheAccess().release();
         // We should at least free this resource, perhaps dependent resources as well.
         SkASSERT(fCount < beforeCount);
     }
-
     this->validate();
 }
 
 void GrResourceCache2::didChangeGpuMemorySize(const GrGpuResource* resource, size_t oldSize) {
     // SkASSERT(!fPurging); GrPathRange increases size during flush. :(
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
 
     ptrdiff_t delta = resource->gpuMemorySize() - oldSize;
 
@@ skipping 95 matching lines @@
         if (!fNewlyPurgableResourceWhilePurging && fCount && fOverBudgetCB) {
             (*fOverBudgetCB)(fOverBudgetData);
         }
     } while (fNewlyPurgableResourceWhilePurging);
     fPurging = false;
     this->validate();
 }
 
 #ifdef SK_DEBUG
 void GrResourceCache2::validate() const {
+    // Reduce the frequency of validations for large resource counts.
+    static SkRandom gRandom;
+    int mask = (SkNextPow2(fCount + 1) >> 5) - 1;
+    if (~mask && (gRandom.nextU() & mask)) {
+        return;
+    }
+
     size_t bytes = 0;
     int count = 0;
     int budgetedCount = 0;
     size_t budgetedBytes = 0;
     int locked = 0;
     int scratch = 0;
     int couldBeScratch = 0;
     int content = 0;
 
     ResourceList::Iter iter;
     GrGpuResource* resource = iter.init(fResources, ResourceList::Iter::kHead_IterStart);
     for ( ; resource; resource = iter.next()) {
         bytes += resource->gpuMemorySize();
         ++count;
 
         if (!resource->isPurgable()) {
             ++locked;
         }
 
         if (resource->cacheAccess().isScratch()) {
             SkASSERT(!resource->cacheAccess().getContentKey().isValid());
             ++scratch;
             SkASSERT(fScratchMap.countForKey(resource->cacheAccess().getScratchKey()));
             SkASSERT(!resource->cacheAccess().isWrapped());
         } else if (resource->cacheAccess().getScratchKey().isValid()) {
-            SkASSERT(resource->cacheAccess().getContentKey().isValid());
+            SkASSERT(!resource->cacheAccess().isBudgeted() ||
+                     resource->cacheAccess().getContentKey().isValid());
             ++couldBeScratch;
             SkASSERT(fScratchMap.countForKey(resource->cacheAccess().getScratchKey()));
             SkASSERT(!resource->cacheAccess().isWrapped());
         }
         const GrContentKey& contentKey = resource->cacheAccess().getContentKey();
         if (contentKey.isValid()) {
             ++content;
             SkASSERT(fContentHash.find(contentKey) == resource);
             SkASSERT(!resource->cacheAccess().isWrapped());
+            SkASSERT(resource->cacheAccess().isBudgeted());
         }
 
         if (resource->cacheAccess().isBudgeted()) {
             ++budgetedCount;
             budgetedBytes += resource->gpuMemorySize();
         }
     }
 
     SkASSERT(fBudgetedCount <= fCount);
     SkASSERT(fBudgetedBytes <= fBudgetedBytes);
@@ skipping 51 matching lines @@
 
     SkDebugf("Budget: %d items %d bytes\n", fMaxCount, fMaxBytes);
     SkDebugf("\t\tEntry Count: current %d"
              " (%d budgeted, %d wrapped, %d locked, %d scratch %.2g%% full), high %d\n",
         fCount, fBudgetedCount, wrapped, locked, scratch, countUtilization, fHighWaterCount);
     SkDebugf("\t\tEntry Bytes: current %d (budgeted %d, %.2g%% full, %d unbudgeted) high %d\n",
                 fBytes, fBudgetedBytes, byteUtilization, unbudgetedSize, fHighWaterBytes);
 }
 
 #endif