Adding a cache + memory pool for GPU TextBlobs

src/gpu/GrAtlasTextContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrAtlasTextContext.h"
 
 #include "GrAtlas.h"
 #include "GrBatch.h"
 #include "GrBatchFontCache.h"
 #include "GrBatchTarget.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawTarget.h"
 #include "GrFontScaler.h"
 #include "GrIndexBuffer.h"
 #include "GrStrokeInfo.h"
+#include "GrTextBlobCache.h"
 #include "GrTexturePriv.h"
 
 #include "SkAutoKern.h"
 #include "SkColorPriv.h"
 #include "SkDraw.h"
 #include "SkDrawFilter.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkGpuDevice.h"
 #include "SkGr.h"
@@ skipping 32 matching lines @@
 
 // TODO
 // More tests
 // move to SkCache
 // handle textblobs where the whole run is larger than the cache size
 // TODO implement micro speedy hash map for fast refing of glyphs
 
 GrAtlasTextContext::GrAtlasTextContext(GrContext* context,
                                        SkGpuDevice* gpuDevice,
                                        const SkDeviceProperties& properties)
-                                       : INHERITED(context, gpuDevice, properties) {
+    : INHERITED(context, gpuDevice, properties) {
+    // We overallocate vertices in our textblobs based on the assumption that A8 has the greatest
+    // vertexStride
+    SK_COMPILE_ASSERT(kGrayTextVASize >= kColorTextVASize && kGrayTextVASize >= kLCDTextVASize,
+                      vertex_attribute_changed);
     fCurrStrike = NULL;
-}
-
-void GrAtlasTextContext::ClearCacheEntry(uint32_t key, BitmapTextBlob** blob) {
-    (*blob)->unref();
-}
-
-GrAtlasTextContext::~GrAtlasTextContext() {
-    fCache.foreach(&GrAtlasTextContext::ClearCacheEntry);
+    fCache = context->getTextBlobCache();
 }
 
 GrAtlasTextContext* GrAtlasTextContext::Create(GrContext* context,
                                                SkGpuDevice* gpuDevice,
                                                const SkDeviceProperties& props) {
     return SkNEW_ARGS(GrAtlasTextContext, (context, gpuDevice, props));
 }
 
 bool GrAtlasTextContext::canDraw(const GrRenderTarget*,
                                  const GrClip&,
@@ skipping 13 matching lines @@
 
 
 inline SkGlyphCache* GrAtlasTextContext::setupCache(BitmapTextBlob::Run* run,
                                                     const SkPaint& skPaint,
                                                     const SkMatrix& viewMatrix) {
     skPaint.getScalerContextDescriptor(&run->fDescriptor, &fDeviceProperties, &viewMatrix, false);
     run->fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
     return SkGlyphCache::DetachCache(run->fTypeface, run->fDescriptor.getDesc());
 }
 
-inline void GrAtlasTextContext::BlobGlyphCount(int* glyphCount, int* runCount,
-                                               const SkTextBlob* blob) {
-    SkTextBlob::RunIterator itCounter(blob);
-    for (; !itCounter.done(); itCounter.next(), (*runCount)++) {
-        *glyphCount += itCounter.glyphCount();
-    }
-}
-
-GrAtlasTextContext::BitmapTextBlob* GrAtlasTextContext::CreateBlob(int glyphCount,
-                                                                   int runCount) {
-    // We allocate size for the BitmapTextBlob itself, plus size for the vertices array,
-    // and size for the glyphIds array.
-    SK_COMPILE_ASSERT(kGrayTextVASize >= kColorTextVASize && kGrayTextVASize >= kLCDTextVASize,
-                      vertex_attribute_changed);
-    size_t verticesCount = glyphCount * kVerticesPerGlyph * kGrayTextVASize;
-    size_t length = sizeof(BitmapTextBlob) +
-                    verticesCount +
-                    glyphCount * sizeof(GrGlyph::PackedID) +
-                    sizeof(BitmapTextBlob::Run) * runCount;
-
-    BitmapTextBlob* cacheBlob = SkNEW_PLACEMENT(sk_malloc_throw(length), BitmapTextBlob);
-
-    // setup offsets for vertices / glyphs
-    cacheBlob->fVertices = sizeof(BitmapTextBlob) + reinterpret_cast<unsigned char*>(cacheBlob);
-    cacheBlob->fGlyphIDs =
-            reinterpret_cast<GrGlyph::PackedID*>(cacheBlob->fVertices + verticesCount);
-    cacheBlob->fRuns = reinterpret_cast<BitmapTextBlob::Run*>(cacheBlob->fGlyphIDs + glyphCount);
-
-    // Initialize runs
-    for (int i = 0; i < runCount; i++) {
-        SkNEW_PLACEMENT(&cacheBlob->fRuns[i], BitmapTextBlob::Run);
-    }
-    cacheBlob->fRunCount = runCount;
-    return cacheBlob;
-}
-
 void GrAtlasTextContext::drawTextBlob(GrRenderTarget* rt, const GrClip& clip,
                                       const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                       const SkTextBlob* blob, SkScalar x, SkScalar y,
                                       SkDrawFilter* drawFilter, const SkIRect& clipBounds) {
-    BitmapTextBlob* cacheBlob;
-    BitmapTextBlob** foundBlob = fCache.find(blob->uniqueID());
+    uint32_t uniqueID = blob->uniqueID();
+    BitmapTextBlob* cacheBlob = fCache->find(uniqueID);
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
-    if (foundBlob) {
-        cacheBlob = *foundBlob;
+    if (cacheBlob) {
         if (MustRegenerateBlob(*cacheBlob, skPaint, viewMatrix, x, y)) {
             // We have to remake the blob because changes may invalidate our masks.
             // TODO we could probably get away reuse most of the time if the pointer is unique,
             // but we'd have to clear the subrun information
-            cacheBlob->unref();
-            int glyphCount = 0;
-            int runCount = 0;
-            BlobGlyphCount(&glyphCount, &runCount, blob);
-            cacheBlob = CreateBlob(glyphCount, runCount);
-            fCache.set(blob->uniqueID(), cacheBlob);
+            fCache->remove(cacheBlob);
+            cacheBlob = fCache->createCachedBlob(blob, kGrayTextVASize);
             this->regenerateTextBlob(cacheBlob, skPaint, viewMatrix, blob, x, y, drawFilter,
                                      clipRect);
+        } else {
+            fCache->makeMRU(cacheBlob);
         }
     } else {
-        int glyphCount = 0;
-        int runCount = 0;
-        BlobGlyphCount(&glyphCount, &runCount, blob);
-        cacheBlob = CreateBlob(glyphCount, runCount);
-        fCache.set(blob->uniqueID(), cacheBlob);
+        cacheBlob = fCache->createCachedBlob(blob, kGrayTextVASize);
         this->regenerateTextBlob(cacheBlob, skPaint, viewMatrix, blob, x, y, drawFilter, clipRect);
     }
 
     // Though for the time being runs in the textblob can override the paint, they only touch font
     // info.
     GrPaint grPaint;
     SkPaint2GrPaintShader(fContext, rt, skPaint, viewMatrix, true, &grPaint);
 
     this->flush(fContext->getTextTarget(), blob, cacheBlob, rt, skPaint, grPaint, drawFilter,
                 clip, viewMatrix, clipBounds, x, y);
@@ skipping 73 matching lines @@
         SkGlyphCache::AttachCache(cache);
     }
 }
 
 void GrAtlasTextContext::onDrawText(GrRenderTarget* rt, const GrClip& clip,
                                     const GrPaint& paint, const SkPaint& skPaint,
                                     const SkMatrix& viewMatrix,
                                     const char text[], size_t byteLength,
                                     SkScalar x, SkScalar y, const SkIRect& regionClipBounds) {
     int glyphCount = skPaint.countText(text, byteLength);
-    SkAutoTUnref<BitmapTextBlob> blob(CreateBlob(glyphCount, 1));
+    SkAutoTUnref<BitmapTextBlob> blob(fCache->createBlob(glyphCount, 1, kGrayTextVASize));
     blob->fViewMatrix = viewMatrix;
     blob->fX = x;
     blob->fY = y;
     blob->fStyle = skPaint.getStyle();
 
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
     // setup cache
     SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, viewMatrix);
@@ skipping 93 matching lines @@
     }
 }
 
 void GrAtlasTextContext::onDrawPosText(GrRenderTarget* rt, const GrClip& clip,
                                        const GrPaint& paint, const SkPaint& skPaint,
                                        const SkMatrix& viewMatrix,
                                        const char text[], size_t byteLength,
                                        const SkScalar pos[], int scalarsPerPosition,
                                        const SkPoint& offset, const SkIRect& regionClipBounds) {
     int glyphCount = skPaint.countText(text, byteLength);
-    SkAutoTUnref<BitmapTextBlob> blob(CreateBlob(glyphCount, 1));
+    SkAutoTUnref<BitmapTextBlob> blob(fCache->createBlob(glyphCount, 1, kGrayTextVASize));
     blob->fStyle = skPaint.getStyle();
     blob->fViewMatrix = viewMatrix;
 
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
     // setup cache
     SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, viewMatrix);
     this->internalDrawPosText(blob, 0, cache, skPaint, viewMatrix, text, byteLength, pos,
                               scalarsPerPosition, offset, clipRect);
@@ skipping 741 matching lines @@
 
     GrColor color = grPaint.getColor();
     uint8_t paintAlpha = skPaint.getAlpha();
     for (int run = 0; run < cacheBlob->fRunCount; run++) {
         this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, paintAlpha);
     }
 
     // Now flush big glyphs
     this->flushBigGlyphs(cacheBlob, rt, grPaint, clip);
 }