Remove GrResourceKey from GrResourceCache

src/gpu/GrResourceCache.cpp

 
 /*
  * Copyright 2010 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 "GrGpuResource.h"
@@ skipping 17 matching lines @@
     int32_t type = sk_atomic_inc(&gNextType);
     if (type >= (1 << 8 * sizeof(ResourceType))) {
         SkFAIL("Too many Resource Types");
     }
 
     return static_cast<ResourceType>(type);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrResourceCacheEntry::GrResourceCacheEntry(GrResourceCache* resourceCache,
-                                           const GrResourceKey& key,
-                                           GrGpuResource* resource)
+GrResourceCacheEntry::GrResourceCacheEntry(GrResourceCache* resourceCache, GrGpuResource* resource)
         : fResourceCache(resourceCache),
-          fKey(key),
           fResource(resource),
-          fCachedSize(resource->gpuMemorySize()),
-          fIsExclusive(false) {
+          fCachedSize(resource->gpuMemorySize()) {
     // we assume ownership of the resource, and will unref it when we die
     SkASSERT(resource);
     resource->ref();
 }
 
 GrResourceCacheEntry::~GrResourceCacheEntry() {
     // We're relying on having the cache entry to remove this from GrResourceCache2's content hash.
     // fResource->setCacheEntry(NULL);
     fResource->unref();
 }
@@ skipping 40 matching lines @@
 
 GrResourceCache::~GrResourceCache() {
     GrAutoResourceCacheValidate atcv(this);
 
     EntryList::Iter iter;
 
     // Unlike the removeAll, here we really remove everything, including locked resources.
     while (GrResourceCacheEntry* entry = fList.head()) {
         GrAutoResourceCacheValidate atcv(this);
 
-        // remove from our cache
-        fCache.remove(entry->fKey, entry);
-
         // remove from our llist
         this->internalDetach(entry);
 
         delete entry;
     }
 }
 
 void GrResourceCache::getLimits(int* maxResources, size_t* maxResourceBytes) const{
     if (maxResources) {
         *maxResources = fMaxCount;
@@ skipping 29 matching lines @@
 #if GR_CACHE_STATS
     if (fHighWaterEntryCount < fEntryCount) {
         fHighWaterEntryCount = fEntryCount;
     }
     if (fHighWaterEntryBytes < fEntryBytes) {
         fHighWaterEntryBytes = fEntryBytes;
     }
 #endif
 }
 
-// This functor just searches for an entry with only a single ref (from
-// the texture cache itself). Presumably in this situation no one else
-// is relying on the texture.
-class GrTFindUnreffedFunctor {
-public:
-    bool operator()(const GrResourceCacheEntry* entry) const {
-        return entry->resource()->isPurgable();
-    }
-};
-
 
 void GrResourceCache::makeResourceMRU(GrGpuResource* resource) {
     GrResourceCacheEntry* entry = resource->getCacheEntry();
     if (entry) {
         this->internalDetach(entry);
         this->attachToHead(entry);
     }
 }
 
 void GrResourceCache::notifyPurgable(const GrGpuResource* resource) {
     // Remove scratch textures from the cache the moment they become purgeable if
     // scratch texture reuse is turned off.
     SkASSERT(resource->getCacheEntry());
-    if (resource->getCacheEntry()->key().getResourceType() == GrTexturePriv::ResourceType() &&
-        resource->getCacheEntry()->key().isScratch() &&
-        !fCaps->reuseScratchTextures() &&
-        !(static_cast<const GrSurface*>(resource)->desc().fFlags & kRenderTarget_GrSurfaceFlag)) {
-        this->deleteResource(resource->getCacheEntry());
+    if (resource->isScratch()) {
+        const GrResourceKey& key = resource->getScratchKey();
+        if (key.getResourceType() == GrTexturePriv::ResourceType() &&
+            !fCaps->reuseScratchTextures() &&
+            !(static_cast<const GrSurface*>(resource)->desc().fFlags & kRenderTarget_GrSurfaceFlag)) {
+            this->deleteResource(resource->getCacheEntry());
+        }
     }
 }
 
 bool GrResourceCache::addResource(const GrResourceKey& key, GrGpuResource* resource) {
     if (NULL != resource->getCacheEntry()) {
         return false;
     }
+    
+    if (key.isScratch()) {
+        SkASSERT(resource->isScratch() && key == resource->getScratchKey());
+    } else {
+        if (!resource->setContentKey(key)) {
+            return false;
+        }
+    }
 
     // we don't expect to create new resources during a purge. In theory
     // this could cause purgeAsNeeded() into an infinite loop (e.g.
     // each resource destroyed creates and locks 2 resources and
     // unlocks 1 thereby causing a new purge).
     SkASSERT(!fPurging);
     GrAutoResourceCacheValidate atcv(this);
 
-    GrResourceCacheEntry* entry = SkNEW_ARGS(GrResourceCacheEntry, (this, key, resource));
-    if (!resource->setCacheEntry(entry)) {
-        SkDELETE(entry);
-        this->purgeAsNeeded();
-        return false;
-    }
+    GrResourceCacheEntry* entry = SkNEW_ARGS(GrResourceCacheEntry, (this, resource));
+    resource->setCacheEntry(entry);
 
     this->attachToHead(entry);
-    fCache.insert(key, entry);
     this->purgeAsNeeded();
     return true;
 }
 
 void GrResourceCache::didIncreaseResourceSize(const GrResourceCacheEntry* entry, size_t amountInc) {
     fEntryBytes += amountInc;
     this->purgeAsNeeded();
 }
 
 void GrResourceCache::didDecreaseResourceSize(const GrResourceCacheEntry* entry, size_t amountDec) {
@@ skipping 17 matching lines @@
  * for incoming resources (e.g., GrContext is about to add 10MB split between
  * 10 textures).
  */
 void GrResourceCache::purgeAsNeeded(int extraCount, size_t extraBytes) {
     if (fPurging) {
         return;
     }
 
     fPurging = true;
 
-    this->purgeInvalidated();
-
     this->internalPurge(extraCount, extraBytes);
     if (((fEntryCount+extraCount) > fMaxCount ||
         (fEntryBytes+extraBytes) > fMaxBytes) &&
         fOverbudgetCB) {
         // Despite the purge we're still over budget. See if Ganesh can
         // release some resources and purge again.
         if ((*fOverbudgetCB)(fOverbudgetData)) {
             this->internalPurge(extraCount, extraBytes);
         }
     }
 
     fPurging = false;
 }
 
 void GrResourceCache::purgeInvalidated() {
-    SkTDArray<GrResourceInvalidatedMessage> invalidated;
-    fInvalidationInbox.poll(&invalidated);
-
-    for (int i = 0; i < invalidated.count(); i++) {
-        while (GrResourceCacheEntry* entry = fCache.find(invalidated[i].key, GrTFindUnreffedFunctor())) {
-            this->deleteResource(entry);
-        }
-    }
+    // TODO: Implement this in GrResourceCache2.

[bsalomon, 2014/11/10 18:38:51]

I won't land this until there is a follow up CL ready that does this. The CLs
were getting big enough that I thought it made sense to break them up.

 }
 
 void GrResourceCache::deleteResource(GrResourceCacheEntry* entry) {
     SkASSERT(entry->fResource->isPurgable());
-
-    // remove from our cache
-    fCache.remove(entry->key(), entry);
-
     // remove from our llist
     this->internalDetach(entry);
     delete entry;
 }
 
 void GrResourceCache::internalPurge(int extraCount, size_t extraBytes) {
     SkASSERT(fPurging);
 
     bool withinBudget = false;
     bool changed = false;
@@ skipping 36 matching lines @@
     // we can have one GrCacheable holding a lock on another
     // so we don't want to just do a simple loop kicking each
     // entry out. Instead change the budget and purge.
 
     size_t savedMaxBytes = fMaxBytes;
     int savedMaxCount = fMaxCount;
     fMaxBytes = (size_t) -1;
     fMaxCount = 0;
     this->purgeAsNeeded();
 
-#ifdef SK_DEBUG
-    if (!fCache.count()) {
-        SkASSERT(fList.isEmpty());
-    }
-#endif
-
     fMaxBytes = savedMaxBytes;
     fMaxCount = savedMaxCount;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 size_t GrResourceCache::countBytes(const EntryList& list) {
     size_t bytes = 0;
 
     EntryList::Iter iter;
 
     const GrResourceCacheEntry* entry = iter.init(const_cast<EntryList&>(list),
                                                   EntryList::Iter::kTail_IterStart);
 
     for ( ; entry; entry = iter.prev()) {
         bytes += entry->resource()->gpuMemorySize();
     }
     return bytes;
 }
 
 static bool both_zero_or_nonzero(int count, size_t bytes) {
     return (count == 0 && bytes == 0) || (count > 0 && bytes > 0);
 }
 
 void GrResourceCache::validate() const {
     fList.validate();
     SkASSERT(both_zero_or_nonzero(fEntryCount, fEntryBytes));
-    SkASSERT(fEntryCount == fCache.count());
 
     EntryList::Iter iter;
 
     // check that the shareable entries are okay
     const GrResourceCacheEntry* entry = iter.init(const_cast<EntryList&>(fList),
                                                   EntryList::Iter::kHead_IterStart);
 
     int count = 0;
     for ( ; entry; entry = iter.next()) {
         entry->validate();
-        SkASSERT(fCache.find(entry->key()));
         count += 1;
     }
     SkASSERT(count == fEntryCount);
 
     size_t bytes = this->countBytes(fList);
     SkASSERT(bytes == fEntryBytes);
     SkASSERT(fList.countEntries() == fEntryCount);
 }
 #endif // SK_DEBUG
 
@@ skipping 22 matching lines @@
     SkDebugf("Budget: %d items %d bytes\n", fMaxCount, fMaxBytes);
     SkDebugf("\t\tEntry Count: current %d (%d locked, %d scratch %.2g%% full), high %d\n",
                 fEntryCount, locked, scratch, countUtilization, fHighWaterEntryCount);
     SkDebugf("\t\tEntry Bytes: current %d (%.2g%% full) high %d\n",
                 fEntryBytes, byteUtilization, fHighWaterEntryBytes);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////