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 100 matching lines @@
     } else if (hasUVs) {
         *localOffset = sizeof(GrPoint);
         drawState->setVertexAttribs<kRectPosUVAttribs>(2);
     } else {
         drawState->setVertexAttribs<kRectPosUVAttribs>(1);
     }
 }
 
 };
 
+enum {
+    kTraceCmdBit = 0x80,
+    kCmdMask = 0x7f,
+};
+
+static uint8_t add_trace_bit(uint8_t cmd) {
+    return cmd | kTraceCmdBit;
+}
+
+static uint8_t strip_trace_bit(uint8_t cmd) {
+    return cmd & kCmdMask;
+}
+
+static bool cmd_has_trace_marker(uint8_t cmd) {
+    return cmd & kTraceCmdBit;
+}
+
 void GrInOrderDrawBuffer::onDrawRect(const SkRect& rect,
                                      const SkMatrix* matrix,
                                      const SkRect* localRect,
                                      const SkMatrix* localMatrix) {
     GrDrawState::AutoColorRestore acr;
 
     GrDrawState* drawState = this->drawState();
 
     GrColor color = drawState->getColor();
 
@@ skipping 118 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 != strip_trace_bit(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 (cmd_has_trace_marker(fCmds.back())) {
+            fGpuCmdMarkers.back().addSet(this->getActiveTraceMarkers());
+        } else {
+            fGpuCmdMarkers.push_back(this->getActiveTraceMarkers());
+            fCmds.back() = add_trace_bit(fCmds.back());
+        }
+    }
+
     return instancesToConcat;
 }
 
 class AutoClipReenable {
 public:
     AutoClipReenable() : fDrawState(NULL) {}
     ~AutoClipReenable() {
         if (NULL != fDrawState) {
             fDrawState->enableState(GrDrawState::kClip_StateBit);
         }
@@ skipping 130 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();
     fClipSet = true;
 }
 
 void GrInOrderDrawBuffer::flush() {
     if (fFlushing) {
         return;
     }
 
     SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fVertexSrc);
     SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fIndexSrc);
@@ skipping 19 matching lines @@
 
     GrClipData clipData;
 
     int currState       = 0;
     int currClip        = 0;
     int currClear       = 0;
     int currDraw        = 0;
     int currStencilPath = 0;
     int currDrawPath    = 0;
     int currCopySurface = 0;
+    int currCmdMarker   = 0;
 
     for (int c = 0; c < numCmds; ++c) {
-        switch (fCmds[c]) {
+        GrGpuTraceMarker newMarker("", -1);
+        if (cmd_has_trace_marker(fCmds[c])) {
+            SkString traceString = fGpuCmdMarkers[currCmdMarker].toString();
+            newMarker.fMarker = traceString.c_str();
+            fDstGpu->addGpuTraceMarker(&newMarker);
+            ++currCmdMarker;
+        }
+        switch (strip_trace_bit(fCmds[c])) {
             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 (cmd_has_trace_marker(fCmds[c])) {
+            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() == 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) {
+    SkASSERT(!cmd_has_trace_marker(cmd));
+    const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
+    if (activeTraceMarkers.count() > 0) {
+        fCmds.push_back(add_trace_bit(cmd));
+        fGpuCmdMarkers.push_back(activeTraceMarkers);
+    } 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);
+    this->addToCmdBuffer(kSetClip_Cmd);
 }
 
 void GrInOrderDrawBuffer::recordState() {
     fStates.push_back().saveFrom(this->getDrawState());
-    fCmds.push_back(kSetState_Cmd);
+    this->addToCmdBuffer(kSetState_Cmd);
 }
 
 GrInOrderDrawBuffer::DrawRecord* GrInOrderDrawBuffer::recordDraw(const DrawInfo& info) {
-    fCmds.push_back(kDraw_Cmd);
+    this->addToCmdBuffer(kDraw_Cmd);
     return &fDraws.push_back(info);
 }
 
 GrInOrderDrawBuffer::StencilPath* GrInOrderDrawBuffer::recordStencilPath() {
-    fCmds.push_back(kStencilPath_Cmd);
+    this->addToCmdBuffer(kStencilPath_Cmd);
     return &fStencilPaths.push_back();
 }
 
 GrInOrderDrawBuffer::DrawPath* GrInOrderDrawBuffer::recordDrawPath() {
-    fCmds.push_back(kDrawPath_Cmd);
+    this->addToCmdBuffer(kDrawPath_Cmd);
     return &fDrawPaths.push_back();
 }
 
 GrInOrderDrawBuffer::Clear* GrInOrderDrawBuffer::recordClear() {
-    fCmds.push_back(kClear_Cmd);
+    this->addToCmdBuffer(kClear_Cmd);
     return &fClears.push_back();
 }
 
 GrInOrderDrawBuffer::CopySurface* GrInOrderDrawBuffer::recordCopySurface() {
-    fCmds.push_back(kCopySurface_Cmd);
+    this->addToCmdBuffer(kCopySurface_Cmd);
     return &fCopySurfaces.push_back();
 }
 
 
 void GrInOrderDrawBuffer::clipWillBeSet(const GrClipData* newClipData) {
     INHERITED::clipWillBeSet(newClipData);
     fClipSet = true;
     fClipProxyState = kUnknown_ClipProxyState;
 }