Add Gpu Tracing to Ganesh

src/gpu/GrInOrderDrawBuffer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrInOrderDrawBuffer.h"
 
 #include "GrBufferAllocPool.h"
@@ skipping 238 matching lines @@
 
     // we only attempt to concat the case when reserved verts are used with a client-specified index
     // buffer. To make this work with client-specified VBs we'd need to know if the VB was updated
     // between draws.
     if (kReserved_GeometrySrcType != geomSrc.fVertexSrc ||
         kBuffer_GeometrySrcType != geomSrc.fIndexSrc) {
         return 0;
     }
     // Check if there is a draw info that is compatible that uses the same VB from the pool and
     // the same IB
-    if (kDraw_Cmd != fCmds.back()) {
+    if (kDraw_Cmd != stripTraceBit(fCmds.back())) {
         return 0;
     }
 
     DrawRecord* draw = &fDraws.back();
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     const GrVertexBuffer* vertexBuffer = poolState.fPoolVertexBuffer;
 
     if (!draw->isInstanced() ||
         draw->verticesPerInstance() != info.verticesPerInstance() ||
         draw->indicesPerInstance() != info.indicesPerInstance() ||
@@ skipping 14 matching lines @@
     int instancesToConcat = this->indexCountInCurrentSource() / info.indicesPerInstance();
     instancesToConcat -= draw->instanceCount();
     instancesToConcat = GrMin(instancesToConcat, info.instanceCount());
 
     // update the amount of reserved vertex data actually referenced in draws
     size_t vertexBytes = instancesToConcat * info.verticesPerInstance() *
                          drawState.getVertexSize();
     poolState.fUsedPoolVertexBytes = GrMax(poolState.fUsedPoolVertexBytes, vertexBytes);
 
     draw->adjustInstanceCount(instancesToConcat);
+
+    // update last fGpuCmdMarkers to include any additional trace markers that have been added
+    if (this->getActiveTraceMarkers()->count() > 0) {
+        if (fCmds.back() & 0x08) {

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

use enum value

+            fNumMarkersPerCmd.top() += this->getActiveTraceMarkers()->count();
+        } else {
+            fNumMarkersPerCmd.push(this->getActiveTraceMarkers()->count());
+            fCmds.back() = addTraceBit(fCmds.back());
+        }
+        for (int i = 0; i < this->getActiveTraceMarkers()->count(); ++i) {
+            fGpuCmdMarkers.push(this->getActiveTraceMarkers()->getAt(i));
+        }
+    }
+
     return instancesToConcat;
 }
 
 class AutoClipReenable {
 public:
     AutoClipReenable() : fDrawState(NULL) {}
     ~AutoClipReenable() {
         if (NULL != fDrawState) {
             fDrawState->enableState(GrDrawState::kClip_StateBit);
         }
@@ skipping 24 matching lines @@
        this->recordClip();
     }
     if (this->needsNewState()) {
         this->recordState();
     }
 
     DrawRecord* draw;
     if (info.isInstanced()) {
         int instancesConcated = this->concatInstancedDraw(info);
         if (info.instanceCount() > instancesConcated) {
+            // grab cmd lock
             draw = this->recordDraw(info);
             draw->adjustInstanceCount(-instancesConcated);
         } else {
             return;
         }
     } else {
         draw = this->recordDraw(info);
     }
 
     switch (this->getGeomSrc().fVertexSrc) {
@@ skipping 86 matching lines @@
         rect = &r;
     }
     Clear* clr = this->recordClear();
     clr->fColor = color;
     clr->fRect = *rect;
     clr->fCanIgnoreRect = canIgnoreRect;
     clr->fRenderTarget = renderTarget;
     renderTarget->ref();
 }
 
-void GrInOrderDrawBuffer::onInstantGpuTraceEvent(const char* marker) {
-    // TODO: adds command to buffer
-}
-
-void GrInOrderDrawBuffer::onPushGpuTraceEvent(const char* marker) {
-    // TODO: adds command to buffer
-}
-
-void GrInOrderDrawBuffer::onPopGpuTraceEvent() {
-    // TODO: adds command to buffer
-}
-
 void GrInOrderDrawBuffer::reset() {
     SkASSERT(1 == fGeoPoolStateStack.count());
     this->resetVertexSource();
     this->resetIndexSource();
     int numDraws = fDraws.count();
     for (int d = 0; d < numDraws; ++d) {
         // we always have a VB, but not always an IB
         SkASSERT(NULL != fDraws[d].fVertexBuffer);
         fDraws[d].fVertexBuffer->unref();
         SkSafeUnref(fDraws[d].fIndexBuffer);
     }
     fCmds.reset();
     fDraws.reset();
     fStencilPaths.reset();
     fDrawPaths.reset();
     fStates.reset();
     fClears.reset();
     fVertexPool.reset();
     fIndexPool.reset();
     fClips.reset();
     fClipOrigins.reset();
     fCopySurfaces.reset();
+    fGpuCmdMarkers.reset();
+    fNumMarkersPerCmd.reset();
     fClipSet = true;
 }
 
 void GrInOrderDrawBuffer::flush() {
     if (fFlushing) {
         return;
     }
 
     SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fVertexSrc);
     SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fIndexSrc);
@@ skipping 12 matching lines @@
     GrDrawTarget::AutoClipRestore acr(fDstGpu);
     AutoGeometryAndStatePush agasp(fDstGpu, kPreserve_ASRInit);
 
     GrDrawState playbackState;
     GrDrawState* prevDrawState = fDstGpu->drawState();
     prevDrawState->ref();
     fDstGpu->setDrawState(&playbackState);
 
     GrClipData clipData;
 
-    int currState       = 0;
-    int currClip        = 0;
-    int currClear       = 0;
-    int currDraw        = 0;
-    int currStencilPath = 0;
-    int currDrawPath    = 0;
-    int currCopySurface = 0;
+    int currState               = 0;
+    int currClip                = 0;
+    int currClear               = 0;
+    int currDraw                = 0;
+    int currStencilPath         = 0;
+    int currDrawPath            = 0;
+    int currCopySurface         = 0;
+    int currCmdMarker           = 0;
+    int currCmdMarkerIndex      = 0;
 
     for (int c = 0; c < numCmds; ++c) {
-        switch (fCmds[c]) {
+        GpuTraceMarker newMarker("", -1);
+        if (fCmds[c] & 0x08) {

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

use enum, or perhaps better add a function CmdHasTraceMarker(fCmds[c]) or
something like that.

+            SkString traceString = getTraceString(&fGpuCmdMarkers, currCmdMarkerIndex,
+                                                  fNumMarkersPerCmd[currCmdMarker]);
+            newMarker.fMarker = traceString.c_str();
+            fDstGpu->addGpuTraceMarker(&newMarker);
+            currCmdMarkerIndex += fNumMarkersPerCmd[currCmdMarker];
+            ++currCmdMarker;
+        }
+        switch (stripTraceBit(fCmds[c])) {

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

this-> but really the functions should probably be static 

             case kDraw_Cmd: {
                 const DrawRecord& draw = fDraws[currDraw];
                 fDstGpu->setVertexSourceToBuffer(draw.fVertexBuffer);
                 if (draw.isIndexed()) {
                     fDstGpu->setIndexSourceToBuffer(draw.fIndexBuffer);
                 }
                 fDstGpu->executeDraw(draw);
-
                 ++currDraw;
                 break;
             }
             case kStencilPath_Cmd: {
                 const StencilPath& sp = fStencilPaths[currStencilPath];
                 fDstGpu->stencilPath(sp.fPath.get(), sp.fFill);
                 ++currStencilPath;
                 break;
             }
             case kDrawPath_Cmd: {
@@ skipping 21 matching lines @@
                 ++currClear;
                 break;
             case kCopySurface_Cmd:
                 fDstGpu->copySurface(fCopySurfaces[currCopySurface].fDst.get(),
                                      fCopySurfaces[currCopySurface].fSrc.get(),
                                      fCopySurfaces[currCopySurface].fSrcRect,
                                      fCopySurfaces[currCopySurface].fDstPoint);
                 ++currCopySurface;
                 break;
         }
+        if (fCmds[c] & 0x08) {

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

enum/function

+            fDstGpu->removeGpuTraceMarker(&newMarker);
+        }
     }
     // we should have consumed all the states, clips, etc.
     SkASSERT(fStates.count() == currState);
     SkASSERT(fClips.count() == currClip);
     SkASSERT(fClipOrigins.count() == currClip);
     SkASSERT(fClears.count() == currClear);
     SkASSERT(fDraws.count()  == currDraw);
     SkASSERT(fCopySurfaces.count() == currCopySurface);
+    SkASSERT(fGpuCmdMarkers.count() == currCmdMarkerIndex);
+    SkASSERT(fNumMarkersPerCmd.count() == currCmdMarker);
 
     fDstGpu->setDrawState(prevDrawState);
     prevDrawState->unref();
     this->reset();
     ++fDrawID;
 }
 
 bool GrInOrderDrawBuffer::onCopySurface(GrSurface* dst,
                                         GrSurface* src,
                                         const SkIRect& srcRect,
@@ skipping 235 matching lines @@
        if (fClipSet &&
            (fClips.empty() ||
             fClips.back() != *this->getClip()->fClipStack ||
             fClipOrigins.back() != this->getClip()->fOrigin)) {
            return true;
        }
     }
     return false;
 }
 
