Nested picture nanobench

bench/PictureNestingBench.cpp

Index: bench/PictureNestingBench.cpp
diff --git a/bench/PictureNestingBench.cpp b/bench/PictureNestingBench.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cbec7a08e32fdbece79a4fd25fda268eaf9ff6f5
--- /dev/null
+++ b/bench/PictureNestingBench.cpp
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Benchmark.h"
+#include "SkCanvas.h"
+#include "SkColor.h"
+#include "SkNullCanvas.h"
+#include "SkPaint.h"
+#include "SkPicture.h"
+#include "SkPictureRecorder.h"
+#include "SkString.h"
+
+static int spinsky(SkCanvas* canvas, int lvl, const SkPaint& paint, int maxLevel,

[mtklein, 2014/09/15 20:38:39]

lvl, maxLevel...

and maybe consider spelling it sierpinski?

[f(malita), 2014/09/15 22:09:25]

Converted to a protected method & dropped the max params completely.
Done.

+                   int maxPictureLevel) {
+    if (++lvl > maxLevel) {
+        return 0;
+    }
+
+    int pics = 0;
+    SkPictureRecorder recorder;
+    SkCanvas* c = canvas;
+
+    if (lvl <= maxPictureLevel) {
+        c = recorder.beginRecording(1, 1);
+        pics++;
+    }
+
+    c->drawLine(0.5, 0, 0, 1, paint);
+    c->drawLine(0.5, 0, 1, 1, paint);
+    c->drawLine(0,   1, 1, 1, paint);
+
+    c->save();
+        c->scale(0.5, 0.5);
+
+        c->translate(0, 1);
+        pics += spinsky(c, lvl, paint, maxLevel, maxPictureLevel);
+
+        c->translate(1, 0);
+        pics += spinsky(c, lvl, paint, maxLevel, maxPictureLevel);
+
+        c->translate(-0.5, -1);
+        pics += spinsky(c, lvl, paint, maxLevel, maxPictureLevel);
+    c->restore();
+
+    if (lvl <= maxPictureLevel) {
+        SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+        canvas->drawPicture(picture);
+    }
+
+    return pics;
+}
+
+class PictureNesting : public Benchmark {
+public:
+    PictureNesting(const char* name, int maxLevel, int maxPictureLevel)
+        : fMaxLevel(maxLevel)
+        , fMaxPictureLevel(maxPictureLevel) {
+
+        fPaint.setColor(SK_ColorRED);
+        fPaint.setAntiAlias(true);
+        fPaint.setStyle(SkPaint::kStroke_Style);
+        fName.printf("picture_nesting_%s_%d", name,
+                     spinsky(SkCreateNullCanvas(), 0, fPaint, maxLevel, maxPictureLevel));
+    }
+
+protected:
+    virtual const char* onGetName() SK_OVERRIDE {
+        return fName.c_str();
+    }
+
+    void doDraw(SkCanvas* canvas) {
+        SkIPoint canvasSize = onGetSize();
+        canvas->save();
+        canvas->scale(SkIntToScalar(canvasSize.x()), SkIntToScalar(canvasSize.y()));
+
+        spinsky(canvas, 0, fPaint, fMaxLevel, fMaxPictureLevel);
+
+        canvas->restore();
+    }
+
+    int fMaxLevel;
+    int fMaxPictureLevel;
+
+private:
+    SkString fName;
+    SkPaint  fPaint;
+
+    typedef Benchmark INHERITED;
+};
+
+class PictureNestingRecording : public PictureNesting {
+public:
+    PictureNestingRecording(int maxLevel, int maxPictureLevel)
+        : INHERITED("recording", maxLevel, maxPictureLevel) {
+    }
+
+protected:
+    virtual void onDraw(const int loops, SkCanvas* canvas) {
+        SkIPoint canvasSize = onGetSize();
+        SkPictureRecorder recorder;
+
+        for (int i = 0; i < loops; i++) {
+            SkCanvas* c = recorder.beginRecording(SkIntToScalar(canvasSize.x()),
+                                                  SkIntToScalar(canvasSize.y()));
+            this->doDraw(c);
+            SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+        }
+    }
+
+private:
+    typedef PictureNesting INHERITED;
+};
+
+class PictureNestingPlayback : public PictureNesting {
+public:
+    PictureNestingPlayback(int maxLevel, int maxPictureLevel)
+        : INHERITED("playback", maxLevel, maxPictureLevel) {
+
+        SkIPoint canvasSize = onGetSize();
+        SkPictureRecorder recorder;
+        SkCanvas* c = recorder.beginRecording(SkIntToScalar(canvasSize.x()),
+                                              SkIntToScalar(canvasSize.y()));
+
+        this->doDraw(c);
+        fPicture.reset(recorder.endRecording());
+    }
+
+protected:
+    virtual void onDraw(const int loops, SkCanvas* canvas) {
+        for (int i = 0; i < loops; i++) {
+            canvas->drawPicture(fPicture);
+        }
+    }
+
+private:
+    SkAutoTUnref<SkPicture> fPicture;
+
+    typedef PictureNesting INHERITED;
+};
+
+DEF_BENCH( return new PictureNestingRecording(8, 0); )
+DEF_BENCH( return new PictureNestingRecording(8, 1); )
+DEF_BENCH( return new PictureNestingRecording(8, 2); )
+DEF_BENCH( return new PictureNestingRecording(8, 3); )
+DEF_BENCH( return new PictureNestingRecording(8, 4); )
+DEF_BENCH( return new PictureNestingRecording(8, 5); )
+DEF_BENCH( return new PictureNestingRecording(8, 6); )
+DEF_BENCH( return new PictureNestingRecording(8, 7); )
+DEF_BENCH( return new PictureNestingRecording(8, 8); )
+
+DEF_BENCH( return new PictureNestingPlayback(8, 0); )
+DEF_BENCH( return new PictureNestingPlayback(8, 1); )
+DEF_BENCH( return new PictureNestingPlayback(8, 2); )
+DEF_BENCH( return new PictureNestingPlayback(8, 3); )
+DEF_BENCH( return new PictureNestingPlayback(8, 4); )
+DEF_BENCH( return new PictureNestingPlayback(8, 5); )
+DEF_BENCH( return new PictureNestingPlayback(8, 6); )
+DEF_BENCH( return new PictureNestingPlayback(8, 7); )
+DEF_BENCH( return new PictureNestingPlayback(8, 8); )