Add Gpu Tracing to Ganesh

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 63 matching lines @@
                        bool canIgnoreRect,
                        GrRenderTarget* renderTarget = NULL) SK_OVERRIDE;
 
     virtual void initCopySurfaceDstDesc(const GrSurface* src, GrTextureDesc* desc) SK_OVERRIDE;
 
 protected:
     virtual void clipWillBeSet(const GrClipData* newClip) SK_OVERRIDE;
 
 private:
     enum Cmd {
-        kDraw_Cmd           = 1,
-        kStencilPath_Cmd    = 2,
-        kSetState_Cmd       = 3,
-        kSetClip_Cmd        = 4,
-        kClear_Cmd          = 5,
-        kCopySurface_Cmd    = 6,
-        kDrawPath_Cmd       = 7,
+        kDraw_Cmd               = 1,
+        kStencilPath_Cmd        = 2,
+        kSetState_Cmd           = 3,
+        kSetClip_Cmd            = 4,
+        kClear_Cmd              = 5,
+        kCopySurface_Cmd        = 6,
+        kDrawPath_Cmd           = 7,
     };
 
     class DrawRecord : public DrawInfo {
     public:
         DrawRecord(const DrawInfo& info) : DrawInfo(info) {}
         const GrVertexBuffer*   fVertexBuffer;
         const GrIndexBuffer*    fIndexBuffer;
     };
 
     struct StencilPath : public ::SkNoncopyable {
@@ skipping 60 matching lines @@
                                GrSurface* src,
                                const SkIRect& srcRect,
                                const SkIPoint& dstPoint)  SK_OVERRIDE;
     virtual bool onCanCopySurface(GrSurface* dst,
                                   GrSurface* src,
                                   const SkIRect& srcRect,
                                   const SkIPoint& dstPoint) SK_OVERRIDE;
 
     bool quickInsideClip(const SkRect& devBounds);
 
-    virtual void onInstantGpuTraceEvent(const char* marker) SK_OVERRIDE;
-    virtual void onPushGpuTraceEvent(const char* marker) SK_OVERRIDE;
-    virtual void onPopGpuTraceEvent() SK_OVERRIDE;
-
+    virtual void onAddGpuTraceMarker() SK_OVERRIDE {};
+    virtual void onRemoveGpuTraceMarker() SK_OVERRIDE {};
 
     // Attempts to concat instances from info onto the previous draw. info must represent an
     // instanced draw. The caller must have already recorded a new draw state and clip if necessary.
     int concatInstancedDraw(const DrawInfo& info);
 
     // we lazily record state and clip changes in order to skip clips and states that have no
     // effect.
     bool needsNewState() const;
     bool needsNewClip() const;
 
     // these functions record a command
-    void            recordState();
-    void            recordClip();
-    DrawRecord*     recordDraw(const DrawInfo&);
-    StencilPath*    recordStencilPath();
-    DrawPath*       recordDrawPath();
-    Clear*          recordClear();
-    CopySurface*    recordCopySurface();
+    void                recordState();
+    void                recordClip();
+    DrawRecord*         recordDraw(const DrawInfo&);
+    StencilPath*        recordStencilPath();
+    DrawPath*           recordDrawPath();
+    Clear*              recordClear();
+    CopySurface*        recordCopySurface();
+
+    // get name out of trace set
+    const char*         getCurrentTraceMarker();
 
     // TODO: Use a single allocator for commands and records
     enum {
         kCmdPreallocCnt          = 32,
         kDrawPreallocCnt         = 8,
         kStencilPathPreallocCnt  = 8,
         kDrawPathPreallocCnt     = 8,
         kStatePreallocCnt        = 8,
         kClipPreallocCnt         = 8,
         kClearPreallocCnt        = 4,
         kGeoPoolStatePreAllocCnt = 4,
         kCopySurfacePreallocCnt  = 4,
     };
 
     SkSTArray<kCmdPreallocCnt, uint8_t, true>                          fCmds;
     GrSTAllocator<kDrawPreallocCnt, DrawRecord>                        fDraws;
     GrSTAllocator<kStatePreallocCnt, StencilPath>                      fStencilPaths;
     GrSTAllocator<kStatePreallocCnt, DrawPath>                         fDrawPaths;
     GrSTAllocator<kStatePreallocCnt, GrDrawState::DeferredState>       fStates;
     GrSTAllocator<kClearPreallocCnt, Clear>                            fClears;
     GrSTAllocator<kCopySurfacePreallocCnt, CopySurface>                fCopySurfaces;
     GrSTAllocator<kClipPreallocCnt, SkClipStack>                       fClips;
     GrSTAllocator<kClipPreallocCnt, SkIPoint>                          fClipOrigins;
+    SkTDArray<GpuTraceMarker>                                          fGpuCmdMarkers;
+    SkTDArray<int>                                                     fNumMarkersPerCmd;
 
     GrDrawTarget*                   fDstGpu;
 
     bool                            fClipSet;
 
     enum ClipProxyState {
         kUnknown_ClipProxyState,
         kValid_ClipProxyState,
         kInvalid_ClipProxyState
     };
@@ skipping 12 matching lines @@
         // 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;
     };
     SkSTArray<kGeoPoolStatePreAllocCnt, GeometryPoolState> fGeoPoolStateStack;
 
     virtual bool       isIssued(uint32_t drawID) { return drawID != fDrawID; }
 
+    void addToCmdBuffer(uint8_t cmd);
+
+    inline uint8_t addTraceBit(uint8_t cmd) {
+        return cmd | 0x08;

[bsalomon, 2014/03/17 17:50:38]

Can we put these in an enum?

e.g.

enum {
   kTraceCmdBit = 0x80,
   kCmdMask     = 0x7f,
};

[egdaniel, 2014/03/17 19:49:12]

yes!
On 2014/03/17 17:50:38, bsalomon wrote:

+    }
+
+    inline uint8_t stripTraceBit(uint8_t cmd) {
+        return cmd & 0x07;

[bsalomon, 2014/03/17 17:50:38]

7f?

[egdaniel, 2014/03/17 19:49:12]

Currently the commands we use only go to 7 so I just used the next available
bit, but I guess if we ever expand the set of commands its better to just use
the far left bit.
On 2014/03/17 17:50:38, bsalomon wrote:

[bsalomon, 2014/03/19 13:28:44]

Yeah, I think it is safer to use 7f. If someone updates the bit enum (suggested
in above comment) then they'll see the mask and update it. If someone adds a new
Cmd they might forget to update it.

addToCmdBuffer() should assert that the cmd param doesn't have any bits set not
in 0x7f if it doesn't already.

[egdaniel, 2014/03/19 14:27:03]

Assert has been added in the newest version

On 2014/03/19 13:28:44, bsalomon wrote:

+    }
+
     bool                            fFlushing;
     uint32_t                        fDrawID;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif