Add Gpu Tracing to Ganesh

src/gpu/GrContext.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 "GrContext.h"
@@ skipping 83 matching lines @@
     fTextureCache = NULL;
     fFontCache = NULL;
     fDrawBuffer = NULL;
     fDrawBufferVBAllocPool = NULL;
     fDrawBufferIBAllocPool = NULL;
     fFlushToReduceCacheSize = false;
     fAARectRenderer = NULL;
     fOvalRenderer = NULL;
     fViewMatrix.reset();
     fMaxTextureSizeOverride = 1 << 20;
+    fGpuTracingEnabled = true;

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

Let's start with false.

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

That's the plan. Just set that way right now for ease of testing.

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

 }
 
 bool GrContext::init(GrBackend backend, GrBackendContext backendContext) {
     SkASSERT(NULL == fGpu);
 
     fGpu = GrGpu::Create(backend, backendContext, this);
     if (NULL == fGpu) {
         return false;
     }
 
@@ skipping 649 matching lines @@
 void GrContext::drawRect(const GrPaint& paint,
                          const SkRect& rect,
                          const SkStrokeRec* stroke,
                          const SkMatrix* matrix) {
     SK_TRACE_EVENT0("GrContext::drawRect");
 
     AutoRestoreEffects are;
     AutoCheckFlush acf(this);
     GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW, &are, &acf);
 
+    GR_CREATE_GPU_TRACE_MARKER("Test_marker_DRAW_RECT", target);
+
     SkScalar width = stroke == NULL ? -1 : stroke->getWidth();
     SkMatrix combinedMatrix = target->drawState()->getViewMatrix();
     if (NULL != matrix) {
         combinedMatrix.preConcat(*matrix);
     }
 
     // Check if this is a full RT draw and can be replaced with a clear. We don't bother checking
     // cases where the RT is fully inside a stroke.
     if (width < 0) {
         SkRect rtRect;
@@ skipping 158 matching lines @@
                              const uint16_t indices[],
                              int indexCount) {
     SK_TRACE_EVENT0("GrContext::drawVertices");
 
     AutoRestoreEffects are;
     AutoCheckFlush acf(this);
     GrDrawTarget::AutoReleaseGeometry geo; // must be inside AutoCheckFlush scope
 
     GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW, &are, &acf);
 
+    GR_CREATE_GPU_TRACE_MARKER("Test_marker_DRAW_VERTICES", target);
+
     GrDrawState* drawState = target->drawState();
 
     int colorOffset = -1, texOffset = -1;
     set_vertex_attributes(drawState, texCoords, colors, &colorOffset, &texOffset);
 
     size_t vertexSize = drawState->getVertexSize();
     if (sizeof(GrPoint) != vertexSize) {
         if (!geo.set(target, vertexCount, 0)) {
             GrPrintf("Failed to get space for vertices!\n");
             return;
@@ skipping 33 matching lines @@
                           const SkRRect& rect,
                           const SkStrokeRec& stroke) {
     if (rect.isEmpty()) {
        return;
     }
 
     AutoRestoreEffects are;
     AutoCheckFlush acf(this);
     GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW, &are, &acf);
 
+    GR_CREATE_GPU_TRACE_MARKER("Test_marker_DRAW_ROUND_REC", target);

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

.._RECT (T)

+
     if (!fOvalRenderer->drawSimpleRRect(target, this, paint.isAntiAlias(), rect, stroke)) {
         SkPath path;
         path.addRRect(rect);
         this->internalDrawPath(target, paint.isAntiAlias(), path, stroke);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawOval(const GrPaint& paint,
                          const SkRect& oval,
                          const SkStrokeRec& stroke) {
     if (oval.isEmpty()) {
        return;
     }
 
     AutoRestoreEffects are;
     AutoCheckFlush acf(this);
     GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW, &are, &acf);
 
+    GR_CREATE_GPU_TRACE_MARKER("Test_marker_DRAW_OVAL", target);
+
     if (!fOvalRenderer->drawOval(target, this, paint.isAntiAlias(), oval, stroke)) {
         SkPath path;
         path.addOval(oval);
         this->internalDrawPath(target, paint.isAntiAlias(), path, stroke);
     }
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
 static bool is_nested_rects(GrDrawTarget* target,
                             const SkPath& path,
@@ skipping 56 matching lines @@
            this->drawPaint(paint);
        }
        return;
     }
 
     // Note that internalDrawPath may sw-rasterize the path into a scratch texture.
     // Scratch textures can be recycled after they are returned to the texture
     // cache. This presents a potential hazard for buffered drawing. However,
     // the writePixels that uploads to the scratch will perform a flush so we're
     // OK.
+
     AutoRestoreEffects are;
     AutoCheckFlush acf(this);
     GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW, &are, &acf);
     GrDrawState* drawState = target->drawState();
 
+    GR_CREATE_GPU_TRACE_MARKER("Test_marker_DRAW_PATH", target);
+
     bool useCoverageAA = paint.isAntiAlias() && !drawState->getRenderTarget()->isMultisampled();
 
     if (useCoverageAA && stroke.getWidth() < 0 && !path.isConvex()) {
         // Concave AA paths are expensive - try to avoid them for special cases
         bool useVertexCoverage;
         SkRect rects[2];
 
         if (is_nested_rects(target, path, stroke, rects, &useVertexCoverage)) {
             SkMatrix origViewMatrix = drawState->getViewMatrix();
             GrDrawState::AutoViewMatrixRestore avmr;
@@ skipping 15 matching lines @@
     if (!isOval || path.isInverseFillType()
         || !fOvalRenderer->drawOval(target, this, paint.isAntiAlias(), ovalRect, stroke)) {
         this->internalDrawPath(target, paint.isAntiAlias(), path, stroke);
     }
 }
 
 void GrContext::internalDrawPath(GrDrawTarget* target, bool useAA, const SkPath& path,
                                  const SkStrokeRec& origStroke) {
     SkASSERT(!path.isEmpty());
 
+    GR_CREATE_GPU_TRACE_MARKER("Test_marker_INTERNAL_DRAW_PATH", target);
+
+
     // An Assumption here is that path renderer would use some form of tweaking
     // the src color (either the input alpha or in the frag shader) to implement
     // aa. If we have some future driver-mojo path AA that can do the right
     // thing WRT to the blend then we'll need some query on the PR.
     bool useCoverageAA = useAA &&
         !target->getDrawState().getRenderTarget()->isMultisampled() &&
         !target->shouldDisableCoverageAAForBlend();
 
 
     GrPathRendererChain::DrawType type =
@@ skipping 74 matching lines @@
 }
 
 bool GrContext::readTexturePixels(GrTexture* texture,
                                   int left, int top, int width, int height,
                                   GrPixelConfig config, void* buffer, size_t rowBytes,
                                   uint32_t flags) {
     SK_TRACE_EVENT0("GrContext::readTexturePixels");
     ASSERT_OWNED_RESOURCE(texture);
 
     GrRenderTarget* target = texture->asRenderTarget();
+
     if (NULL != target) {
         return this->readRenderTargetPixels(target,
                                             left, top, width, height,
                                             config, buffer, rowBytes,
                                             flags);
     } else {
         // TODO: make this more efficient for cases where we're reading the entire
         //       texture, i.e., use GetTexImage() instead
 
         // create scratch rendertarget and read from that
@@ skipping 562 matching lines @@
     }
     return path;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #if GR_CACHE_STATS
 void GrContext::printCacheStats() const {
     fTextureCache->printStats();
 }
 #endif