GrResourceCache2 manages scratch texture.

src/gpu/GrResourceCache.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-
-
 #ifndef GrResourceCache_DEFINED
 #define GrResourceCache_DEFINED
 
+#include "GrDrawTargetCaps.h"
 #include "GrResourceKey.h"
 #include "SkTMultiMap.h"
 #include "SkMessageBus.h"
 #include "SkTInternalLList.h"
 
 class GrGpuResource;
 class GrResourceCache;
 class GrResourceCacheEntry;
 
 
@@ skipping 57 matching lines @@
  *  list backwards from the tail, since those are the least recently used.
  *
  *  For fast searches, we maintain a hash map based on the GrResourceKey.
  *
  *  It is a goal to make the GrResourceCache the central repository and bookkeeper
  *  of all resources. It should replace the linked list of GrGpuResources that
  *  GrGpu uses to call abandon/release.
  */
 class GrResourceCache {
 public:
-    GrResourceCache(int maxCount, size_t maxBytes);
+    GrResourceCache(const GrDrawTargetCaps*, int maxCount, size_t maxBytes);
     ~GrResourceCache();
 
     /**
      *  Return the current resource cache limits.
      *
      *  @param maxResource If non-null, returns maximum number of resources
      *                     that can be held in the cache.
      *  @param maxBytes    If non-null, returns maximum number of bytes of
      *                     gpu memory that can be held in the cache.
      */
@@ skipping 32 matching lines @@
     /**
      * Returns the number of bytes consumed by cached resources.
      */
     size_t getCachedResourceBytes() const { return fEntryBytes; }
 
     /**
      * Returns the number of cached resources.
      */
     int getCachedResourceCount() const { return fEntryCount; }
 
-    // For a found or added resource to be completely exclusive to the caller
-    // both the kNoOtherOwners and kHide flags need to be specified
-    enum OwnershipFlags {
-        kNoOtherOwners_OwnershipFlag = 0x1, // found/added resource has no other owners
-        kHide_OwnershipFlag = 0x2  // found/added resource is hidden from future 'find's
-    };
-
     /**
      *  Search for an entry with the same Key. If found, return it.
      *  If not found, return null.
-     *  If ownershipFlags includes kNoOtherOwners and a resource is returned
-     *  then that resource has no other refs to it.
-     *  If ownershipFlags includes kHide and a resource is returned then that
-     *  resource will not be returned from future 'find' calls until it is
-     *  'freed' (and recycled) or makeNonExclusive is called.
-     *  For a resource to be completely exclusive to a caller both kNoOtherOwners
-     *  and kHide must be specified.
      */
-    GrGpuResource* find(const GrResourceKey& key,
-                        uint32_t ownershipFlags = 0);
+    GrGpuResource* find(const GrResourceKey& key);
+
+    void makeResourceMRU(GrGpuResource*);
+
+    /** Called by GrGpuResources when they detects that they are newly purgable. */
+    void notifyPurgable(const GrGpuResource*);
 
     /**
      *  Add the new resource to the cache (by creating a new cache entry based
      *  on the provided key and resource).
      *
      *  Ownership of the resource is transferred to the resource cache,
      *  which will unref() it when it is purged or deleted.
-     *
-     *  If ownershipFlags includes kHide, subsequent calls to 'find' will not
-     *  return 'resource' until it is 'freed' (and recycled) or makeNonExclusive
-     *  is called.
      */
-    void addResource(const GrResourceKey& key,
-                     GrGpuResource* resource,
-                     uint32_t ownershipFlags = 0);
+    void addResource(const GrResourceKey& key, GrGpuResource* resource);
 
     /**
      * Determines if the cache contains an entry matching a key. If a matching
      * entry exists but was detached then it will not be found.
      */
     bool hasKey(const GrResourceKey& key) const { return SkToBool(fCache.find(key)); }
 
     /**
-     * Hide 'entry' so that future searches will not find it. Such
-     * hidden entries will not be purged. The entry still counts against
-     * the cache's budget and should be made non-exclusive when exclusive access
-     * is no longer needed.
-     */
-    void makeExclusive(GrResourceCacheEntry* entry);
-
-    /**
-     * Restore 'entry' so that it can be found by future searches. 'entry'
-     * will also be purgeable (provided its lock count is now 0.)
-     */
-    void makeNonExclusive(GrResourceCacheEntry* entry);
-
-    /**
      * Notify the cache that the size of a resource has changed.
      */
     void didIncreaseResourceSize(const GrResourceCacheEntry*, size_t amountInc);
     void didDecreaseResourceSize(const GrResourceCacheEntry*, size_t amountDec);
 
     /**
      * Remove a resource from the cache and delete it!
      */
     void deleteResource(GrResourceCacheEntry* entry);
 
@@ skipping 19 matching lines @@
     void validate() const;
 #else
     void validate() const {}
 #endif
 
 #if GR_CACHE_STATS
     void printStats();
 #endif
 
 private:
-    enum BudgetBehaviors {
-        kAccountFor_BudgetBehavior,
-        kIgnore_BudgetBehavior
-    };
+    void internalDetach(GrResourceCacheEntry*);
+    void attachToHead(GrResourceCacheEntry*);
+    void purgeInvalidated();
+    void internalPurge(int extraCount, size_t extraBytes);
+#ifdef SK_DEBUG
+    static size_t countBytes(const SkTInternalLList<GrResourceCacheEntry>& list);
+#endif
 
-    void internalDetach(GrResourceCacheEntry*, BudgetBehaviors behavior = kAccountFor_BudgetBehavior);
-    void attachToHead(GrResourceCacheEntry*, BudgetBehaviors behavior = kAccountFor_BudgetBehavior);
-
-    void removeInvalidResource(GrResourceCacheEntry* entry);
-
-    SkTMultiMap<GrResourceCacheEntry, GrResourceKey> fCache;
+    typedef SkTMultiMap<GrResourceCacheEntry, GrResourceKey> CacheMap;
+    CacheMap                                fCache;
 
     // We're an internal doubly linked list
     typedef SkTInternalLList<GrResourceCacheEntry> EntryList;
-    EntryList      fList;
-
-#ifdef SK_DEBUG
-    // These objects cannot be returned by a search
-    EntryList      fExclusiveList;
-#endif
+    EntryList                               fList;
 
     // our budget, used in purgeAsNeeded()
-    int            fMaxCount;
-    size_t         fMaxBytes;
+    int                                     fMaxCount;
+    size_t                                  fMaxBytes;
 
     // our current stats, related to our budget
 #if GR_CACHE_STATS
-    int            fHighWaterEntryCount;
-    size_t         fHighWaterEntryBytes;
-    int            fHighWaterClientDetachedCount;
-    size_t         fHighWaterClientDetachedBytes;
+    int                                     fHighWaterEntryCount;
+    size_t                                  fHighWaterEntryBytes;
 #endif
 
-    int            fEntryCount;
-    size_t         fEntryBytes;
-    int            fClientDetachedCount;
-    size_t         fClientDetachedBytes;
+    int                                     fEntryCount;
+    size_t                                  fEntryBytes;
 
     // prevents recursive purging
-    bool           fPurging;
+    bool                                    fPurging;
 
-    PFOverbudgetCB fOverbudgetCB;
-    void*          fOverbudgetData;
+    PFOverbudgetCB                          fOverbudgetCB;
+    void*                                   fOverbudgetData;
 
-    void internalPurge(int extraCount, size_t extraBytes);
+    SkAutoTUnref<const GrDrawTargetCaps>    fCaps;
 
     // Listen for messages that a resource has been invalidated and purge cached junk proactively.
-    SkMessageBus<GrResourceInvalidatedMessage>::Inbox fInvalidationInbox;
-    void purgeInvalidated();
-
-#ifdef SK_DEBUG
-    static size_t countBytes(const SkTInternalLList<GrResourceCacheEntry>& list);
-#endif
+   typedef  SkMessageBus<GrResourceInvalidatedMessage>::Inbox Inbox;
+   Inbox                                    fInvalidationInbox;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
     class GrAutoResourceCacheValidate {
     public:
         GrAutoResourceCacheValidate(GrResourceCache* cache) : fCache(cache) {
             cache->validate();
         }
         ~GrAutoResourceCacheValidate() {
             fCache->validate();
         }
     private:
         GrResourceCache* fCache;
     };
 #else
     class GrAutoResourceCacheValidate {
     public:
         GrAutoResourceCacheValidate(GrResourceCache*) {}
     };
 #endif
 
 #endif