Switch to one single bitmap text blob cache allocation

src/gpu/GrBitmapTextContext.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrBitmapTextContext_DEFINED
 #define GrBitmapTextContext_DEFINED
 
 #include "GrTextContext.h"
 
 #include "GrGeometryProcessor.h"
+#include "GrMemoryPool.h"
+#include "SkDescriptor.h"
 #include "SkTHash.h"
 
 class GrBatchTextStrike;
 class GrPipelineBuilder;
 
 /*
  * This class implements GrTextContext using standard bitmap fonts, and can also process textblobs.
  * TODO replace GrBitmapTextContext
  */
 class GrBitmapTextContextB : public GrTextContext {
@@ skipping 33 matching lines @@
      * The only thing(aside from a memcopy) required to flush a BitmapTextBlob is to ensure that
      * the GrAtlas will not evict anything the Blob needs.
      * TODO this is currently a bug
      */
     struct BitmapTextBlob : public SkRefCnt {
         // Each Run inside of the blob can have its texture coordinates regenerated if required.
         // To determine if regeneration is necessary, fAtlasGeneration is used.  If there have been
         // any evictions inside of the atlas, then we will simply regenerate Runs.  We could track
         // this at a more fine grained level, but its not clear if this is worth it, as evictions
         // should be fairly rare.
         // One additional point, each run can contain glyphs with any of the three mask formats.

[bsalomon, 2015/03/31 21:19:10]

specify in comments that these are "subruns" to make connection to code clearer?

[joshualitt, 2015/04/01 13:21:18]

Acknowledged.

         // We maintain separate arrays for each format type, and flush them separately.  In practice
         // most of the time a run will have the same format type
         struct Run {
-            Run() : fColor(GrColor_ILLEGAL) { fVertexBounds.setLargestInverted(); }
-            struct PerFormatInfo {
-                PerFormatInfo() : fAtlasGeneration(GrBatchAtlas::kInvalidAtlasGeneration) {}
-                SkTDArray<unsigned char> fVertices;
-                SkTDArray<GrGlyph::PackedID> fGlyphIDs;
+            Run() : fColor(GrColor_ILLEGAL), fInitialized(false) {
+                fVertexBounds.setLargestInverted();
+                fSubRunInfo.push_back();
+            }
+            struct PerSubRunInfo {

[bsalomon, 2015/03/31 21:19:11]

SubRunInfo?

[joshualitt, 2015/04/01 13:21:18]

Acknowledged.

+                PerSubRunInfo()
+                    : fAtlasGeneration(GrBatchAtlas::kInvalidAtlasGeneration)
+                    , fGlyphStartIndex(0)
+                    , fGlyphEndIndex(0)
+                    , fVertexStartIndex(0)
+                    , fVertexEndIndex(0) {}
+                GrMaskFormat fMaskFormat;
                 uint64_t fAtlasGeneration;
+                uint32_t fGlyphStartIndex;
+                uint32_t fGlyphEndIndex;
+                uint32_t fVertexStartIndex;
+                uint32_t fVertexEndIndex;
             };
-            SkAutoTUnref<const SkData> fDescriptor;
+            SkSTArray<1, PerSubRunInfo, true> fSubRunInfo;

[bsalomon, 2015/03/31 21:19:11]

Does this max out at 3? Maybe just always have an array of 3?

[joshualitt, 2015/04/01 13:21:18]

No, we can have as many subruns as there are glyphs in a run.  Let me know if
the updated comment above does not clarify things.

+            SkAutoDescriptor fDescriptor;
             SkAutoTUnref<SkTypeface> fTypeface;
-            PerFormatInfo fInfos[kMaskFormatCount];
             SkRect fVertexBounds;
             GrColor fColor;
+            bool fInitialized;

[bsalomon, 2015/03/31 21:19:11]

can you use another param for this rather than adding a field?
fDescriptor.isInitialized() (which would be easy to write).

[joshualitt, 2015/04/01 13:21:18]

Unfortunately I can't just use the descriptor because it is initialized before
the mask.  I could use fSubRunInfo.count(), but it would really complicate how I
have to handle 'handing off' from one run to the next, ie, if there are no
glyphs in a given run, the subrun could be empty, so when I go to write forward
start vertices / indices, I'd have to put in logic to handle the empty case.  I
could handle this by putting start / end vertices / indices on each run as well
as each subrun, but it seems easier to just use a bool.

[bsalomon, 2015/04/01 15:41:45]

I'm not sure I totally follow... but maybe this makes sense:

Why not skip the push_back in the constructor and have:

if (run.fSubRunInfo.isEmpty() || run.fSubRunInfo.back().fMaskFormat != format) {
    SubRunInfo* newSubRun = &run.fSubRunInfo.push_back();
    // ...
}
SubRunInfo* subRunInfo = &run.fSubRunInfo.back();

Seems simpler, no slower, and gets rid of the bool. Is it useful elsewhere to
have a subrun that has no glyphs?

         };
-        SkSTArray<1, Run, true> fRuns;
+
         struct BigGlyph {
             BigGlyph(const SkPath& path, int vx, int vy) : fPath(path), fVx(vx), fVy(vy) {}
             SkPath fPath;
             int fVx;
             int fVy;
         };
+
         SkTArray<BigGlyph> fBigGlyphs;
-        SkTextBlob* fBlob;
         SkMatrix fViewMatrix;
         SkScalar fX;
         SkScalar fY;
         SkPaint::Style fStyle;
+        uint32_t fRunCount;
+
+        // all glyph / vertex offsets are into these pools.
+        unsigned char* fVertices;
+        GrGlyph::PackedID* fGlyphIDs;
+        Run* fRuns;
 
         static uint32_t Hash(const uint32_t& key) {
             return SkChecksum::Mix(key);
         }
+
+        void operator delete(void* p) { sk_free(p); }
+        void* operator new(size_t) {
+            SkFAIL("All blobs are created by placement new.");
+            return sk_malloc_throw(0);
+        }
+        void* operator new(size_t, void* p) { return p; }

[bsalomon, 2015/03/31 21:19:11]

some compilers will yell at you for not overriding delete if you override new.

[joshualitt, 2015/04/01 13:21:18]

Acknowledged.  I'm not sure if I did the delete right though.

[bsalomon, 2015/04/01 15:41:45]

Now that I look more closely, why did you need to override new/delete at all?

[joshualitt, 2015/04/01 16:54:23]

Just to put the throw in new.  I guess its not really necessary, but anyways I
override them a few cls down the road to use the pool.

     };
 
+    typedef BitmapTextBlob::Run Run;
+    typedef Run::PerSubRunInfo PerSubRunInfo;
+
+    inline BitmapTextBlob* CreateBlob(int glyphCount, int runCount);
+
     void appendGlyph(BitmapTextBlob*, int runIndex, GrGlyph::PackedID, int left, int top,
                      GrFontScaler*, const SkIRect& clipRect);
-    void flushSubRun(GrDrawTarget*, BitmapTextBlob*, int i, GrPipelineBuilder*, GrMaskFormat,
-               GrColor color, int paintAlpha);
     void flush(GrDrawTarget*, BitmapTextBlob*, GrRenderTarget*, const GrPaint&, const GrClip&,
                const SkMatrix& viewMatrix, int paintAlpha);
 
-    void internalDrawText(BitmapTextBlob*, int runIndex, const SkPaint&,
+    void internalDrawText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
                           const SkMatrix& viewMatrix, const char text[], size_t byteLength,
                           SkScalar x, SkScalar y, const SkIRect& clipRect);
-    void internalDrawPosText(BitmapTextBlob*, int runIndex, const SkPaint&,
+    void internalDrawPosText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
                              const SkMatrix& viewMatrix,
                              const char text[], size_t byteLength,
                              const SkScalar pos[], int scalarsPerPosition,
                              const SkPoint& offset, const SkIRect& clipRect);
 
+    // sets up the descriptor on the blob and returns a detached cache.  Client must attach
+    inline SkGlyphCache* setupCache(Run*, const SkPaint&, const SkMatrix& viewMatrix);
     static inline bool MustRegenerateBlob(const BitmapTextBlob&, const SkPaint&,
                                           const SkMatrix& viewMatrix, SkScalar x, SkScalar y);
     void regenerateTextBlob(BitmapTextBlob* bmp, const SkPaint& skPaint, const SkMatrix& viewMatrix,
                             const SkTextBlob* blob, SkScalar x, SkScalar y,
                             SkDrawFilter* drawFilter, const SkIRect& clipRect);
+    static inline void BlobGlyphCount(int* glyphCount, int* runCount, const SkTextBlob*);
 
     GrBatchTextStrike* fCurrStrike;
 
     // TODO use real cache
     static void ClearCacheEntry(uint32_t key, BitmapTextBlob**);
     SkTHashMap<uint32_t, BitmapTextBlob*, BitmapTextBlob::Hash> fCache;
 
     friend class BitmapTextBatch;
 
     typedef GrTextContext INHERITED;
@@ skipping 40 matching lines @@
 
     void init(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
               const SkIRect& regionClipBounds);
     void appendGlyph(GrGlyph::PackedID, SkFixed left, SkFixed top, GrFontScaler*);
     bool uploadGlyph(GrGlyph*, GrFontScaler*);
     void flush();                 // automatically called by destructor
     void finish();
 };
 
 #endif