Add Gpu Tracing to Ganesh

src/gpu/GrDrawTarget.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 
 #include "GrDrawTarget.h"
 #include "GrContext.h"
 #include "GrDrawTargetCaps.h"
 #include "GrPath.h"
 #include "GrRenderTarget.h"
 #include "GrTexture.h"
 #include "GrVertexBuffer.h"
 
 #include "SkStrokeRec.h"
+#include "SkTSort.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrDrawTarget::DrawInfo& GrDrawTarget::DrawInfo::operator =(const DrawInfo& di) {
     fPrimitiveType  = di.fPrimitiveType;
     fStartVertex    = di.fStartVertex;
     fStartIndex     = di.fStartIndex;
     fVertexCount    = di.fVertexCount;
     fIndexCount     = di.fIndexCount;
 
@@ skipping 52 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define DEBUG_INVAL_BUFFER 0xdeadcafe
 #define DEBUG_INVAL_START_IDX -1
 
 GrDrawTarget::GrDrawTarget(GrContext* context)
     : fClip(NULL)
     , fContext(context)
-    , fPushGpuTraceCount(0) {
+    , fGpuTraceMarkerCount(0) {
     SkASSERT(NULL != context);
 
     fDrawState = &fDefaultDrawState;
     // We assume that fDrawState always owns a ref to the object it points at.
     fDefaultDrawState.ref();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.push_back();
 #ifdef SK_DEBUG
     geoSrc.fVertexCount = DEBUG_INVAL_START_IDX;
     geoSrc.fVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
     geoSrc.fIndexCount = DEBUG_INVAL_START_IDX;
@@ skipping 438 matching lines @@
     viewM.mapRect(&devBounds);
 
     GrDeviceCoordTexture dstCopy;
     if (!this->setupDstReadIfNecessary(&dstCopy, &devBounds)) {
         return;
     }
 
     this->onDrawPath(path, fill, dstCopy.texture() ? &dstCopy : NULL);
 }
 
-void GrDrawTarget::instantGpuTraceEvent(const char* marker) {
+SkString GrDrawTarget::getTraceString(SkTDArray<GpuTraceMarker>* markerArray,
+                                      int startIdx, int numMarkers) {
+    SkTQSort<GpuTraceMarker>(markerArray->begin() + startIdx,
+                             markerArray->begin() + startIdx + numMarkers - 1);
+    SkString marker_string;
+    const char* currBaseCmd = "";

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

It took me a little bit to understand what this is used for. It might be clearer
if it were named something like prevMarkerName since it is used to check whether
the previous marker had the same name as the current one.

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

Agree.

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

+    int counter = 0;
+
+    // check used for GrGpuGL device after we've already collapsed all markers
+    if (1 == numMarkers && -1 == (*markerArray)[0].fID) {
+        marker_string.append((*markerArray)[0].fMarker);
+        return marker_string;
+    }
+
+    for (int i = startIdx; counter < numMarkers; ++i ) {
+        GpuTraceMarker& currMarker = markerArray->getAt(i);
+        const char* currCmd = currMarker.fMarker;
+        if (currCmd != currBaseCmd) {
+            if (counter != 0) {
+                marker_string.append("):");
+            }
+            marker_string.append(currCmd);
+            marker_string.append("(");
+            marker_string.appendS32(currMarker.fID);
+            currBaseCmd = currCmd;
+        } else {
+            marker_string.append(", ");
+            marker_string.appendS32(currMarker.fID);
+        }
+        ++counter;
+    }
+    if (counter > 0) {
+        marker_string.append(")");
+    }
+    return marker_string;
+}
+
+void GrDrawTarget::addTraceMarkerActiveSet(GpuTraceMarker* marker) {
+    this->fActiveTraceMarkers.push(*marker);
+}
+
+void GrDrawTarget::removeTraceMarkerActiveSet(GpuTraceMarker* marker) {
+    SkASSERT(-1 != this->fActiveTraceMarkers.find(*marker));
+    int index = this->fActiveTraceMarkers.find(*marker);
+    this->fActiveTraceMarkers.remove(index);
+}
+
+void GrDrawTarget::addGpuTraceMarker(GpuTraceMarker* marker) {
     if (this->caps()->gpuTracingSupport()) {
-        this->onInstantGpuTraceEvent(marker);
+        SkASSERT(fGpuTraceMarkerCount >= 0);
+        this->addTraceMarkerActiveSet(marker);
+        this->onAddGpuTraceMarker();
+        ++fGpuTraceMarkerCount;
     }
 }
 
-void GrDrawTarget::pushGpuTraceEvent(const char* marker) {
-    SkASSERT(fPushGpuTraceCount >= 0);
+void GrDrawTarget::removeGpuTraceMarker(GpuTraceMarker* marker) {
     if (this->caps()->gpuTracingSupport()) {
-        this->onPushGpuTraceEvent(marker);
-        ++fPushGpuTraceCount;
+        SkASSERT(fGpuTraceMarkerCount >= 1);
+        this->removeTraceMarkerActiveSet(marker);
+        this->onRemoveGpuTraceMarker();
+        --fGpuTraceMarkerCount;
     }
 }
 
-void GrDrawTarget::popGpuTraceEvent() {
-    SkASSERT(fPushGpuTraceCount >= 1);
-    if (this->caps()->gpuTracingSupport()) {
-        this->onPopGpuTraceEvent();
-        --fPushGpuTraceCount;
-    }
+bool GrDrawTarget::gpuTracingEnabled() const {
+    return this->getContext()->gpuTracingEnabled();
 }
-
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawTarget::willUseHWAALines() const {
     // There is a conflict between using smooth lines and our use of premultiplied alpha. Smooth
     // lines tweak the incoming alpha value but not in a premul-alpha way. So we only use them when
     // our alpha is 0xff and tweaking the color for partial coverage is OK
     if (!this->caps()->hwAALineSupport() ||
         !this->getDrawState().isHWAntialiasState()) {
         return false;
     }
@@ skipping 489 matching lines @@
     for (size_t i = 0; i < SK_ARRAY_COUNT(kConfigNames); ++i)  {
         if (i != kUnknown_GrPixelConfig) {
             r.appendf("%s is renderable: %s, with MSAA: %s\n",
                      kConfigNames[i],
                      gNY[fConfigRenderSupport[i][0]],
                      gNY[fConfigRenderSupport[i][1]]);
         }
     }
     return r;
 }