Speed up GrResourceCache add and lookup by using TDynamicHash

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.
  */
 
 
 
@@ skipping 60 matching lines @@
 GrResourceCache::~GrResourceCache() {
     GrAutoResourceCacheValidate atcv(this);
 
     EntryList::Iter iter;
 
     // Unlike the removeAll, here we really remove everything, including locked resources.
     while (GrResourceEntry* entry = fList.head()) {
         GrAutoResourceCacheValidate atcv(this);
 
         // remove from our cache
-        fCache.remove(entry->fKey, entry);
+        fCache.remove(entry);
 
         // remove from our llist
         this->internalDetach(entry);
 
         delete entry;
     }
 }
 
 void GrResourceCache::getLimits(int* maxResources, size_t* maxResourceBytes) const{
     if (NULL != maxResources) {
@@ skipping 110 matching lines @@
     SkASSERT(NULL == resource->getCacheEntry());
     // 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);
 
     GrResourceEntry* entry = SkNEW_ARGS(GrResourceEntry, (key, resource));
     resource->setCacheEntry(entry);
-
     this->attachToHead(entry);
-    fCache.insert(key, entry);
+    fCache.add(entry);
 
     if (ownershipFlags & kHide_OwnershipFlag) {
         this->makeExclusive(entry);
     }
 
 }
 
 void GrResourceCache::makeExclusive(GrResourceEntry* entry) {
     GrAutoResourceCacheValidate atcv(this);
-
     // When scratch textures are detached (to hide them from future finds) they
     // still count against the resource budget
     this->internalDetach(entry, kIgnore_BudgetBehavior);
-    fCache.remove(entry->key(), entry);
+    fCache.remove(entry);
 
 #ifdef SK_DEBUG
     fExclusiveList.addToHead(entry);
 #endif
 }
 
 void GrResourceCache::removeInvalidResource(GrResourceEntry* entry) {
     // If the resource went invalid while it was detached then purge it
     // This can happen when a 3D context was lost,
     // the client called GrContext::contextDestroyed() to notify Gr,
@@ skipping 11 matching lines @@
 
 #ifdef SK_DEBUG
     fExclusiveList.remove(entry);
 #endif
 
     if (entry->resource()->isValid()) {
         // Since scratch textures still count against the cache budget even
         // when they have been removed from the cache, re-adding them doesn't
         // alter the budget information.
         attachToHead(entry, kIgnore_BudgetBehavior);
-        fCache.insert(entry->key(), entry);
+        fCache.add(entry);
     } else {
         this->removeInvalidResource(entry);
     }
 }
 
 /**
  * Destroying a resource may potentially trigger the unlock of additional
  * resources which in turn will trigger a nested purge. We block the nested
  * purge using the fPurging variable. However, the initial purge will keep
  * looping until either all resources in the cache are unlocked or we've met
@@ skipping 43 matching lines @@
         // now, these resources are just LRU'd as if we never got the message.
         GrResourceEntry* entry = fCache.find(invalidated[i].key, GrTFindUnreffedFunctor());
         if (entry) {
             this->deleteResource(entry);
         }
     }
 }
 
 void GrResourceCache::deleteResource(GrResourceEntry* entry) {
     SkASSERT(1 == entry->fResource->getRefCnt());
-
     // remove from our cache
-    fCache.remove(entry->key(), entry);
+    fCache.remove(entry);
 
     // remove from our llist
     this->internalDetach(entry);
     delete entry;
 }
 
 void GrResourceCache::internalPurge(int extraCount, size_t extraBytes) {
     SkASSERT(fPurging);
 
     bool withinBudget = false;
@@ skipping 84 matching lines @@
 
 void GrResourceCache::validate() const {
     fList.validate();
     fExclusiveList.validate();
     SkASSERT(both_zero_or_nonzero(fEntryCount, fEntryBytes));
     SkASSERT(both_zero_or_nonzero(fClientDetachedCount, fClientDetachedBytes));
     SkASSERT(fClientDetachedBytes <= fEntryBytes);
     SkASSERT(fClientDetachedCount <= fEntryCount);
     SkASSERT((fEntryCount - fClientDetachedCount) == fCache.count());
 
-    fCache.validate();
-
-
     EntryList::Iter iter;
 
     // check that the exclusively held entries are okay
     const GrResourceEntry* entry = iter.init(const_cast<EntryList&>(fExclusiveList),
                                              EntryList::Iter::kHead_IterStart);
 
     for ( ; NULL != entry; entry = iter.next()) {
         entry->validate();
     }
 
@@ skipping 42 matching lines @@
                 fEntryBytes, fHighWaterEntryBytes);
     SkDebugf("\t\tDetached Entry Count: current %d high %d\n",
                 fClientDetachedCount, fHighWaterClientDetachedCount);
     SkDebugf("\t\tDetached Bytes: current %d high %d\n",
                 fClientDetachedBytes, fHighWaterClientDetachedBytes);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////