Allow the resource cache to (indirectly) flush the InOrderDrawBuffer

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 44 matching lines @@
     fHighWaterEntryBytes          = 0;
     fHighWaterClientDetachedCount = 0;
     fHighWaterClientDetachedBytes = 0;
 #endif
 
     fEntryCount                   = 0;
     fEntryBytes                   = 0;
     fClientDetachedCount          = 0;
     fClientDetachedBytes          = 0;
 
-    fPurging = false;
+    fPurging                      = false;
+
+    fOverbudgetCB                 = NULL;
+    fOverbudgetData               = NULL;
 }
 
 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);
@@ skipping 192 matching lines @@
  * 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
  * the budget. There is an assertion in createAndLock to check against a
  * resource's destructor inserting new resources into the cache. If these
  * new resources were unlocked before purgeAsNeeded completed it could
  * potentially make purgeAsNeeded loop infinitely.
  */
 void GrResourceCache::purgeAsNeeded() {
-    if (!fPurging) {
-        fPurging = true;
-        bool withinBudget = false;
-        bool changed = false;
+    if (fPurging) {
+        return;
+    }
 
-        // The purging process is repeated several times since one pass
-        // may free up other resources
-        do {
-            EntryList::Iter iter;
+    fPurging = true;
 
-            changed = false;
+    this->internalPurge();
+    if ((fEntryCount > fMaxCount || fEntryBytes > fMaxBytes) &&
+        NULL != fOverbudgetCB) {
+        // Despite the purge we're still over budget. See if Ganesh can
+        // release some resources and purge again.
+        (*fOverbudgetCB)(fOverbudgetData);
+        this->internalPurge();
+    }
 
-            // Note: the following code relies on the fact that the
-            // doubly linked list doesn't invalidate its data/pointers
-            // outside of the specific area where a deletion occurs (e.g.,
-            // in internalDetach)
-            GrResourceEntry* entry = iter.init(fList, EntryList::Iter::kTail_IterStart);
+    fPurging = false;
+}
 
-            while (NULL != entry) {
-                GrAutoResourceCacheValidate atcv(this);
+void GrResourceCache::internalPurge() {
+    SkASSERT(fPurging);
 
-                if (fEntryCount <= fMaxCount && fEntryBytes <= fMaxBytes) {
-                    withinBudget = true;
-                    break;
-                }
+    bool withinBudget = false;
+    bool changed = false;
 
-                GrResourceEntry* prev = iter.prev();
-                if (1 == entry->fResource->getRefCnt()) {
-                    changed = true;
+    // The purging process is repeated several times since one pass
+    // may free up other resources
+    do {
+        EntryList::Iter iter;
 
-                    // remove from our cache
-                    fCache.remove(entry->key(), entry);
+        changed = false;
 
-                    // remove from our llist
-                    this->internalDetach(entry);
-                    delete entry;
-                }
-                entry = prev;
+        // Note: the following code relies on the fact that the
+        // doubly linked list doesn't invalidate its data/pointers
+        // outside of the specific area where a deletion occurs (e.g.,
+        // in internalDetach)
+        GrResourceEntry* entry = iter.init(fList, EntryList::Iter::kTail_IterStart);
+
+        while (NULL != entry) {
+            GrAutoResourceCacheValidate atcv(this);
+
+            if (fEntryCount <= fMaxCount && fEntryBytes <= fMaxBytes) {
+                withinBudget = true;
+                break;
             }
-        } while (!withinBudget && changed);
-        fPurging = false;
-    }
+
+            GrResourceEntry* prev = iter.prev();
+            if (1 == entry->fResource->getRefCnt()) {
+                changed = true;
+
+                // remove from our cache
+                fCache.remove(entry->key(), entry);
+
+                // remove from our llist
+                this->internalDetach(entry);
+                delete entry;
+            }
+            entry = prev;
+        }
+    } while (!withinBudget && changed);
 }
 
 void GrResourceCache::purgeAllUnlocked() {
     GrAutoResourceCacheValidate atcv(this);
 
     // we can have one GrResource 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.
 
     int savedMaxBytes = fMaxBytes;
@@ skipping 107 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
 
 ///////////////////////////////////////////////////////////////////////////////