Allow GPU resources to not be counted against the cache budget.

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 86 matching lines @@
     SkASSERT(!this->isInCache(resource));
     SkASSERT(!fPurging);
     fResources.addToHead(resource);
     resource->ref();
 
     size_t size = resource->gpuMemorySize();
     ++fCount;
     SkDEBUGCODE(fHighWaterCount = SkTMax(fCount, fHighWaterCount));
     fBytes += size;
     SkDEBUGCODE(fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes));
-    if (!resource->cacheAccess().isWrapped()) {
+    if (resource->cacheAccess().isBudgeted()) {

[bsalomon, 2014/11/13 19:20:54]

Previously isWrapped() controlled whether a resource counted against the budget.
Now isWrapped() implies not budgeted, but not all unbudgeted resources are
wrapped.

         ++fBudgetedCount;
         SkDEBUGCODE(fBudgetedHighWaterCount = SkTMax(fBudgetedCount, fBudgetedHighWaterCount));
         fBudgetedBytes += size;
         SkDEBUGCODE(fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes));
     }
     if (!resource->cacheAccess().getScratchKey().isNullScratch()) {
-        // TODO(bsalomon): Make this assertion possible.
-        // SkASSERT(!resource->isWrapped());
+        SkASSERT(!resource->cacheAccess().isWrapped());
         fScratchMap.insert(resource->cacheAccess().getScratchKey(), resource);
     }
     
     this->purgeAsNeeded();
 }
 
 void GrResourceCache2::removeResource(GrGpuResource* resource) {
     AutoValidate av(this);
 
     SkASSERT(this->isInCache(resource));
 
     size_t size = resource->gpuMemorySize();
     --fCount;
     fBytes -= size;
-    if (!resource->cacheAccess().isWrapped()) {
+    if (resource->cacheAccess().isBudgeted()) {
         --fBudgetedCount;
         fBudgetedBytes -= size;
     }
 
     fResources.remove(resource);
     if (!resource->cacheAccess().getScratchKey().isNullScratch()) {
         fScratchMap.remove(resource->cacheAccess().getScratchKey(), resource);
     }
     if (const GrResourceKey* contentKey = resource->cacheAccess().getContentKey()) {
         fContentHash.remove(*contentKey);
@@ skipping 38 matching lines @@
 }
 
 class GrResourceCache2::AvailableForScratchUse {
 public:
     AvailableForScratchUse(bool rejectPendingIO) : fRejectPendingIO(rejectPendingIO) { }
 
     bool operator()(const GrGpuResource* resource) const {
         if (!resource->reffedOnlyByCache() || !resource->cacheAccess().isScratch()) {
             return false;
         }
-
         return !fRejectPendingIO || !resource->internalHasPendingIO();
     }
 
 private:
     bool fRejectPendingIO;
 };
 
 GrGpuResource* GrResourceCache2::findAndRefScratchResource(const GrResourceKey& scratchKey,
                                                            uint32_t flags) {
     AutoValidate av(this);
@@ skipping 93 matching lines @@
 
 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;
 
     fBytes += delta;
     SkDEBUGCODE(fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes));
-    if (!resource->cacheAccess().isWrapped()) {
+    if (resource->cacheAccess().isBudgeted()) {
         fBudgetedBytes += delta;
         SkDEBUGCODE(fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes));
     }
 
     this->purgeAsNeeded();
     this->validate();
 }
 
+void GrResourceCache2::didChangeBudgetStatus(GrGpuResource* resource) {
+    SkASSERT(!fPurging);
+    SkASSERT(resource);
+    SkASSERT(this->isInCache(resource));
+
+    size_t size = resource->gpuMemorySize();
+
+    if (resource->cacheAccess().isBudgeted()) {
+        ++fBudgetedCount;
+        fBudgetedBytes += size;
+        this->purgeAsNeeded();
+    } else {
+        --fBudgetedCount;
+        fBudgetedBytes -= size;
+    }
+
+    this->validate();
+}
+
+
 void GrResourceCache2::internalPurgeAsNeeded() {
     SkASSERT(!fPurging);
     SkASSERT(!fNewlyPurgableResourceWhilePurging);
     SkASSERT(fBudgetedCount > fMaxCount || fBudgetedBytes > fMaxBytes);
 
     fPurging = true;
 
     AutoValidate av(this); // Put this after setting fPurging so we're allowed to be over budget.
 
     bool overBudget = true;
@@ skipping 86 matching lines @@
             SkASSERT(fScratchMap.countForKey(resource->cacheAccess().getScratchKey()));
             SkASSERT(!resource->cacheAccess().isWrapped());
         }
 
         if (const GrResourceKey* contentKey = resource->cacheAccess().getContentKey()) {
             ++content;
             SkASSERT(fContentHash.find(*contentKey) == resource);
             SkASSERT(!resource->cacheAccess().isWrapped());
         }
 
-        if (!resource->cacheAccess().isWrapped()) {
+        if (resource->cacheAccess().isBudgeted()) {
             ++budgetedCount;
             budgetedBytes += resource->gpuMemorySize();
         }
     }
 
     SkASSERT(fBudgetedCount <= fCount);
     SkASSERT(fBudgetedBytes <= fBudgetedBytes);
     SkASSERT(bytes == fBytes);
     SkASSERT(count == fCount);
     SkASSERT(budgetedBytes == fBudgetedBytes);
@@ skipping 13 matching lines @@
     SkASSERT(!overBudget || locked == count || fPurging);
 }
 #endif
 
 #if GR_CACHE_STATS
 void GrResourceCache2::printStats() const {
     this->validate();
 
     int locked = 0;
     int scratch = 0;
+    int wrapped = 0;
 
     ResourceList::Iter iter;
     GrGpuResource* resource = iter.init(fResources, ResourceList::Iter::kHead_IterStart);
 
     for ( ; resource; resource = iter.next()) {
         if (!resource->isPurgable()) {
             ++locked;
         }
         if (resource->cacheAccess().isScratch()) {
             ++scratch;
         }
+        if (resource->cacheAccess().isWrapped()) {
+            ++wrapped;
+        }
     }
 
     float countUtilization = (100.f * fBudgetedCount) / fMaxCount;
     float byteUtilization = (100.f * fBudgetedBytes) / fMaxBytes;
 
     SkDebugf("Budget: %d items %d bytes\n", fMaxCount, fMaxBytes);
     SkDebugf(
-        "\t\tEntry Count: current %d (%d budgeted, %d locked, %d scratch %.2g%% full), high %d\n",
-        fCount, fBudgetedCount, locked, scratch, countUtilization, fHighWaterCount);
+        "\t\tEntry Count: current %d (%d budgeted, %d wrapped, %d locked, %d scratch %.2g%% full), high %d\n",

[egdaniel, 2014/11/13 20:47:32]

over 100, but not the easiest to make look nice...

[bsalomon, 2014/11/13 20:53:34]

wrapped

+        fCount, fBudgetedCount, wrapped, locked, scratch, countUtilization, fHighWaterCount);
     SkDebugf("\t\tEntry Bytes: current %d (budgeted %d, %.2g%% full) high %d\n",
                 fBytes, fBudgetedBytes, byteUtilization, fHighWaterBytes);
 }
 
 #endif