+void GrInOrderDrawBuffer::addToCmdBuffer(uint8_t cmd) {
+    SkTDArray<GpuTraceMarker>* activeTraceMarkers = this->getActiveTraceMarkers();
+    if (activeTraceMarkers->count() > 0) {
+        fCmds.push_back(addTraceBit(cmd));
+        for (int i = 0; i < activeTraceMarkers->count(); ++i) {
+            fGpuCmdMarkers.push(activeTraceMarkers->getAt(i));
+        }
+        fNumMarkersPerCmd.push(activeTraceMarkers->count());
+    } else {
+        fCmds.push_back(cmd);
+    }
+}
+
 void GrInOrderDrawBuffer::recordClip() {
-    fClips.push_back() = *this->getClip()->fClipStack;
+    fClips.push_back(*this->getClip()->fClipStack);
     fClipOrigins.push_back() = this->getClip()->fOrigin;
     fClipSet = false;
-    fCmds.push_back(kSetClip_Cmd);
+    addToCmdBuffer(kSetClip_Cmd);

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

this->

here and below

 }
 
 void GrInOrderDrawBuffer::recordState() {
     fStates.push_back().saveFrom(this->getDrawState());
-    fCmds.push_back(kSetState_Cmd);
+    addToCmdBuffer(kSetState_Cmd);
 }
 
 GrInOrderDrawBuffer::DrawRecord* GrInOrderDrawBuffer::recordDraw(const DrawInfo& info) {
-    fCmds.push_back(kDraw_Cmd);
+    addToCmdBuffer(kDraw_Cmd);
     return &fDraws.push_back(info);
 }
 
 GrInOrderDrawBuffer::StencilPath* GrInOrderDrawBuffer::recordStencilPath() {
-    fCmds.push_back(kStencilPath_Cmd);
+    addToCmdBuffer(kStencilPath_Cmd);
     return &fStencilPaths.push_back();
 }
 
 GrInOrderDrawBuffer::DrawPath* GrInOrderDrawBuffer::recordDrawPath() {
-    fCmds.push_back(kDrawPath_Cmd);
+    addToCmdBuffer(kDrawPath_Cmd);
     return &fDrawPaths.push_back();
 }
 
 GrInOrderDrawBuffer::Clear* GrInOrderDrawBuffer::recordClear() {
-    fCmds.push_back(kClear_Cmd);
+    addToCmdBuffer(kClear_Cmd);
     return &fClears.push_back();
 }
 
 GrInOrderDrawBuffer::CopySurface* GrInOrderDrawBuffer::recordCopySurface() {
-    fCmds.push_back(kCopySurface_Cmd);
+    addToCmdBuffer(kCopySurface_Cmd);
     return &fCopySurfaces.push_back();
 }
 
-
 void GrInOrderDrawBuffer::clipWillBeSet(const GrClipData* newClipData) {
     INHERITED::clipWillBeSet(newClipData);
     fClipSet = true;
     fClipProxyState = kUnknown_ClipProxyState;
 }