remove obsolete USE_CACHE_HASH

src/core/SkGlyphCache.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkGlyphCache.h"
 #include "SkGraphics.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkTemplates.h"
 #include "SkTLS.h"
 #include "SkTypeface.h"
 
 //#define SPEW_PURGE_STATUS
-//#define USE_CACHE_HASH
 //#define RECORD_HASH_EFFICIENCY
 
 bool gSkSuppressFontCachePurgeSpew;
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef RECORD_HASH_EFFICIENCY
     static uint32_t gHashSuccess;
     static uint32_t gHashCollision;
 
@@ skipping 365 matching lines @@
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef SK_DEFAULT_FONT_CACHE_LIMIT
     #define SK_DEFAULT_FONT_CACHE_LIMIT     (2 * 1024 * 1024)
 #endif
 
-#ifdef USE_CACHE_HASH
-    #define HASH_BITCOUNT   6
-    #define HASH_COUNT      (1 << HASH_BITCOUNT)
-    #define HASH_MASK       (HASH_COUNT - 1)
-
-    static unsigned desc_to_hashindex(const SkDescriptor* desc)
-    {
-        SkASSERT(HASH_MASK < 256);  // since our munging reduces to 8 bits
-
-        uint32_t n = *(const uint32_t*)desc;    //desc->getChecksum();
-        SkASSERT(n == desc->getChecksum());
-
-        // don't trust that the low bits of checksum vary enough, so...
-        n ^= (n >> 24) ^ (n >> 16) ^ (n >> 8) ^ (n >> 30);
-
-        return n & HASH_MASK;
-    }
-#endif
-
 #include "SkThread.h"
 
 class SkGlyphCache_Globals {
 public:
     enum UseMutex {
         kNo_UseMutex,  // thread-local cache
         kYes_UseMutex  // shared cache
     };
 
     SkGlyphCache_Globals(UseMutex um) {
         fHead = NULL;
         fTotalMemoryUsed = 0;
         fFontCacheLimit = SK_DEFAULT_FONT_CACHE_LIMIT;
         fMutex = (kYes_UseMutex == um) ? SkNEW(SkMutex) : NULL;
-
-#ifdef USE_CACHE_HASH
-        sk_bzero(fHash, sizeof(fHash));
-#endif
     }
 
     ~SkGlyphCache_Globals() {
         SkGlyphCache* cache = fHead;
         while (cache) {
             SkGlyphCache* next = cache->fNext;
             SkDELETE(cache);
             cache = next;
         }
 
         SkDELETE(fMutex);
     }
 
     SkMutex*        fMutex;
     SkGlyphCache*   fHead;
     size_t          fTotalMemoryUsed;
-#ifdef USE_CACHE_HASH
-    SkGlyphCache*   fHash[HASH_COUNT];
-#endif
 
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
 
     size_t  getFontCacheLimit() const { return fFontCacheLimit; }
     size_t  setFontCacheLimit(size_t limit);
     void    purgeAll(); // does not change budget
@@ skipping 89 matching lines @@
     }
     SkASSERT(desc);
 
     SkGlyphCache_Globals& globals = getGlobals();
     SkAutoMutexAcquire    ac(globals.fMutex);
     SkGlyphCache*         cache;
     bool                  insideMutex = true;
 
     globals.validate();
 
-#ifdef USE_CACHE_HASH
-    SkGlyphCache** hash = globals.fHash;
-    unsigned index = desc_to_hashindex(desc);
-    cache = hash[index];
-    if (cache && *cache->fDesc == *desc) {
-        cache->detach(&globals.fHead);
-        goto FOUND_IT;
-    }
-#endif
-
     for (cache = globals.fHead; cache != NULL; cache = cache->fNext) {
         if (cache->fDesc->equals(*desc)) {
             cache->detach(&globals.fHead);
             goto FOUND_IT;
         }
     }
 
     /* Release the mutex now, before we create a new entry (which might have
         side-effects like trying to access the cache/mutex (yikes!)
     */
@@ skipping 16 matching lines @@
     }
 
 FOUND_IT:
 
     AutoValidate av(cache);
 
     if (proc(cache, context)) {   // stay detached
         if (insideMutex) {
             SkASSERT(globals.fTotalMemoryUsed >= cache->fMemoryUsed);
             globals.fTotalMemoryUsed -= cache->fMemoryUsed;
-#ifdef USE_CACHE_HASH
-            hash[index] = NULL;
-#endif
         }
     } else {                        // reattach
         if (insideMutex) {
             cache->attachToHead(&globals.fHead);
-#ifdef USE_CACHE_HASH
-            hash[index] = cache;
-#endif
         } else {
             AttachCache(cache);
         }
         cache = NULL;
     }
     return cache;
 }
 
 void SkGlyphCache::AttachCache(SkGlyphCache* cache) {
     SkASSERT(cache);
@@ skipping 10 matching lines @@
         size_t allocated = globals.fTotalMemoryUsed + cache->fMemoryUsed;
         size_t budgeted = globals.getFontCacheLimit();
         if (allocated > budgeted) {
             (void)InternalFreeCache(&globals, allocated - budgeted);
         }
     }
 
     cache->attachToHead(&globals.fHead);
     globals.fTotalMemoryUsed += cache->fMemoryUsed;
 
-#ifdef USE_CACHE_HASH
-    unsigned index = desc_to_hashindex(cache->fDesc);
-    SkASSERT(globals.fHash[index] != cache);
-    globals.fHash[index] = cache;
-#endif
-
     globals.validate();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkGlyphCache* SkGlyphCache::FindTail(SkGlyphCache* cache) {
     if (cache) {
         while (cache->fNext) {
             cache = cache->fNext;
         }
@@ skipping 28 matching lines @@
     // don't do any "small" purges
     size_t minToPurge = globals->fTotalMemoryUsed >> 2;
     if (bytesNeeded < minToPurge)
         bytesNeeded = minToPurge;
 
     SkGlyphCache* cache = FindTail(globals->fHead);
     while (cache != NULL && bytesFreed < bytesNeeded) {
         SkGlyphCache* prev = cache->fPrev;
         bytesFreed += cache->fMemoryUsed;
 
-#ifdef USE_CACHE_HASH
-        unsigned index = desc_to_hashindex(cache->fDesc);
-        if (cache == globals->fHash[index]) {
-            globals->fHash[index] = NULL;
-        }
-#endif
-
         cache->detach(&globals->fHead);
         SkDELETE(cache);
         cache = prev;
         count += 1;
     }
 
     SkASSERT(bytesFreed <= globals->fTotalMemoryUsed);
     globals->fTotalMemoryUsed -= bytesFreed;
     globals->validate();
 
@@ skipping 52 matching lines @@
     return tls ? tls->getFontCacheLimit() : 0;
 }
 
 void SkGraphics::SetTLSFontCacheLimit(size_t bytes) {
     if (0 == bytes) {
         SkGlyphCache_Globals::DeleteTLS();
     } else {
         SkGlyphCache_Globals::GetTLS().setFontCacheLimit(bytes);
     }
 }