Combine similar DrawPaths calls in GrInOrderDrawBuffer

src/gpu/GrInOrderDrawBuffer.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrInOrderDrawBuffer_DEFINED
 #define GrInOrderDrawBuffer_DEFINED
 
@@ skipping 37 matching lines @@
      *                   the vertex source is either reserved or array.
      * @param indexPool  pool where indices for queued draws will be saved when
      *                   the index source is either reserved or array.
      */
     GrInOrderDrawBuffer(GrGpu* gpu,
                         GrVertexBufferAllocPool* vertexPool,
                         GrIndexBufferAllocPool* indexPool);
 
     virtual ~GrInOrderDrawBuffer();
 
+    GrGpu* dstGpu() const { return fDstGpu; }
+    const uint32_t* pathIndexBuffer() const { return fPathIndexBuffer; }
+    const float* pathTransformBuffer() const { return fPathTransformBuffer; }
+
     /**
      * Empties the draw buffer of any queued up draws. This must not be called while inside an
      * unbalanced pushGeometrySource(). The current draw state and clip are preserved.
      */
     void reset();
 
     /**
      * This plays the queued up draws to its GrGpu target. It also resets this object (i.e. flushing
      * is destructive). This buffer must not have an active reserved vertex or index source. Any
      * reserved geometry on the target will be finalized because it's geometry source will be pushed
@@ skipping 35 matching lines @@
         kClear_Cmd          = 4,
         kCopySurface_Cmd    = 5,
         kDrawPath_Cmd       = 6,
         kDrawPaths_Cmd      = 7,
     };
 
     struct Cmd : ::SkNoncopyable {
         Cmd(uint8_t type) : fType(type) {}
         virtual ~Cmd() {}
 
-        virtual void execute(GrGpu*) = 0;
+        virtual void execute(GrInOrderDrawBuffer*) = 0;
 
         uint8_t fType;
     };
 
     struct Draw : public Cmd {
         Draw(const DrawInfo& info,
              const ScissorState& scissorState,
              const GrVertexBuffer* vb,
              const GrIndexBuffer* ib)
             : Cmd(kDraw_Cmd)
             , fInfo(info)
             , fScissorState(scissorState)
             , fVertexBuffer(vb)
             , fIndexBuffer(ib) {}
 
         const GrVertexBuffer* vertexBuffer() const { return fVertexBuffer.get(); }
         const GrIndexBuffer* indexBuffer() const { return fIndexBuffer.get(); }
 
-        virtual void execute(GrGpu*);
+        virtual void execute(GrInOrderDrawBuffer*);
 
         DrawInfo     fInfo;
         ScissorState fScissorState;
 
     private:
         GrPendingIOResource<const GrVertexBuffer, kRead_GrIOType>    fVertexBuffer;
         GrPendingIOResource<const GrIndexBuffer, kRead_GrIOType>     fIndexBuffer;
     };
 
     struct StencilPath : public Cmd {
         StencilPath(const GrPath* path) : Cmd(kStencilPath_Cmd), fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
-        virtual void execute(GrGpu*);
+        virtual void execute(GrInOrderDrawBuffer*);
 
         ScissorState      fScissorState;
         GrStencilSettings fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPath, kRead_GrIOType>   fPath;
     };
 
     struct DrawPath : public Cmd {
         DrawPath(const GrPath* path) : Cmd(kDrawPath_Cmd), fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
-        virtual void execute(GrGpu*);
+        virtual void execute(GrInOrderDrawBuffer*);
 
         GrDeviceCoordTexture    fDstCopy;
         ScissorState            fScissorState;
         GrStencilSettings       fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPath, kRead_GrIOType> fPath;
     };
 
     struct DrawPaths : public Cmd {
         DrawPaths(const GrPathRange* pathRange) : Cmd(kDrawPaths_Cmd), fPathRange(pathRange) {}
 
         const GrPathRange* pathRange() const { return fPathRange.get();  }
-        uint32_t* indices() { return reinterpret_cast<uint32_t*>(CmdBuffer::GetDataForItem(this)); }
-        float* transforms() { return reinterpret_cast<float*>(&this->indices()[fCount]); }
 
-        virtual void execute(GrGpu*);
+        virtual void execute(GrInOrderDrawBuffer*);
 
+        int                     fIndicesLocation;
         size_t                  fCount;
+        int                     fTransformsLocation;
         PathTransformType       fTransformsType;
         GrDeviceCoordTexture    fDstCopy;
         ScissorState            fScissorState;
         GrStencilSettings       fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPathRange, kRead_GrIOType> fPathRange;
     };
 
     // This is also used to record a discard by setting the color to GrColor_ILLEGAL
     struct Clear : public Cmd {
         Clear(GrRenderTarget* rt) : Cmd(kClear_Cmd), fRenderTarget(rt) {}
 
         GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
 
-        virtual void execute(GrGpu*);
+        virtual void execute(GrInOrderDrawBuffer*);
 
         SkIRect fRect;
         GrColor fColor;
         bool    fCanIgnoreRect;
 
     private:
         GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> fRenderTarget;
     };
 
     // This command is ONLY used by the clip mask manager to clear the stencil clip bits
     struct ClearStencilClip : public Cmd {
         ClearStencilClip(GrRenderTarget* rt) : Cmd(kClear_Cmd), fRenderTarget(rt) {}
 
         GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
 
-        virtual void execute(GrGpu*);
+        virtual void execute(GrInOrderDrawBuffer*);
 
         SkIRect fRect;
         bool    fInsideClip;
 
     private:
         GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> fRenderTarget;
     };
 
     struct CopySurface : public Cmd {
         CopySurface(GrSurface* dst, GrSurface* src) : Cmd(kCopySurface_Cmd), fDst(dst), fSrc(src) {}
 
         GrSurface* dst() const { return fDst.get(); }
         GrSurface* src() const { return fSrc.get(); }
 
-        virtual void execute(GrGpu*);
+        virtual void execute(GrInOrderDrawBuffer*);
 
         SkIPoint    fDstPoint;
         SkIRect     fSrcRect;
 
     private:
         GrPendingIOResource<GrSurface, kWrite_GrIOType> fDst;
         GrPendingIOResource<GrSurface, kRead_GrIOType> fSrc;
     };
 
     struct SetState : public Cmd {
         SetState(const GrDrawState& state) : Cmd(kSetState_Cmd), fState(state) {}
 
-        virtual void execute(GrGpu*);
+        virtual void execute(GrInOrderDrawBuffer*);
 
         GrDrawState fState;
     };
 
     typedef void* TCmdAlign; // This wouldn't be enough align if a command used long double.
     typedef GrTRecorder<Cmd, TCmdAlign> CmdBuffer;
 
     // overrides from GrDrawTarget
     virtual void onDraw(const DrawInfo&, const GrClipMaskManager::ScissorState&) SK_OVERRIDE;
     virtual void onDrawRect(const SkRect& rect,
@@ skipping 41 matching lines @@
     // We lazily record clip changes in order to skip clips that have no effect.
     void recordClipIfNecessary();
     // Records any trace markers for a command after adding it to the buffer.
     void recordTraceMarkersIfNecessary();
 
     virtual bool isIssued(uint32_t drawID) { return drawID != fDrawID; }
 
     // TODO: Use a single allocator for commands and records
     enum {
         kCmdBufferInitialSizeInBytes = 8 * 1024,
+        kPathIdxBufferMinAllocCnt    = 64,
+        kPathXformBufferMinAllocCnt  = 2 * kPathIdxBufferMinAllocCnt,
         kGeoPoolStatePreAllocCnt     = 4,
     };
 
     CmdBuffer                         fCmdBuffer;
     GrDrawState*                      fLastState;
     SkTArray<GrTraceMarkerSet, false> fGpuCmdMarkers;
     GrGpu*                            fDstGpu;
     GrVertexBufferAllocPool&          fVertexPool;
     GrIndexBufferAllocPool&           fIndexPool;
 
+    template<typename T> class DataBuffer : SkNoncopyable {

[bsalomon, 2014/11/11 14:41:25]

Could you use SkTDArray here instead of a new type?

[Chris Dalton, 2014/11/11 17:49:07]

I did look into this.

* SkTDArray doesn't grow exponentially, and only barely grows enough to squeeze
in the new data when its out of room for an append. So unless it has enough
memory preallocated ahead of time, it has to do a realloc on every onDrawPaths
call.

* SkTArray does grow exponentially, but can't reset the count to 0 without
deleting its memory, so we can't hold on to the already-allocated memory for
future draws.

* Neither SkTDArray nor SkTArray (if it had the ability to not delete memory
after reset) have built-in logic for reducing the amount of memory reserved once
we start using less. SkTDArray does give enough control that we could run the
logic ourselves within GrInOrderDrawBuffer::reset(), but that takes about the
same amount of extra code as this class.

* Would it be possible to expose a bit of new functionality on SkTArray? I think
we could use it if it let us change fReserveCount on the fly.

* Otherwise, this class is pretty minimal. It's mostly just a wrapper for
SkAutoTMalloc plus logic to try and adapt the amount of reserved memory to the
amount being required during each draw.

+    public:
+        DataBuffer(int minAllocCnt) : fMinAllocCnt(minAllocCnt), fAllocCnt(0), fCount(0) {}
+        operator const T*() const { return fBuffer; }
+        int append(const T* array, int count);
+        void reset();
+    private:
+        SkAutoTMalloc<T> fBuffer;
+        const int        fMinAllocCnt;
+        int              fAllocCnt;
+        int              fCount;
+    };
+
+    DataBuffer<uint32_t>                                fPathIndexBuffer;
+    DataBuffer<float>                                   fPathTransformBuffer;
+
     struct GeometryPoolState {
         const GrVertexBuffer*   fPoolVertexBuffer;
         int                     fPoolStartVertex;
         const GrIndexBuffer*    fPoolIndexBuffer;
         int                     fPoolStartIndex;
         // caller may conservatively over reserve vertices / indices.
         // we release unused space back to allocator if possible
         // can only do this if there isn't an intervening pushGeometrySource()
         size_t                  fUsedPoolVertexBytes;
         size_t                  fUsedPoolIndexBytes;
     };
 
     typedef SkSTArray<kGeoPoolStatePreAllocCnt, GeometryPoolState> GeoPoolStateStack;
 
     GeoPoolStateStack                                   fGeoPoolStateStack;
     bool                                                fFlushing;
     uint32_t                                            fDrawID;
 
     typedef GrClipTarget INHERITED;
 };
 
 #endif