Reduce the amount of validation in GrResourceCache2

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 72 matching lines @@
     this->releaseAll();
 }
 
 void GrResourceCache2::setLimits(int count, size_t bytes) {
     fMaxCount = count;
     fMaxBytes = bytes;
     this->purgeAsNeeded();
 }
 
 void GrResourceCache2::insertResource(GrGpuResource* resource) {
-    AutoValidate av(this);
-
     SkASSERT(resource);
     SkASSERT(!resource->wasDestroyed());
     SkASSERT(!this->isInCache(resource));
     SkASSERT(!fPurging);
     fResources.addToHead(resource);
 
     size_t size = resource->gpuMemorySize();
     ++fCount;
     fBytes += size;
 #if GR_CACHE_STATS
@@ skipping 10 matching lines @@
     }
     if (!resource->cacheAccess().getScratchKey().isNullScratch()) {
         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().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);
     }
+    this->validate();
 }
 
 void GrResourceCache2::abandonAll() {
     AutoValidate av(this);
 
     SkASSERT(!fPurging);
     while (GrGpuResource* head = fResources.head()) {
         SkASSERT(!head->wasDestroyed());
         head->cacheAccess().abandon();
         // abandon should have already removed this from the list.
@@ skipping 34 matching lines @@
         }
         return !fRejectPendingIO || !resource->internalHasPendingIO();
     }
 
 private:
     bool fRejectPendingIO;
 };
 
 GrGpuResource* GrResourceCache2::findAndRefScratchResource(const GrResourceKey& scratchKey,
                                                            uint32_t flags) {
-    AutoValidate av(this);
-
     SkASSERT(!fPurging);
     SkASSERT(scratchKey.isScratch());
 
     GrGpuResource* resource;
     if (flags & (kPreferNoPendingIO_ScratchFlag | kRequireNoPendingIO_ScratchFlag)) {
         resource = fScratchMap.find(scratchKey, AvailableForScratchUse(true));
         if (resource) {
+            resource->ref();
             this->makeResourceMRU(resource);
-            return SkRef(resource);
+            this->validate();
+            return resource;
         } else if (flags & kRequireNoPendingIO_ScratchFlag) {
             return NULL;
         }
         // TODO: fail here when kPrefer is specified, we didn't find a resource without pending io,
         // but there is still space in our budget for the resource.
     }
     resource = fScratchMap.find(scratchKey, AvailableForScratchUse(false));
     if (resource) {
         resource->ref();
         this->makeResourceMRU(resource);
+        this->validate();
     }
     return resource;
 }
 
 bool GrResourceCache2::didSetContentKey(GrGpuResource* resource) {
     SkASSERT(!fPurging);
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
     SkASSERT(resource->cacheAccess().getContentKey());
     SkASSERT(!resource->cacheAccess().getContentKey()->isScratch());
 
     GrGpuResource* res = fContentHash.find(*resource->cacheAccess().getContentKey());
     if (NULL != res) {
         return false;
     }
 
     fContentHash.add(resource);
     this->validate();
     return true;
 }
 
 void GrResourceCache2::makeResourceMRU(GrGpuResource* resource) {
-    AutoValidate av(this);
-
     SkASSERT(!fPurging);
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
     fResources.remove(resource);    
-    fResources.addToHead(resource);    
+    fResources.addToHead(resource);
 }
 
 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) {
@@ skipping 64 matching lines @@
 }
 
 
 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;
     do {
         fNewlyPurgableResourceWhilePurging = false;
         ResourceList::Iter resourceIter;
         GrGpuResource* resource = resourceIter.init(fResources,
                                                     ResourceList::Iter::kTail_IterStart);
 
         while (resource) {
             GrGpuResource* prev = resourceIter.prev();
             if (resource->isPurgable()) {
                 resource->cacheAccess().release();
             }
             resource = prev;
             if (fBudgetedCount <= fMaxCount && fBudgetedBytes <= fMaxBytes) {
                 overBudget = false;
                 resource = NULL;
             }
         }
 
         if (!fNewlyPurgableResourceWhilePurging && overBudget && fOverBudgetCB) {
             // Despite the purge we're still over budget. Call our over budget callback.
             (*fOverBudgetCB)(fOverBudgetData);
         }
     } while (overBudget && fNewlyPurgableResourceWhilePurging);
 
     fNewlyPurgableResourceWhilePurging = false;
     fPurging = false;
+    this->validate();
 }
 
 void GrResourceCache2::purgeAllUnlocked() {
     SkASSERT(!fPurging);
     SkASSERT(!fNewlyPurgableResourceWhilePurging);
 
     fPurging = true;
 
-    AutoValidate av(this); // Put this after setting fPurging so we're allowed to be over budget.
-
     do {
         fNewlyPurgableResourceWhilePurging = false;
         ResourceList::Iter resourceIter;
         GrGpuResource* resource =
             resourceIter.init(fResources, ResourceList::Iter::kTail_IterStart);
 
         while (resource) {
             GrGpuResource* prev = resourceIter.prev();
             if (resource->isPurgable()) {
                 resource->cacheAccess().release();
             }
             resource = prev;
         }
 
         if (!fNewlyPurgableResourceWhilePurging && fCount && fOverBudgetCB) {
             (*fOverBudgetCB)(fOverBudgetData);
         }
     } while (fNewlyPurgableResourceWhilePurging);
     fPurging = false;
+    this->validate();
 }
 
 #ifdef SK_DEBUG
 void GrResourceCache2::validate() const {
     size_t bytes = 0;
     int count = 0;
     int budgetedCount = 0;
     size_t budgetedBytes = 0;
     int locked = 0;
     int scratch = 0;
@@ skipping 90 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