Benchmark to measure SkSurface copy on write performance

bench/DeferredSurfaceCopyBench.cpp

Index: bench/DeferredSurfaceCopyBench.cpp
===================================================================
--- bench/DeferredSurfaceCopyBench.cpp	(revision 0)
+++ bench/DeferredSurfaceCopyBench.cpp	(revision 0)
@@ -0,0 +1,84 @@
+
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#if SK_SUPPORT_GPU
+#include "GrRenderTarget.h"
+#endif
+#include "SkBenchmark.h"
+#include "SkDeferredCanvas.h"
+#include "SkDevice.h"
+#include "SkImage.h"
+#include "SkSurface.h"
+
+class DeferredSurfaceCopyBench : public SkBenchmark {
+    enum {
+        N = SkBENCHLOOP(25),
+    };
+public:
+    DeferredSurfaceCopyBench(void* param, bool discardableContents) : SkBenchmark(param) {
+        fDiscardableContents = discardableContents;
+
+    }
+
+protected:
+    virtual const char* onGetName() SK_OVERRIDE { 
+        return fDiscardableContents ? "DeferredSurfaceCopy_discardable" : 
+            "DeferredSurfaceCopy_nonDiscardable"; 
+    }
+
+    virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+        // The canvas is not actually used for this test except to provide
+        // configuration information: gpu, multisampling, size, etc?
+        SkDevice *referenceDevice = canvas->getDevice();
+        SkImage::Info info;
+        info.fWidth = referenceDevice->width();

[reed1, 2013/04/16 20:37:24]

Is it important to match this size? Seems like the results will be more
repeatable if we just hard-code a given size.

[Justin Novosad, 2013/04/16 20:50:48]

Done.

+        info.fHeight = referenceDevice->height();
+        info.fColorType = SkImage::kPMColor_ColorType;
+        info.fAlphaType = SkImage::kPremul_AlphaType;
+        SkSurface *surface;
+#if SK_SUPPORT_GPU
+        GrRenderTarget* rt = reinterpret_cast<GrRenderTarget*>(referenceDevice->accessRenderTarget());
+        if (NULL != rt) {
+            surface = SkSurface::NewRenderTarget(rt->getContext(), info, rt->numSamples());
+        } else
+#endif
+        {
+            surface = SkSurface::NewRaster(info);
+        }
+        SkDeferredCanvas drawingCanvas(surface);
+        surface->unref();
+
+        for (int iteration = 0; iteration < N; iteration++) {
+            drawingCanvas.clear(0);
+            SkImage* image = drawingCanvas.newImageSnapshot();

[reed1, 2013/04/16 20:37:24]

I think you can collaps these two lines down to just

SkAutoTUnref<SkImage> image(drawingCanvas.newImageSnapshot());

[Justin Novosad, 2013/04/16 20:50:48]

Done.

+            SkAutoTUnref<SkImage> aur(image);
+            SkPaint paint;
+            if (!fDiscardableContents) {
+                // If paint is not opaque, prior canvas contents are
+                // not discardable because they are needed for compositing.
+                paint.setAlpha(127);
+            }
+            drawingCanvas.drawPaint(paint);

[reed1, 2013/04/16 20:37:24]

this is a non-trival call, in terms of time, if the canvas is large. If you are
just trying to trigger a change at all, why not drawRect(1x1 rect)?

[Justin Novosad, 2013/04/16 20:50:48]

To make contents recognized as discardable I need the draw op to cover the
entire canvas. So just did a large rect.

+            // Trigger copy on write, which should be faster in the discardable case.
+            drawingCanvas.flush();
+        }
+    }
+
+private:
+    bool fDiscardableContents;
+
+    typedef SkBenchmark INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static SkBenchmark* Fact0(void* p) { return new DeferredSurfaceCopyBench(p, false); }
+static SkBenchmark* Fact1(void* p) { return new DeferredSurfaceCopyBench(p, true); }
+
+static BenchRegistry gReg0(Fact0);
+static BenchRegistry gReg1(Fact1);