Optimize visualbench offscreen blits

tools/VisualBench/WrappedBenchmark.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef WrappedBenchmark_DEFINED
 #define WrappedBenchmark_DEFINED
 
 #include "Benchmark.h"
+#include "SkDevice.h"
 #include "SkSurface.h"
+#include "GrContext.h"
+#include "GrRenderTarget.h"
 
 // Wrap some other benchmark to allow specialization to either
 // cpu or gpu backends. The derived class will override 'setupOffScreen'
 // to create an offscreen surface in which the actual rendering will occur.
 class WrappedBenchmark : public Benchmark {
 public:
     // Takes ownership of caller's ref on `bench`.
     explicit WrappedBenchmark(const SkSurfaceProps& surfaceProps, Benchmark* bench)
         : fSurfaceProps(surfaceProps)
         , fBench(bench) {}
 
     const SkSurfaceProps& surfaceProps() const { return fSurfaceProps; }
 
     const char* onGetName()       override { return fBench->getName(); }
     const char* onGetUniqueName() override { return fBench->getUniqueName(); }
 
     void onDelayedSetup() override { fBench->delayedSetup(); }
     void onPerCanvasPreDraw(SkCanvas* canvas) override {
-        fOffScreen.reset(this->setupOffScreen(canvas));
+        this->setupOffScreen(canvas);
         fBench->perCanvasPreDraw(fOffScreen->getCanvas());
     }
     void onPreDraw(SkCanvas* canvas) override {
         SkASSERT(fOffScreen.get());
         fBench->preDraw(fOffScreen->getCanvas());
     }
     void onPostDraw(SkCanvas* canvas) override {
         SkASSERT(fOffScreen.get());
         fBench->postDraw(fOffScreen->getCanvas());
     }
     void onPerCanvasPostDraw(SkCanvas* canvas) override {
         SkASSERT(fOffScreen.get());
         fBench->perCanvasPostDraw(fOffScreen->getCanvas());
     }
 
     void onDraw(int loops, SkCanvas* canvas) override {
         SkASSERT(fOffScreen.get());
         fBench->draw(loops, fOffScreen->getCanvas());
+        this->blitToScreen(canvas);
+    }
+
+    virtual SkIPoint onGetSize() override { return fBench->getSize(); }
+
+protected:
+    virtual void setupOffScreen(SkCanvas*)=0;
+
+    virtual void blitToScreen(SkCanvas* canvas) {
         SkAutoTUnref<SkImage> image(fOffScreen->newImageSnapshot());
         canvas->drawImage(image, 0,0);
     }
 
-    virtual SkIPoint onGetSize() override { return fBench->getSize(); }
-
-private:
-    virtual SkSurface* setupOffScreen(SkCanvas*)=0;
-
     SkSurfaceProps          fSurfaceProps;
     SkAutoTUnref<SkSurface> fOffScreen;
     SkAutoTUnref<Benchmark> fBench;
 };
 
 // Create a raster surface for off screen rendering
 class CpuWrappedBenchmark : public WrappedBenchmark {
 public:
     explicit CpuWrappedBenchmark(const SkSurfaceProps& surfaceProps, Benchmark* bench)
         : INHERITED(surfaceProps, bench) {}
 
 private:
-    SkSurface* setupOffScreen(SkCanvas* canvas) override {
-        return SkSurface::NewRaster(canvas->imageInfo(), &this->surfaceProps());
+    void setupOffScreen(SkCanvas* canvas) override {
+        fOffScreen.reset(SkSurface::NewRaster(canvas->imageInfo(), &this->surfaceProps()));
     }
 
     typedef WrappedBenchmark INHERITED;
 };
 
 // Create an MSAA & NVPR-enabled GPU backend
 class NvprWrappedBenchmark : public WrappedBenchmark {
 public:
     explicit NvprWrappedBenchmark(const SkSurfaceProps& surfaceProps, Benchmark* bench,
                                   int numSamples)
         : INHERITED(surfaceProps, bench)
         , fNumSamples(numSamples) {}
 
 private:
-    SkSurface* setupOffScreen(SkCanvas* canvas) override {
-        return SkSurface::NewRenderTarget(canvas->getGrContext(),
-                                          SkSurface::kNo_Budgeted,
-                                          canvas->imageInfo(),
-                                          fNumSamples,
-                                          &this->surfaceProps());
+    void setupOffScreen(SkCanvas* canvas) override {
+        fOffScreen.reset(SkSurface::NewRenderTarget(canvas->getGrContext(),
+                                                    SkSurface::kNo_Budgeted,
+                                                    canvas->imageInfo(),
+                                                    fNumSamples,
+                                                    &this->surfaceProps()));
+        fOffScreen->getCanvas()->clear(SK_ColorWHITE);
+    }
+
+    void blitToScreen(SkCanvas* canvas) override {
+        // We call copySurface directly on the underlying GPU surfaces for a more efficient blit.
+        SkCanvas::LayerIter canvasIter(canvas, false);

[Chris Dalton, 2015/11/16 18:30:35]

I'd rather call getTopDevice() than use the LayerIter, except it's private. Is
there a secret internal way to get the top device or is this the best we can do?

[bsalomon, 2015/11/16 21:14:59]

I think this is the best we can do right now.

+        GrRenderTarget* dst = canvasIter.device()->accessRenderTarget();
+
+        SkCanvas::LayerIter offscreenIter(fOffScreen->getCanvas(), false);
+        GrRenderTarget* src = offscreenIter.device()->accessRenderTarget();
+
+        if (!src || src->width() != fOffScreen->width() || src->height() != fOffScreen->height() ||
+            !dst || canvas->imageInfo().dimensions() != SkISize::Make(dst->width(),dst->height())) {

[Chris Dalton, 2015/11/16 18:30:35]

I added the check of RT size because I understand if the SkCanvas is larger than
the max RT size supported by the GPU, tiling will happen somewhere. Is this
correct? Is this check sufficient to handle that case?

[bsalomon, 2015/11/16 21:14:59]

I think the RT is always the size of the screen. Josh?

[Chris Dalton, 2015/11/16 21:23:17]

Oh that's right, unless running in windowed mode (--fullscreen false)

In theory though, if this were ever given a gigantic canvas (say 10k x 10k),
larger than GL_MAX_TEXTURE_SIZE, would the SkGpuDevice run tiled and make it so
a simple copySurface call wouldn't work?

[joshualitt, 2015/11/18 17:02:03]

just print not supported in that case.

+            SkDebugf("warning : blitToScreen() falling back on slow path for nvpr.");
+            INHERITED::blitToScreen(canvas);
+            return;
+        }
+
+        SkASSERT(dst->getContext() == src->getContext());
+
+        int w = SkTMin(fBench->getSize().fX, SkTMin(dst->width(), src->width()));
+        int h = SkTMin(fBench->getSize().fY, SkTMin(dst->height(), src->height()));
+        dst->getContext()->copySurface(dst, src, SkIRect::MakeWH(w, h), SkIPoint::Make(0, 0));
+
+#ifdef SK_DEBUG
+        // This method should not be called while layers are saved.
+        canvasIter.next();
+        SkASSERT(canvasIter.done());
+
+        offscreenIter.next();
+        SkASSERT(offscreenIter.done());
+#endif
     }
 
     int fNumSamples;
     typedef WrappedBenchmark INHERITED;
 };
 
 #endif //WrappedBenchmark_DEFINED