Major bench refactoring.

bench/AAClipBench.cpp

 /*

[epoger, 2013/09/04 14:45:51]

One more toplevel comment:

Presumably, this CL is intended to address some particular problem(s) with
bench.  (Primarily, I assume, that bench takes too long to run.)

Personally, I prefer for us to keep a "paper trail" (usually in the form of
bugs) indicating why we make substantial changes, and addressing the potential
alternatives (e.g., https://code.google.com/p/skia/issues/detail?id=1566
('GenerateGMs takes way too long on the bots')), for the following reasons:

1. It helps us make sure we are data-driven in our decisionmaking
2. It may help us 6 months from now, when we want to make further adjustments
and we have forgotten many of the considerations we thought were valuable way
back in 2013.

But I may be in the minority here.  I think many people prefer the higher
execution velocity made possible by NOT keeping the paper trail.  I suppose
there are pros and cons both ways.

If we worked at General Dynamics, I suppose somebody "in charge" would tell us
to do it one way or the other.  But we don't. :-)

[scroggo, 2013/09/04 14:51:31]

I don't know whether you're in the minority, but I agree. I'd say it's more
important for changes like this, which are large in scope. On the other end of
the spectrum, if you need to add a check for NULL, I think execution velocity is
more important. Somewhere in between the paper trail becomes "worth it", which
may vary from person to person.

[mtklein, 2013/09/04 19:06:51]

Sure.  Added 1590.  Guess I'm spoiled by cs/ where the CLs themselves make
easily searchable paper-trail.

  * 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 "SkBenchmark.h"
 #include "SkAAClip.h"
 #include "SkPath.h"
 #include "SkRegion.h"
 #include "SkString.h"
 #include "SkCanvas.h"
 #include "SkRandom.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // This bench tests out AA/BW clipping via canvas' clipPath and clipRect calls
 class AAClipBench : public SkBenchmark {
     SkString fName;
     SkPath   fClipPath;
     SkRect   fClipRect;
     SkRect   fDrawRect;
     bool     fDoPath;
     bool     fDoAA;
 
-    enum {
-        N = SkBENCHLOOP(200),
-    };
-
 public:
     AAClipBench(void* param, bool doPath, bool doAA)
         : INHERITED(param)
         , fDoPath(doPath)
         , fDoAA(doAA) {
 
         fName.printf("aaclip_%s_%s",
                      doPath ? "path" : "rect",
                      doAA ? "AA" : "BW");
 
         fClipRect.set(SkFloatToScalar(10.5f), SkFloatToScalar(10.5f),
                       SkFloatToScalar(50.5f), SkFloatToScalar(50.5f));
         fClipPath.addRoundRect(fClipRect, SkIntToScalar(10), SkIntToScalar(10));
         fDrawRect.set(SkIntToScalar(0), SkIntToScalar(0),
                       SkIntToScalar(100), SkIntToScalar(100));
 
         SkASSERT(fClipPath.isConvex());
     }
 
 protected:
     virtual const char* onGetName() { return fName.c_str(); }
     virtual void onDraw(SkCanvas* canvas) {
 
         SkPaint paint;
         this->setupPaint(&paint);
 
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             // jostle the clip regions each time to prevent caching
             fClipRect.offset((i % 2) == 0 ? SkIntToScalar(10) : SkIntToScalar(-10), 0);
             fClipPath.reset();
             fClipPath.addRoundRect(fClipRect,
                                    SkIntToScalar(5), SkIntToScalar(5));
             SkASSERT(fClipPath.isConvex());
 
             canvas->save();
 #if 1
             if (fDoPath) {
@@ skipping 22 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // This bench tests out nested clip stacks. It is intended to simulate
 // how WebKit nests clips.
 class NestedAAClipBench : public SkBenchmark {
     SkString fName;
     bool     fDoAA;
     SkRect   fDrawRect;
     SkRandom fRandom;
 
-    static const int kNumDraws = SkBENCHLOOP(2);
     static const int kNestingDepth = 3;
     static const int kImageSize = 400;
 
     SkPoint fSizes[kNestingDepth+1];
 
 public:
     NestedAAClipBench(void* param, bool doAA)
         : INHERITED(param)
         , fDoAA(doAA) {
 
@@ skipping 52 matching lines @@
                 childOffset.fX = offset.fX;
                 childOffset.fY = offset.fY + fSizes[depth+1].fY;
                 this->recurse(canvas, depth+1, childOffset);
             }
 
             canvas->restore();
     }
 
     virtual void onDraw(SkCanvas* canvas) {
 
-        for (int i = 0; i < kNumDraws; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             SkPoint offset = SkPoint::Make(0, 0);
             this->recurse(canvas, 0, offset);
         }
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 class AAClipBuilderBench : public SkBenchmark {
     SkString fName;
     SkPath   fPath;
     SkRect   fRect;
     SkRegion fRegion;
     bool     fDoPath;
     bool     fDoAA;
 
-    enum {
-        N = SkBENCHLOOP(200),
-    };
-
 public:
     AAClipBuilderBench(void* param, bool doPath, bool doAA) : INHERITED(param) {
         fDoPath = doPath;
         fDoAA = doAA;
 
         fName.printf("aaclip_build_%s_%s", doPath ? "path" : "rect",
                      doAA ? "AA" : "BW");
 
         fRegion.setRect(0, 0, 640, 480);
         fRect.set(fRegion.getBounds());
         fRect.inset(SK_Scalar1/4, SK_Scalar1/4);
         fPath.addRoundRect(fRect, SkIntToScalar(20), SkIntToScalar(20));
     }
 
 protected:
     virtual const char* onGetName() { return fName.c_str(); }
     virtual void onDraw(SkCanvas*) {
         SkPaint paint;
         this->setupPaint(&paint);
 
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             SkAAClip clip;
             if (fDoPath) {
                 clip.setPath(fPath, &fRegion, fDoAA);
             } else {
                 clip.setRect(fRect, fDoAA);
             }
         }
     }
 private:
     typedef SkBenchmark INHERITED;
@@ skipping 11 matching lines @@
         path.setFillType(SkPath::kEvenOdd_FillType);
 
         SkIRect bounds;
         path.getBounds().roundOut(&bounds);
         fRegion.setPath(path, SkRegion(bounds));
     }
 
 protected:
     virtual const char* onGetName() { return "aaclip_setregion"; }
     virtual void onDraw(SkCanvas*) {
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             SkAAClip clip;
             clip.setRegion(fRegion);
         }
     }
 
 private:
-    enum {
-        N = SkBENCHLOOP(400),
-    };
     SkRegion fRegion;
     typedef SkBenchmark INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static SkBenchmark* Fact0(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, false, false)); }
 static SkBenchmark* Fact1(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, false, true)); }
 static SkBenchmark* Fact2(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, true, false)); }
 static SkBenchmark* Fact3(void* p) { return SkNEW_ARGS(AAClipBuilderBench, (p, true, true)); }
@@ skipping 14 matching lines @@
 static BenchRegistry gReg000(Fact000);
 static BenchRegistry gReg001(Fact001);
 static BenchRegistry gReg002(Fact002);
 static BenchRegistry gReg003(Fact003);
 
 static SkBenchmark* Fact004(void* p) { return SkNEW_ARGS(NestedAAClipBench, (p, false)); }
 static SkBenchmark* Fact005(void* p) { return SkNEW_ARGS(NestedAAClipBench, (p, true)); }
 
 static BenchRegistry gReg004(Fact004);
 static BenchRegistry gReg005(Fact005);