Add a simpler key type for scratch resource keys.

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"
 #include "GrGpuResource.h"  
 
+#include "SkChecksum.h"
 #include "SkGr.h"
 #include "SkMessageBus.h"
 
 DECLARE_SKMESSAGEBUS_MESSAGE(GrResourceInvalidatedMessage);
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrResourceKey& GrResourceKey::NullScratchKey() {
-    static const GrCacheID::Key kBogusKey = { { {0} } };
-    static GrCacheID kBogusID(ScratchDomain(), kBogusKey);
-    static GrResourceKey kNullScratchKey(kBogusID, NoneResourceType(), 0);
-    return kNullScratchKey;
-}
+GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() {
+    static int32_t gType = kInvalidResourceType + 1;
 
-GrResourceKey::ResourceType GrResourceKey::NoneResourceType() {
-    static const ResourceType gNoneResourceType = GenerateResourceType();
-    return gNoneResourceType;
-}
-
-GrCacheID::Domain GrResourceKey::ScratchDomain() {
-    static const GrCacheID::Domain gDomain = GrCacheID::GenerateDomain();
-    return gDomain;
-}
-
-GrResourceKey::ResourceType GrResourceKey::GenerateResourceType() {
-    static int32_t gNextType = 0;
-
-    int32_t type = sk_atomic_inc(&gNextType);
-    if (type >= (1 << 8 * sizeof(ResourceType))) {
+    int32_t type = sk_atomic_inc(&gType);
+    if (kInvalidResourceType == type) {
         SkFAIL("Too many Resource Types");
     }
 
     return static_cast<ResourceType>(type);
 }
 
+
+void GrScratchKey::Builder::finish() {
+    if (NULL == fKey) {
+        return;
+    }
+    GR_STATIC_ASSERT(0 == kHash_MetaDataIdx);
+    fKey->fKey[kHash_MetaDataIdx] = 
+        SkChecksum::Compute(&fKey->fKey[kHash_MetaDataIdx + 1], fKey->size() - sizeof(uint32_t));
+    fKey = NULL;
+}
+
 //////////////////////////////////////////////////////////////////////////////
 
 class GrResourceCache2::AutoValidate : ::SkNoncopyable {
 public:
     AutoValidate(GrResourceCache2* cache) : fCache(cache) { cache->validate(); }
     ~AutoValidate() { fCache->validate(); }
 private:
     GrResourceCache2* fCache;
 };
 
@@ skipping 46 matching lines @@
     fHighWaterBytes = SkTMax(fBytes, fHighWaterBytes);
 #endif
     if (resource->cacheAccess().isBudgeted()) {
         ++fBudgetedCount;
         fBudgetedBytes += size;
 #if GR_CACHE_STATS
         fBudgetedHighWaterCount = SkTMax(fBudgetedCount, fBudgetedHighWaterCount);
         fBudgetedHighWaterBytes = SkTMax(fBudgetedBytes, fBudgetedHighWaterBytes);
 #endif
     }
-    if (!resource->cacheAccess().getScratchKey().isNullScratch()) {
+    if (resource->cacheAccess().getScratchKey().isValid()) {
         SkASSERT(!resource->cacheAccess().isWrapped());
         fScratchMap.insert(resource->cacheAccess().getScratchKey(), resource);
     }
     
     this->purgeAsNeeded();
 }
 
 void GrResourceCache2::removeResource(GrGpuResource* resource) {
     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()) {
+    if (resource->cacheAccess().getScratchKey().isValid()) {
         fScratchMap.remove(resource->cacheAccess().getScratchKey(), resource);
     }
     if (const GrResourceKey* contentKey = resource->cacheAccess().getContentKey()) {
         fContentHash.remove(*contentKey);
     }
     this->validate();
 }
 
 void GrResourceCache2::abandonAll() {
     AutoValidate av(this);
@@ skipping 38 matching lines @@
         if (resource->internalHasRef() || !resource->cacheAccess().isScratch()) {
             return false;
         }
         return !fRejectPendingIO || !resource->internalHasPendingIO();
     }
 
 private:
     bool fRejectPendingIO;
 };
 
-GrGpuResource* GrResourceCache2::findAndRefScratchResource(const GrResourceKey& scratchKey,
+GrGpuResource* GrResourceCache2::findAndRefScratchResource(const GrScratchKey& scratchKey,
                                                            uint32_t flags) {
     SkASSERT(!fPurging);
-    SkASSERT(scratchKey.isScratch());
+    SkASSERT(scratchKey.isValid());
 
     GrGpuResource* resource;
     if (flags & (kPreferNoPendingIO_ScratchFlag | kRequireNoPendingIO_ScratchFlag)) {
         resource = fScratchMap.find(scratchKey, AvailableForScratchUse(true));
         if (resource) {
             resource->ref();
             this->makeResourceMRU(resource);
             this->validate();
             return resource;
         } else if (flags & kRequireNoPendingIO_ScratchFlag) {
@@ skipping 14 matching lines @@
 void GrResourceCache2::willRemoveScratchKey(const GrGpuResource* resource) {
     SkASSERT(resource->cacheAccess().isScratch());
     fScratchMap.remove(resource->cacheAccess().getScratchKey(), 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;
 }
@@ skipping 165 matching lines @@
 
         if (!resource->isPurgable()) {
             ++locked;
         }
 
         if (resource->cacheAccess().isScratch()) {
             SkASSERT(NULL == resource->cacheAccess().getContentKey());
             ++scratch;
             SkASSERT(fScratchMap.countForKey(resource->cacheAccess().getScratchKey()));
             SkASSERT(!resource->cacheAccess().isWrapped());
-        } else if (!resource->cacheAccess().getScratchKey().isNullScratch()) {
+        } else if (resource->cacheAccess().getScratchKey().isValid()) {
             SkASSERT(NULL != resource->cacheAccess().getContentKey());
             ++couldBeScratch;
             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());
@@ skipping 61 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