Parallel cache - preliminary

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 <SkOnce.h>
 #include "SkGlyphCache.h"
 #include "SkGlyphCache_Globals.h"
 #include "SkGraphics.h"
 #include "SkLazyPtr.h"
 #include "SkPath.h"
 #include "SkTemplates.h"
 #include "SkTypeface.h"
 
 //#define SPEW_PURGE_STATUS
 
@@ skipping 13 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // so we don't grow our arrays a lot
 #define kMinGlyphCount      16
 #define kMinGlyphImageSize  (16*2)
 #define kMinAllocAmount     ((sizeof(SkGlyph) + kMinGlyphImageSize) * kMinGlyphCount)
 
 SkGlyphCache::SkGlyphCache(SkTypeface* typeface, const SkDescriptor* desc, SkScalerContext* ctx)
-    : fDesc(desc->copy())
+    : fNext(NULL)
+    , fPrev(NULL)
+    , fDesc(desc->copy())
+    , refCount(0)
+    , fGlyphAlloc(kMinAllocAmount)
+    , fMemoryUsed(sizeof(*this))
     , fScalerContext(ctx)
-    , fGlyphAlloc(kMinAllocAmount) {
+    , fAuxProcList(NULL) {
     SkASSERT(typeface);
     SkASSERT(desc);
     SkASSERT(ctx);
 
-    fPrev = fNext = NULL;
-
     fScalerContext->getFontMetrics(&fFontMetrics);
-
-    fMemoryUsed = sizeof(*this);
-
-    fAuxProcList = NULL;
 }
 
 SkGlyphCache::~SkGlyphCache() {
     fGlyphMap.foreach(
         [](SkGlyph* g) {
             SkDELETE(g->fPath);
         }
     );
     SkDescriptor::Free(fDesc);
     SkDELETE(fScalerContext);
     this->invokeAndRemoveAuxProcs();
 }
 
+void SkGlyphCache::increaseMemoryUsed(size_t used) {
+    fMemoryUsed += used;
+    get_globals().increaseTotalMemoryUsed(used);
+}
+
+SkGlyphCache::CharGlyphRec SkGlyphCache::PackedUnicharIDtoCharGlyphRec(PackedUnicharID packedUnicharID) {
+    SkFixed x = SkGlyph::SubToFixed(SkGlyph::ID2SubX(packedUnicharID));
+    SkFixed y = SkGlyph::SubToFixed(SkGlyph::ID2SubY(packedUnicharID));
+    SkUnichar unichar = SkGlyph::ID2Code(packedUnicharID);
+
+    SkAutoMutexAcquire lock(fScalerMutex);
+    PackedGlyphID packedGlyphID = SkGlyph::MakeID(fScalerContext->charToGlyphID(unichar), x, y);
+
+    return {packedUnicharID, packedGlyphID};
+}
+
 SkGlyphCache::CharGlyphRec* SkGlyphCache::getCharGlyphRec(PackedUnicharID packedUnicharID) {
     if (NULL == fPackedUnicharIDToPackedGlyphID.get()) {
-        // Allocate the array.
-        fPackedUnicharIDToPackedGlyphID.reset(kHashCount);
-        // Initialize array to map character and position with the impossible glyph ID. This
-        // represents no mapping.
-        for (int i = 0; i <kHashCount; ++i) {
-            fPackedUnicharIDToPackedGlyphID[i].fPackedUnicharID = SkGlyph::kImpossibleID;
-            fPackedUnicharIDToPackedGlyphID[i].fPackedGlyphID = 0;
+        fMu.releaseShared();

[mtklein_C, 2015/08/14 15:31:37]

Let's add assertShared() / assertExclusive() methods to SkSharedMutex.  It'll
help document the invariants in these methods, which are somewhat complicated
now.

+
+        // Add the map only if there is a call for char -> glyph mapping.
+        {
+            SkAutoTAcquire<SkSharedMutex> lock(fMu);
+
+            // Now that the cache is locked exclusively, make sure no one added this array while unlocked.
+            if (NULL == fPackedUnicharIDToPackedGlyphID.get()) {
+                // Allocate the array.
+                fPackedUnicharIDToPackedGlyphID.reset(SkNEW(PackedUnicharIDToPackedGlyphIDMap));
+            }
+
+            fPackedUnicharIDToPackedGlyphID->set(PackedUnicharIDtoCharGlyphRec(packedUnicharID));
         }
+        fMu.acquireShared();
+
+        return fPackedUnicharIDToPackedGlyphID->find(packedUnicharID);
     }
 
-    return &fPackedUnicharIDToPackedGlyphID[SkChecksum::CheapMix(packedUnicharID) & kHashMask];
+    CharGlyphRec* answer = fPackedUnicharIDToPackedGlyphID->find(packedUnicharID);
+    if (NULL == answer) {
+        fMu.releaseShared();
+        // Add a new char -> glyph mapping.
+        {
+            SkAutoTAcquire<SkSharedMutex> lock(fMu);
+            answer = fPackedUnicharIDToPackedGlyphID->find(packedUnicharID);
+            if (NULL == answer) {
+                fPackedUnicharIDToPackedGlyphID->set(PackedUnicharIDtoCharGlyphRec(packedUnicharID));
+            }
+        }
+        fMu.acquireShared();
+        return fPackedUnicharIDToPackedGlyphID->find(packedUnicharID);
+    }
+
+    return answer;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 #define VALIDATE()  AutoValidate av(this)
 #else
 #define VALIDATE()
 #endif
 
 uint16_t SkGlyphCache::unicharToGlyph(SkUnichar charCode) {
     VALIDATE();
     PackedUnicharID packedUnicharID = SkGlyph::MakeID(charCode);
     const CharGlyphRec& rec = *this->getCharGlyphRec(packedUnicharID);
-
-    if (rec.fPackedUnicharID == packedUnicharID) {
-        return SkGlyph::ID2Code(rec.fPackedGlyphID);
-    } else {
-        return fScalerContext->charToGlyphID(charCode);
-    }
+    return SkGlyph::ID2Code(rec.fPackedGlyphID);
 }
 
 SkUnichar SkGlyphCache::glyphToUnichar(uint16_t glyphID) {
-    return fScalerContext->glyphIDToChar(glyphID);
+    SkUnichar answer;
+    SkAutoMutexAcquire lock(fScalerMutex);

[mtklein_C, 2015/08/14 15:31:37]

Is this different from
  SkAutoMutexAcquire lock(fScalerMutex);
  return fScalerContext->glyphIDToChar(glyphID);
?

+    answer = fScalerContext->glyphIDToChar(glyphID);
+    return answer;
 }
 
 unsigned SkGlyphCache::getGlyphCount() {
     return fScalerContext->getGlyphCount();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 const SkGlyph& SkGlyphCache::getUnicharAdvance(SkUnichar charCode) {
     VALIDATE();
@@ skipping 24 matching lines @@
     return *this->lookupByPackedGlyphID(packedGlyphID, kFull_MetricsType);
 }
 
 const SkGlyph& SkGlyphCache::getGlyphIDMetrics(uint16_t glyphID, SkFixed x, SkFixed y) {
     VALIDATE();
     PackedGlyphID packedGlyphID = SkGlyph::MakeID(glyphID, x, y);
     return *this->lookupByPackedGlyphID(packedGlyphID, kFull_MetricsType);
 }
 
 SkGlyph* SkGlyphCache::lookupByChar(SkUnichar charCode, MetricsType type, SkFixed x, SkFixed y) {
-    PackedUnicharID id = SkGlyph::MakeID(charCode, x, y);
-    CharGlyphRec* rec = this->getCharGlyphRec(id);
-    if (rec->fPackedUnicharID != id) {
-        // this ID is based on the UniChar
-        rec->fPackedUnicharID = id;
-        // this ID is based on the glyph index
-        PackedGlyphID combinedID = SkGlyph::MakeID(fScalerContext->charToGlyphID(charCode), x, y);
-        rec->fPackedGlyphID = combinedID;
-        return this->lookupByPackedGlyphID(combinedID, type);
-    } else {
-        return this->lookupByPackedGlyphID(rec->fPackedGlyphID, type);
-    }
+    PackedUnicharID targetUnicharID = SkGlyph::MakeID(charCode, x, y);
+    CharGlyphRec* rec = this->getCharGlyphRec(targetUnicharID);
+    PackedGlyphID packedGlyphID = rec->fPackedGlyphID;
+
+    return this->lookupByPackedGlyphID(packedGlyphID, type);
 }
 
 SkGlyph* SkGlyphCache::lookupByPackedGlyphID(PackedGlyphID packedGlyphID, MetricsType type) {
     SkGlyph* glyph = fGlyphMap.find(packedGlyphID);
 
     if (NULL == glyph) {
         glyph = this->allocateNewGlyph(packedGlyphID, type);
     } else {
         if (type == kFull_MetricsType && glyph->isJustAdvance()) {
-           fScalerContext->getMetrics(glyph);
+            addFullMetrics(glyph);

[mtklein_C, 2015/08/14 15:31:37]

this->

         }
     }
     return glyph;
 }
 
 SkGlyph* SkGlyphCache::allocateNewGlyph(PackedGlyphID packedGlyphID, MetricsType mtype) {
-    fMemoryUsed += sizeof(SkGlyph);
 
     SkGlyph* glyphPtr;
     {
-        SkGlyph glyph;
-        glyph.initGlyphFromCombinedID(packedGlyphID);
-        glyphPtr = fGlyphMap.set(glyph);
-    }
+        fMu.releaseShared();
+        {
+            SkAutoTAcquire<SkSharedMutex> mapLock(fMu);

[mtklein_C, 2015/08/14 15:31:37]

Let's find some common naming scheme between fMu and fScalerMutex.   I like
fScalerMutex.  fMu is a little vague.

+            glyphPtr = fGlyphMap.find(packedGlyphID);
+            if (NULL == glyphPtr) {
+                SkGlyph glyph;
+                glyph.initGlyphFromCombinedID(packedGlyphID);
+                {
+                    SkAutoMutexAcquire lock(fScalerMutex);
+                    if (kJustAdvance_MetricsType == mtype) {
+                        fScalerContext->getAdvance(&glyph);
+                    } else {
+                        SkASSERT(kFull_MetricsType == mtype);
+                        fScalerContext->getMetrics(&glyph);
+                    }
+                    increaseMemoryUsed(sizeof(SkGlyph));

[mtklein_C, 2015/08/14 15:31:37]

this->

+                }  // drop scaler lock
+                glyphPtr = fGlyphMap.set(glyph);
 
-    if (kJustAdvance_MetricsType == mtype) {
-        fScalerContext->getAdvance(glyphPtr);
-    } else {
-        SkASSERT(kFull_MetricsType == mtype);
-        fScalerContext->getMetrics(glyphPtr);
+            } else if (kFull_MetricsType == mtype && glyphPtr->isJustAdvance()) {
+                // Some other thread added the glyph, but only calculated just-advance metrics.
+                SkAutoMutexAcquire lock(fScalerMutex);
+                fScalerContext->getMetrics(glyphPtr);
+            }
+        }  // drop map lock
+        fMu.acquireShared();
+        glyphPtr = fGlyphMap.find(packedGlyphID);
     }
 
     SkASSERT(glyphPtr->fID != SkGlyph::kImpossibleID);
     return glyphPtr;
 }
 
-const void* SkGlyphCache::findImage(const SkGlyph& glyph) {
-    if (glyph.fWidth > 0 && glyph.fWidth < kMaxGlyphWidth) {
-        if (NULL == glyph.fImage) {
-            size_t  size = glyph.computeImageSize();
-            const_cast<SkGlyph&>(glyph).fImage = fGlyphAlloc.alloc(size,
-                                        SkChunkAlloc::kReturnNil_AllocFailType);
-            // check that alloc() actually succeeded
-            if (glyph.fImage) {
-                fScalerContext->getImage(glyph);
-                // TODO: the scaler may have changed the maskformat during
-                // getImage (e.g. from AA or LCD to BW) which means we may have
-                // overallocated the buffer. Check if the new computedImageSize
-                // is smaller, and if so, strink the alloc size in fImageAlloc.
-                fMemoryUsed += size;
-            }
+void SkGlyphCache::addFullMetrics(SkGlyph* glyph) {
+    // Now that the cache is exclusively owned, check again.
+    SkAutoMutexAcquire lock(fScalerMutex);
+    if (glyph->isJustAdvance()) {
+        fScalerContext->getMetrics(glyph);
+    }
+}
+
+void SkGlyphCache::onceFillInImage(GlyphAndCache gc) {

[mtklein_C, 2015/08/14 15:31:37]

It'd be nice to remind ourselves we're holding the scaler mutex in these methods
with

fScalerMutex.assertHeld();

+    SkGlyphCache* cache = gc.cache;
+    const SkGlyph* glyph = gc.glyph;
+    if (glyph->fWidth > 0 && glyph->fWidth < kMaxGlyphWidth) {
+        size_t size = glyph->computeImageSize();
+        sk_atomic_store(&const_cast<SkGlyph*>(glyph)->fImage,

[mtklein_C, 2015/08/14 15:31:37]

This shouldn't need to be atomic under this scheme, called by SkOnce.

+                cache->fGlyphAlloc.alloc(size, SkChunkAlloc::kReturnNil_AllocFailType),
+                        sk_memory_order_relaxed);
+        if (glyph->fImage != NULL) {
+            cache->fScalerContext->getImage(*glyph);
+            cache->increaseMemoryUsed(size);
         }
     }
-    return glyph.fImage;
+}
+
+const void* SkGlyphCache::findImage(const SkGlyph& glyph) {
+    SkOnce(&glyph.fImageIsSet, &fScalerMutex, &SkGlyphCache::onceFillInImage, {this, &glyph});
+    return sk_atomic_load(&glyph.fImage, sk_memory_order_relaxed);

[mtklein_C, 2015/08/14 15:31:37]

Again, I think these do not need to be atomic.

[herb_g, 2015/08/21 19:16:50]

I don't think this is correct. I think that making the load of glyph.fImage
non-atomic, means that there is no happens-before relationship between the mutex
and this variable. So, I think that the change would be a data race (1.10.21)
because glyph.fImage is non-atomic and there is no happens-before relationship
because the mutex does not synchronize with the fImage field. By making the
loads atomic relaxed forces the fImage read to not be a data race. 

From ISO: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf
The execution of a program contains a data race if it contains two conflicting
actions in different threads,
at least one of which is not atomic, and neither happens before the other. Any
such data race results in
undefined behavior

+}
+
+void SkGlyphCache::onceFillInPath(GlyphAndCache gc) {
+    SkGlyphCache* cache = gc.cache;
+    const SkGlyph* glyph = gc.glyph;
+    if (glyph->fWidth > 0) {
+        sk_atomic_store(&const_cast<SkGlyph*>(glyph)->fPath, SkNEW(SkPath), sk_memory_order_relaxed);

[mtklein_C, 2015/08/14 15:31:37]

ditto

+        cache->fScalerContext->getPath(*glyph, glyph->fPath);
+        size_t size = sizeof(SkPath) + glyph->fPath->countPoints() * sizeof(SkPoint);
+        cache->increaseMemoryUsed(size);
+    }
 }
 
 const SkPath* SkGlyphCache::findPath(const SkGlyph& glyph) {
-    if (glyph.fWidth) {
-        if (glyph.fPath == NULL) {
-            const_cast<SkGlyph&>(glyph).fPath = SkNEW(SkPath);
-            fScalerContext->getPath(glyph, glyph.fPath);
-            fMemoryUsed += sizeof(SkPath) +
-                    glyph.fPath->countPoints() * sizeof(SkPoint);
-        }
-    }
-    return glyph.fPath;
+    SkOnce(&glyph.fPathIsSet, &fScalerMutex, &SkGlyphCache::onceFillInPath, {this, &glyph});
+    return sk_atomic_load(&glyph.fPath, sk_memory_order_relaxed);

[mtklein_C, 2015/08/14 15:31:37]

ditto

 }
 
 void SkGlyphCache::dump() const {
     const SkTypeface* face = fScalerContext->getTypeface();
     const SkScalerContextRec& rec = fScalerContext->getRec();
     SkMatrix matrix;
     rec.getSingleMatrix(&matrix);
     matrix.preScale(SkScalarInvert(rec.fTextSize), SkScalarInvert(rec.fTextSize));
     SkString name;
     face->getFamilyName(&name);
 
     SkString msg;
     msg.printf("cache typeface:%x %25s:%d size:%2g [%g %g %g %g] lum:%02X devG:%d pntG:%d cntr:%d glyphs:%3d",
                face->uniqueID(), name.c_str(), face->style(), rec.fTextSize,
                matrix[SkMatrix::kMScaleX], matrix[SkMatrix::kMSkewX],
                matrix[SkMatrix::kMSkewY], matrix[SkMatrix::kMScaleY],
                rec.fLumBits & 0xFF, rec.fDeviceGamma, rec.fPaintGamma, rec.fContrast,
                fGlyphMap.count());
     SkDebugf("%s\n", msg.c_str());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkGlyphCache::getAuxProcData(void (*proc)(void*), void** dataPtr) const {
+    SkAutoMutexAcquire lock(fScalerMutex);

[mtklein_C, 2015/08/14 15:31:37]

It's not obvious why these hold fScalerMutex?

     const AuxProcRec* rec = fAuxProcList;
     while (rec) {
         if (rec->fProc == proc) {
             if (dataPtr) {
                 *dataPtr = rec->fData;
             }
             return true;
         }
         rec = rec->fNext;
     }
     return false;
 }
 
 void SkGlyphCache::setAuxProc(void (*proc)(void*), void* data) {
     if (proc == NULL) {
         return;
     }
 
+    SkAutoMutexAcquire lock(fScalerMutex);
     AuxProcRec* rec = fAuxProcList;
     while (rec) {
         if (rec->fProc == proc) {
             rec->fData = data;
             return;
         }
         rec = rec->fNext;
     }
     // not found, create a new rec
     rec = SkNEW(AuxProcRec);
     rec->fProc = proc;
     rec->fData = data;
     rec->fNext = fAuxProcList;
     fAuxProcList = rec;
 }
 
 void SkGlyphCache::invokeAndRemoveAuxProcs() {
     AuxProcRec* rec = fAuxProcList;
     while (rec) {
         rec->fProc(rec->fData);
         AuxProcRec* next = rec->fNext;
         SkDELETE(rec);
         rec = next;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-
-class AutoAcquire {
-public:
-    AutoAcquire(SkSpinlock& lock) : fLock(lock) { fLock.acquire(); }
-    ~AutoAcquire() { fLock.release(); }
-private:
-    SkSpinlock& fLock;
-};
+typedef SkAutoTAcquire<SkSpinlock> AutoAcquire;
 
 size_t SkGlyphCache_Globals::setCacheSizeLimit(size_t newLimit) {
     static const size_t minLimit = 256 * 1024;
     if (newLimit < minLimit) {
         newLimit = minLimit;
     }
 
     AutoAcquire ac(fLock);
 
     size_t prevLimit = fCacheSizeLimit;
@@ skipping 10 matching lines @@
     AutoAcquire ac(fLock);
 
     int prevCount = fCacheCountLimit;
     fCacheCountLimit = newCount;
     this->internalPurge();
     return prevCount;
 }
 
 void SkGlyphCache_Globals::purgeAll() {
     AutoAcquire ac(fLock);
-    this->internalPurge(fTotalMemoryUsed);
+    this->internalPurge(fTotalMemoryUsed.load());
 }
 
 /*  This guy calls the visitor from within the mutext lock, so the visitor
     cannot:
     - take too much time
     - try to acquire the mutext again
     - call a fontscaler (which might call into the cache)
 */
-SkGlyphCache* SkGlyphCache::VisitCache(SkTypeface* typeface,
-                              const SkDescriptor* desc,
-                              bool (*proc)(const SkGlyphCache*, void*),
-                              void* context) {
+SkGlyphCache* SkGlyphCache::VisitCache(SkTypeface* typeface, const SkDescriptor* desc, VisitProc proc, void* context) {
     if (!typeface) {
         typeface = SkTypeface::GetDefaultTypeface();
     }
     SkASSERT(desc);
 
     SkGlyphCache_Globals& globals = get_globals();
     SkGlyphCache*         cache;
 
     {
         AutoAcquire ac(globals.fLock);
 
         globals.validate();
 
         for (cache = globals.internalGetHead(); cache != NULL; cache = cache->fNext) {
             if (cache->fDesc->equals(*desc)) {
-                globals.internalDetachCache(cache);
+                globals.internalMoveToHead(cache);
+                cache->fMu.acquireShared();
                 if (!proc(cache, context)) {
-                    globals.internalAttachCacheToHead(cache);
-                    cache = NULL;
+                    cache->fMu.releaseShared();
+                    return NULL;
                 }
+                cache->refCount += 1;

[mtklein_C, 2015/08/14 15:31:37]

This seems odd.  Are all these cache->refCounts always guarded by globals.fLock?
 If so, let's document / assert the crap out of it.  Locks spread out over two
different objects are confusing and easily screwed up.

We might want to brainstorm a bit about a different name, just given how
specific a meaning ref count has in the rest of Skia.

                 return cache;
             }
         }
     }
 
     // Check if we can create a scaler-context before creating the glyphcache.
     // If not, we may have exhausted OS/font resources, so try purging the
     // cache once and try again.
     {
         // pass true the first time, to notice if the scalercontext failed,
         // so we can try the purge.
         SkScalerContext* ctx = typeface->createScalerContext(desc, true);
-        if (!ctx) {
+        if (NULL == ctx) {
             get_globals().purgeAll();
             ctx = typeface->createScalerContext(desc, false);
             SkASSERT(ctx);
         }
         cache = SkNEW_ARGS(SkGlyphCache, (typeface, desc, ctx));
+
+        globals.attachCacheToHead(cache);
     }
 
     AutoValidate av(cache);
+    AutoAcquire ac(globals.fLock);
 
+    cache->fMu.acquireShared();
     if (!proc(cache, context)) {   // need to reattach
-        globals.attachCacheToHead(cache);
-        cache = NULL;
+        cache->fMu.releaseShared();
+        return NULL;
     }
+    cache->refCount += 1;
     return cache;
 }
 
 void SkGlyphCache::AttachCache(SkGlyphCache* cache) {
     SkASSERT(cache);
-    SkASSERT(cache->fNext == NULL);
-
-    get_globals().attachCacheToHead(cache);
+    cache->fMu.releaseShared();
+    SkGlyphCache_Globals& globals = get_globals();
+    AutoAcquire ac(globals.fLock);
+    globals.validate();
+    cache->validate();
+    if (cache->refCount == 0) {
+        delete cache;
+    }
+    globals.internalPurge();
 }
 
 void SkGlyphCache::Dump() {
     SkGlyphCache_Globals& globals = get_globals();
     AutoAcquire           ac(globals.fLock);
     SkGlyphCache*         cache;
 
     globals.validate();
 
     SkDebugf("SkGlyphCache strikes:%d memory:%d\n",
              globals.getCacheCountUsed(), (int)globals.getTotalMemoryUsed());
 
     for (cache = globals.internalGetHead(); cache != NULL; cache = cache->fNext) {
         cache->dump();
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGlyphCache_Globals::attachCacheToHead(SkGlyphCache* cache) {
     AutoAcquire ac(fLock);
 
+    fCacheCount += 1;
+    cache->refCount += 1;
+    // Access to cache->fMemoryUsed is single threaded until internalMoveToHead.
+    fTotalMemoryUsed.fetch_add(cache->fMemoryUsed);
+
+    this->internalMoveToHead(cache);
+
     this->validate();
     cache->validate();
 
-    this->internalAttachCacheToHead(cache);
     this->internalPurge();
 }
 
 SkGlyphCache* SkGlyphCache_Globals::internalGetTail() const {
     SkGlyphCache* cache = fHead;
     if (cache) {
         while (cache->fNext) {
             cache = cache->fNext;
         }
     }
     return cache;
 }
 
 size_t SkGlyphCache_Globals::internalPurge(size_t minBytesNeeded) {
     this->validate();
 
     size_t bytesNeeded = 0;
-    if (fTotalMemoryUsed > fCacheSizeLimit) {
-        bytesNeeded = fTotalMemoryUsed - fCacheSizeLimit;
+    if (fTotalMemoryUsed.load() > fCacheSizeLimit) {
+        bytesNeeded = fTotalMemoryUsed.load() - fCacheSizeLimit;
     }
     bytesNeeded = SkTMax(bytesNeeded, minBytesNeeded);
     if (bytesNeeded) {
         // no small purges!
-        bytesNeeded = SkTMax(bytesNeeded, fTotalMemoryUsed >> 2);
+        bytesNeeded = SkTMax(bytesNeeded, fTotalMemoryUsed.load() >> 2);
     }
 
     int countNeeded = 0;
     if (fCacheCount > fCacheCountLimit) {
         countNeeded = fCacheCount - fCacheCountLimit;
         // no small purges!
         countNeeded = SkMax32(countNeeded, fCacheCount >> 2);
     }
 
     // early exit
     if (!countNeeded && !bytesNeeded) {
         return 0;
     }
 
     size_t  bytesFreed = 0;
     int     countFreed = 0;
 
     // we start at the tail and proceed backwards, as the linklist is in LRU
     // order, with unimportant entries at the tail.
     SkGlyphCache* cache = this->internalGetTail();
     while (cache != NULL &&
            (bytesFreed < bytesNeeded || countFreed < countNeeded)) {
         SkGlyphCache* prev = cache->fPrev;
         bytesFreed += cache->fMemoryUsed;
         countFreed += 1;
 
         this->internalDetachCache(cache);
-        SkDELETE(cache);
+        if (0 == cache->refCount) {
+            SkDELETE(cache);
+        }
         cache = prev;
     }
 
     this->validate();
 
 #ifdef SPEW_PURGE_STATUS
     if (countFreed) {
         SkDebugf("purging %dK from font cache [%d entries]\n",
                  (int)(bytesFreed >> 10), countFreed);
     }
 #endif
 
     return bytesFreed;
 }
 
-void SkGlyphCache_Globals::internalAttachCacheToHead(SkGlyphCache* cache) {
-    SkASSERT(NULL == cache->fPrev && NULL == cache->fNext);
-    if (fHead) {
-        fHead->fPrev = cache;
-        cache->fNext = fHead;
+void SkGlyphCache_Globals::internalMoveToHead(SkGlyphCache *cache) {
+    if (cache != fHead) {
+        if (cache->fPrev) {
+            cache->fPrev->fNext = cache->fNext;
+        }
+        if (cache->fNext) {
+            cache->fNext->fPrev = cache->fPrev;
+        }
+        cache->fNext = NULL;
+        cache->fPrev = NULL;
+        if (fHead) {
+            fHead->fPrev = cache;
+            cache->fNext = fHead;
+        }
+        fHead = cache;
     }
-    fHead = cache;
-
-    fCacheCount += 1;
-    fTotalMemoryUsed += cache->fMemoryUsed;
 }
 
 void SkGlyphCache_Globals::internalDetachCache(SkGlyphCache* cache) {
-    SkASSERT(fCacheCount > 0);
     fCacheCount -= 1;
-    fTotalMemoryUsed -= cache->fMemoryUsed;
+    fTotalMemoryUsed.fetch_add(-cache->fMemoryUsed);
 
     if (cache->fPrev) {
         cache->fPrev->fNext = cache->fNext;
     } else {
         fHead = cache->fNext;
     }
     if (cache->fNext) {
         cache->fNext->fPrev = cache->fPrev;
     }
     cache->fPrev = cache->fNext = NULL;
+    cache->refCount -= 1;
+
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 
 void SkGlyphCache::validate() const {
 #ifdef SK_DEBUG_GLYPH_CACHE
     int count = fGlyphArray.count();
     for (int i = 0; i < count; i++) {
         const SkGlyph* glyph = &fGlyphArray[i];
         SkASSERT(glyph);
         if (glyph->fImage) {
             SkASSERT(fGlyphAlloc.contains(glyph->fImage));
         }
     }
 #endif
 }
 
 void SkGlyphCache_Globals::validate() const {
-    size_t computedBytes = 0;
     int computedCount = 0;
 
-    const SkGlyphCache* head = fHead;
+    SkGlyphCache* head = fHead;
     while (head != NULL) {
-        computedBytes += head->fMemoryUsed;
         computedCount += 1;
         head = head->fNext;
     }
 
     SkASSERTF(fCacheCount == computedCount, "fCacheCount: %d, computedCount: %d", fCacheCount,
               computedCount);
-    SkASSERTF(fTotalMemoryUsed == computedBytes, "fTotalMemoryUsed: %d, computedBytes: %d",
-              fTotalMemoryUsed, computedBytes);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkTypefaceCache.h"
 
 size_t SkGraphics::GetFontCacheLimit() {
@@ skipping 21 matching lines @@
 }
 
 void SkGraphics::PurgeFontCache() {
     get_globals().purgeAll();
     SkTypefaceCache::PurgeAll();
 }
 
 // TODO(herb): clean up TLS apis.
 size_t SkGraphics::GetTLSFontCacheLimit() { return 0; }
 void SkGraphics::SetTLSFontCacheLimit(size_t bytes) { }