Add Gpu Tracing to Ganesh

src/gpu/GrInOrderDrawBuffer.cpp

Index: src/gpu/GrInOrderDrawBuffer.cpp
diff --git a/src/gpu/GrInOrderDrawBuffer.cpp b/src/gpu/GrInOrderDrawBuffer.cpp
index 44bf4edab7aa7aefdae0a1d282af4dc3370a533b..bec2fbf91504bfe3e487ab0c7d81a1342dcaed53 100644
--- a/src/gpu/GrInOrderDrawBuffer.cpp
+++ b/src/gpu/GrInOrderDrawBuffer.cpp
@@ -256,7 +256,7 @@ int GrInOrderDrawBuffer::concatInstancedDraw(const DrawInfo& info) {
     }
     // 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;
     }
 
@@ -291,6 +291,20 @@ int GrInOrderDrawBuffer::concatInstancedDraw(const DrawInfo& info) {
     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;
 }
 
@@ -335,6 +349,7 @@ void GrInOrderDrawBuffer::onDraw(const DrawInfo& info) {
     if (info.isInstanced()) {
         int instancesConcated = this->concatInstancedDraw(info);
         if (info.instanceCount() > instancesConcated) {
+            // grab cmd lock
             draw = this->recordDraw(info);
             draw->adjustInstanceCount(-instancesConcated);
         } else {
@@ -441,18 +456,6 @@ void GrInOrderDrawBuffer::clear(const SkIRect* rect, GrColor color,
     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();
@@ -475,6 +478,8 @@ void GrInOrderDrawBuffer::reset() {
     fClips.reset();
     fClipOrigins.reset();
     fCopySurfaces.reset();
+    fGpuCmdMarkers.reset();
+    fNumMarkersPerCmd.reset();
     fClipSet = true;
 }
 
@@ -507,16 +512,27 @@ void GrInOrderDrawBuffer::flush() {
 
     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);
@@ -524,7 +540,6 @@ void GrInOrderDrawBuffer::flush() {
                     fDstGpu->setIndexSourceToBuffer(draw.fIndexBuffer);
                 }
                 fDstGpu->executeDraw(draw);
-
                 ++currDraw;
                 break;
             }
@@ -566,6 +581,9 @@ void GrInOrderDrawBuffer::flush() {
                 ++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);
@@ -574,6 +592,8 @@ void GrInOrderDrawBuffer::flush() {
     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();
@@ -829,44 +849,56 @@ bool GrInOrderDrawBuffer::needsNewClip() const {
     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;