combine glyph and image bulk alloc, and adjust initial alloc size, to reduce total waste from 50% t…

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"
@@ skipping 30 matching lines @@
         }
     }
 #else
     #define RecordHashSuccess() (void)0
     #define RecordHashCollisionIf(pred) (void)0
 #endif
 #define RecordHashCollision() RecordHashCollisionIf(true)
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#define kMinGlphAlloc       (sizeof(SkGlyph) * 64)
-#define kMinImageAlloc      (24 * 64)   // should be pointsize-dependent
-
-#define METRICS_RESERVE_COUNT  128  // so we don't grow this array a lot
+// 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)
-        : fGlyphAlloc(kMinGlphAlloc)
-        , fImageAlloc(kMinImageAlloc) {
+        : fGlyphAlloc(kMinAllocAmount) {
     SkASSERT(typeface);
 
     fPrev = fNext = NULL;
 
     fDesc = desc->copy();
     fScalerContext = typeface->createScalerContext(desc);
     fScalerContext->getFontMetrics(&fFontMetrics);
 
     // init to 0 so that all of the pointers will be null
     memset(fGlyphHash, 0, sizeof(fGlyphHash));
     // init with 0xFF so that the charCode field will be -1, which is invalid
     memset(fCharToGlyphHash, 0xFF, sizeof(fCharToGlyphHash));
 
-    fMemoryUsed = sizeof(*this) + kMinGlphAlloc + kMinImageAlloc;
+    fMemoryUsed = sizeof(*this);
 
-    fGlyphArray.setReserve(METRICS_RESERVE_COUNT);
+    fGlyphArray.setReserve(kMinGlyphCount);
 
     fMetricsCount = 0;
     fAdvanceCount = 0;
     fAuxProcList = NULL;
 }
 
 SkGlyphCache::~SkGlyphCache() {
+#if 0
+    {
+        size_t ptrMem = fGlyphArray.count() * sizeof(SkGlyph*);
+        size_t glyphAlloc = fGlyphAlloc.totalCapacity();
+        size_t glyphHashUsed = 0;
+        size_t uniHashUsed = 0;
+        for (int i = 0; i < kHashCount; ++i) {
+            glyphHashUsed += fGlyphHash[i] ? sizeof(fGlyphHash[0]) : 0;
+            uniHashUsed += fCharToGlyphHash[i].fID != 0xFFFFFFFF ? sizeof(fCharToGlyphHash[0]) : 0;
+        }
+        size_t glyphUsed = fGlyphArray.count() * sizeof(SkGlyph);
+        size_t imageUsed = 0;
+        for (int i = 0; i < fGlyphArray.count(); ++i) {
+            const SkGlyph& g = *fGlyphArray[i];
+            if (g.fImage) {
+                imageUsed += g.fHeight * g.rowBytes();
+            }
+        }
+
+        printf("glyphPtrArray,%zu, Alloc,%zu, imageUsed,%zu, glyphUsed,%zu, glyphHashAlloc,%zu, glyphHashUsed,%zu, unicharHashAlloc,%zu, unicharHashUsed,%zu\n",
+                 ptrMem, glyphAlloc, imageUsed, glyphUsed, sizeof(fGlyphHash), glyphHashUsed, sizeof(fCharToGlyphHash), uniHashUsed);
+        
+    }
+#endif
     SkGlyph**   gptr = fGlyphArray.begin();
     SkGlyph**   stop = fGlyphArray.end();
     while (gptr < stop) {
         SkPath* path = (*gptr)->fPath;
         if (path) {
             SkDELETE(path);
         }
         gptr += 1;
     }
     SkDescriptor::Free(fDesc);
@@ skipping 197 matching lines @@
         fMetricsCount += 1;
     }
 
     return glyph;
 }
 
 const void* SkGlyphCache::findImage(const SkGlyph& glyph) {
     if (glyph.fWidth > 0 && glyph.fWidth < kMaxGlyphWidth) {
         if (glyph.fImage == NULL) {
             size_t  size = glyph.computeImageSize();
-            const_cast<SkGlyph&>(glyph).fImage = fImageAlloc.alloc(size,
+            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;
             }
@@ skipping 391 matching lines @@
 
 #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);
         SkASSERT(fGlyphAlloc.contains(glyph));
         if (glyph->fImage) {
-            SkASSERT(fImageAlloc.contains(glyph->fImage));
+            SkASSERT(fGlyphAlloc.contains(glyph->fImage));
         }
     }
 #endif
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkTypefaceCache.h"
@@ skipping 20 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);
     }
 }