skia: Add tracing for skia's budget

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"
 #include "GrGpuResourceCacheAccess.h"
+#include "GrTracing.h"
 #include "SkChecksum.h"
 #include "SkGr.h"
 #include "SkMessageBus.h"
 #include "SkTSort.h"
 
 DECLARE_SKMESSAGEBUS_MESSAGE(GrUniqueKeyInvalidatedMessage);
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() {
@@ skipping 72 matching lines @@
 
     // 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());
 
     this->addToNonpurgeableArray(resource);
 
     size_t size = resource->gpuMemorySize();
     SkDEBUGCODE(++fCount;)
     fBytes += size;
+
+//    TRACE_COUNTER2(TRACE_DISABLED_BY_DEFAULT("skia.gpu.cache"), "fBytes", fBytes);

[bsalomon, 2015/03/04 18:08:27]

what's with this?

+
 #if GR_CACHE_STATS
     fHighWaterCount = SkTMax(this->getResourceCount(), fHighWaterCount);
     fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes);
 #endif
     if (resource->resourcePriv().isBudgeted()) {
         ++fBudgetedCount;
         fBudgetedBytes += size;
+        TRACE_COUNTER2(TRACE_DISABLED_BY_DEFAULT("skia.gpu.cache"), "skia budget", "used",
+                       fBudgetedBytes, "free", fMaxBytes - fBudgetedBytes);
 #if GR_CACHE_STATS
         fBudgetedHighWaterCount = SkTMax(fBudgetedCount, fBudgetedHighWaterCount);
         fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes);
 #endif
     }
     if (resource->resourcePriv().getScratchKey().isValid()) {
         SkASSERT(!resource->cacheAccess().isWrapped());
         fScratchMap.insert(resource->resourcePriv().getScratchKey(), resource);
     }
 
     this->purgeAsNeeded();
 }
 
 void GrResourceCache::removeResource(GrGpuResource* resource) {
     this->validate();
     SkASSERT(this->isInCache(resource));
 
     if (resource->isPurgeable()) {
         fPurgeableQueue.remove(resource);
     } else {
         this->removeFromNonpurgeableArray(resource);
     }
 
     size_t size = resource->gpuMemorySize();
     SkDEBUGCODE(--fCount;)
     fBytes -= size;
     if (resource->resourcePriv().isBudgeted()) {
         --fBudgetedCount;
         fBudgetedBytes -= size;
+        TRACE_COUNTER2(TRACE_DISABLED_BY_DEFAULT("skia.gpu.cache"), "skia budget", "used",
+                       fBudgetedBytes, "free", fMaxBytes - fBudgetedBytes);
     }
 
     if (resource->resourcePriv().getScratchKey().isValid()) {
         fScratchMap.remove(resource->resourcePriv().getScratchKey(), resource);
     }
     if (resource->getUniqueKey().isValid()) {
         fUniqueHash.remove(resource->getUniqueKey());
     }
     this->validate();
 }
@@ skipping 194 matching lines @@
     SkASSERT(this->isInCache(resource));
 
     ptrdiff_t delta = resource->gpuMemorySize() - oldSize;
 
     fBytes += delta;
 #if GR_CACHE_STATS
     fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes);
 #endif
     if (resource->resourcePriv().isBudgeted()) {
         fBudgetedBytes += delta;
+        TRACE_COUNTER2(TRACE_DISABLED_BY_DEFAULT("skia.gpu.cache"), "skia budget", "used",
+                       fBudgetedBytes, "free", fMaxBytes - fBudgetedBytes);
 #if GR_CACHE_STATS
         fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes);
 #endif
     }
 
     this->purgeAsNeeded();
     this->validate();
 }
 
 void GrResourceCache::didChangeBudgetStatus(GrGpuResource* resource) {
     SkASSERT(resource);
     SkASSERT(this->isInCache(resource));
 
     size_t size = resource->gpuMemorySize();
 
     if (resource->resourcePriv().isBudgeted()) {
         ++fBudgetedCount;
         fBudgetedBytes += size;
 #if GR_CACHE_STATS
         fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes);
         fBudgetedHighWaterCount = SkTMax(fBudgetedCount, fBudgetedHighWaterCount);
 #endif
         this->purgeAsNeeded();
     } else {
         --fBudgetedCount;
         fBudgetedBytes -= size;
     }
+    TRACE_COUNTER2(TRACE_DISABLED_BY_DEFAULT("skia.gpu.cache"), "skia budget", "used",
+                   fBudgetedBytes, "free", fMaxBytes - fBudgetedBytes);
 
     this->validate();
 }
 
 void GrResourceCache::internalPurgeAsNeeded() {
     SkASSERT(this->overBudget());
 
     bool stillOverbudget = true;
     while (fPurgeableQueue.count()) {
         GrGpuResource* resource = fPurgeableQueue.peek();
@@ skipping 230 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