Major bench refactoring.

bench/PathBench.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 "SkBenchmark.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 11 matching lines @@
 
 #define FLAGS00  Flags(0)
 #define FLAGS01  Flags(kStroke_Flag)
 #define FLAGS10  Flags(kBig_Flag)
 #define FLAGS11  Flags(kStroke_Flag | kBig_Flag)
 
 class PathBench : public SkBenchmark {
     SkPaint     fPaint;
     SkString    fName;
     Flags       fFlags;
-    enum { N = SkBENCHLOOP(1000) };
 public:
     PathBench(void* param, Flags flags) : INHERITED(param), fFlags(flags) {
         fPaint.setStyle(flags & kStroke_Flag ? SkPaint::kStroke_Style :
                         SkPaint::kFill_Style);
         fPaint.setStrokeWidth(SkIntToScalar(5));
         fPaint.setStrokeJoin(SkPaint::kBevel_Join);
     }
 
     virtual void appendName(SkString*) = 0;
     virtual void makePath(SkPath*) = 0;
@@ skipping 13 matching lines @@
         this->setupPaint(&paint);
 
         SkPath path;
         this->makePath(&path);
         if (fFlags & kBig_Flag) {
             SkMatrix m;
             m.setScale(SkIntToScalar(10), SkIntToScalar(10));
             path.transform(m);
         }
 
-        int count = N;
+        int count = this->getLoops();
         if (fFlags & kBig_Flag) {
             count >>= 2;
         }
         count >>= (3 * complexity());
 
         for (int i = 0; i < count; i++) {
             canvas->drawPath(path, paint);
         }
     }
 
@@ skipping 242 matching lines @@
     SkRandom                    fRandom;
     typedef SkBenchmark INHERITED;
 };
 
 class PathCreateBench : public RandomPathBench {
 public:
     PathCreateBench(void* param) : INHERITED(param) {
     }
 
 protected:
-    enum { N = SkBENCHLOOP(5000) };
-
     virtual const char* onGetName() SK_OVERRIDE {
         return "path_create";
     }
 
     virtual void onPreDraw() SK_OVERRIDE {
         this->createData(10, 100);
         fPaths.reset(kPathCnt);
     }
 
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             this->makePath(&fPaths[i & (kPathCnt - 1)]);
         }
         this->restartMakingPaths();
     }
 
     virtual void onPostDraw() SK_OVERRIDE {
         this->finishedMakingPaths();
         fPaths.reset(0);
     }
 
 private:
     enum {
         // must be a pow 2
         kPathCnt = 1 << 5,
     };
     SkAutoTArray<SkPath> fPaths;
 
     typedef RandomPathBench INHERITED;
 };
 
 class PathCopyBench : public RandomPathBench {
 public:
     PathCopyBench(void* param) : INHERITED(param) {
     }
 
 protected:
-    enum { N = SkBENCHLOOP(30000) };
-
     virtual const char* onGetName() SK_OVERRIDE {
         return "path_copy";
     }
     virtual void onPreDraw() SK_OVERRIDE {
         this->createData(10, 100);
         fPaths.reset(kPathCnt);
         fCopies.reset(kPathCnt);
         for (int i = 0; i < kPathCnt; ++i) {
             this->makePath(&fPaths[i]);
         }
         this->finishedMakingPaths();
     }
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             int idx = i & (kPathCnt - 1);
             fCopies[idx] = fPaths[idx];
         }
     }
     virtual void onPostDraw() SK_OVERRIDE {
         fPaths.reset(0);
         fCopies.reset(0);
     }
 
 private:
     enum {
         // must be a pow 2
         kPathCnt = 1 << 5,
     };
     SkAutoTArray<SkPath> fPaths;
     SkAutoTArray<SkPath> fCopies;
 
     typedef RandomPathBench INHERITED;
 };
 
 class PathTransformBench : public RandomPathBench {
 public:
     PathTransformBench(bool inPlace, void* param)
         : INHERITED(param)
         , fInPlace(inPlace) {
     }
 
 protected:
-    enum { N = SkBENCHLOOP(30000) };
-
     virtual const char* onGetName() SK_OVERRIDE {
         return fInPlace ? "path_transform_in_place" : "path_transform_copy";
     }
 
     virtual void onPreDraw() SK_OVERRIDE {
         fMatrix.setScale(5 * SK_Scalar1, 6 * SK_Scalar1);
         this->createData(10, 100);
         fPaths.reset(kPathCnt);
         for (int i = 0; i < kPathCnt; ++i) {
             this->makePath(&fPaths[i]);
         }
         this->finishedMakingPaths();
         if (!fInPlace) {
             fTransformed.reset(kPathCnt);
         }
     }
 
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
         if (fInPlace) {
-            for (int i = 0; i < N; ++i) {
+            for (int i = 0; i < this->getLoops(); ++i) {
                 fPaths[i & (kPathCnt - 1)].transform(fMatrix);
             }
         } else {
-            for (int i = 0; i < N; ++i) {
+            for (int i = 0; i < this->getLoops(); ++i) {
                 int idx = i & (kPathCnt - 1);
                 fPaths[idx].transform(fMatrix, &fTransformed[idx]);
             }
         }
     }
 
     virtual void onPostDraw() SK_OVERRIDE {
         fPaths.reset(0);
         fTransformed.reset(0);
     }
@@ skipping 11 matching lines @@
     typedef RandomPathBench INHERITED;
 };
 
 class PathEqualityBench : public RandomPathBench {
 public:
     PathEqualityBench(void* param)
         : INHERITED(param) {
     }
 
 protected:
-    enum { N = SkBENCHLOOP(40000) };
-
     virtual const char* onGetName() SK_OVERRIDE {
         return "path_equality_50%";
     }
 
     virtual void onPreDraw() SK_OVERRIDE {
         fParity = 0;
         this->createData(10, 100);
         fPaths.reset(kPathCnt);
         fCopies.reset(kPathCnt);
         for (int i = 0; i < kPathCnt; ++i) {
             this->makePath(&fPaths[i]);
             fCopies[i] = fPaths[i];
         }
         this->finishedMakingPaths();
     }
 
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             int idx = i & (kPathCnt - 1);
             fParity ^= (fPaths[idx] == fCopies[idx & ~0x1]);
         }
     }
 
     virtual void onPostDraw() SK_OVERRIDE {
         fPaths.reset(0);
         fCopies.reset(0);
     }
 
@@ skipping 19 matching lines @@
         kReversePathTo_AddType,
     };
 
     SkBench_AddPathTest(AddType type, void* param)
         : INHERITED(param)
         , fType(type) {
         fMatrix.setRotate(60 * SK_Scalar1);
     }
 
 protected:
-    enum { N = SkBENCHLOOP(15000) };
-
     virtual const char* onGetName() SK_OVERRIDE {
         switch (fType) {
             case kAdd_AddType:
                 return "path_add_path";
             case kAddTrans_AddType:
                 return "path_add_path_trans";
             case kAddMatrix_AddType:
                 return "path_add_path_matrix";
             case kPathTo_AddType:
                 return "path_path_to";
@@ skipping 17 matching lines @@
         for (int i = 0; i < kPathCnt; ++i) {
             this->makePath(&fPaths0[i]);
             this->makePath(&fPaths1[i]);
         }
         this->finishedMakingPaths();
     }
 
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
         switch (fType) {
             case kAdd_AddType:
-                for (int i = 0; i < N; ++i) {
+                for (int i = 0; i < this->getLoops(); ++i) {
                     int idx = i & (kPathCnt - 1);
                     SkPath result = fPaths0[idx];
                     result.addPath(fPaths1[idx]);
                 }
                 break;
             case kAddTrans_AddType:
-                for (int i = 0; i < N; ++i) {
+                for (int i = 0; i < this->getLoops(); ++i) {
                     int idx = i & (kPathCnt - 1);
                     SkPath result = fPaths0[idx];
                     result.addPath(fPaths1[idx], 2 * SK_Scalar1, 5 * SK_Scalar1);
                 }
                 break;
             case kAddMatrix_AddType:
-                for (int i = 0; i < N; ++i) {
+                for (int i = 0; i < this->getLoops(); ++i) {
                     int idx = i & (kPathCnt - 1);
                     SkPath result = fPaths0[idx];
                     result.addPath(fPaths1[idx], fMatrix);
                 }
                 break;
             case kPathTo_AddType:
-                for (int i = 0; i < N; ++i) {
+                for (int i = 0; i < this->getLoops(); ++i) {
                     int idx = i & (kPathCnt - 1);
                     SkPath result = fPaths0[idx];
                     result.pathTo(fPaths1[idx]);
                 }
                 break;
             case kReverseAdd_AddType:
-                for (int i = 0; i < N; ++i) {
+                for (int i = 0; i < this->getLoops(); ++i) {
                     int idx = i & (kPathCnt - 1);
                     SkPath result = fPaths0[idx];
                     result.reverseAddPath(fPaths1[idx]);
                 }
                 break;
             case kReversePathTo_AddType:
-                for (int i = 0; i < N; ++i) {
+                for (int i = 0; i < this->getLoops(); ++i) {
                     int idx = i & (kPathCnt - 1);
                     SkPath result = fPaths0[idx];
                     result.reversePathTo(fPaths1[idx]);
                 }
                 break;
         }
     }
 
     virtual void onPostDraw() SK_OVERRIDE {
         fPaths0.reset(0);
@@ skipping 11 matching lines @@
     SkMatrix         fMatrix;
     typedef RandomPathBench INHERITED;
 };
 
 
 class CirclesBench : public SkBenchmark {
 protected:
     SkString            fName;
     Flags               fFlags;
 
-    enum {
-        N = SkBENCHLOOP(100)
-    };
 public:
     CirclesBench(void* param, Flags flags) : INHERITED(param), fFlags(flags) {
         fName.printf("circles_%s", fFlags & kStroke_Flag ? "stroke" : "fill");
     }
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
         SkPaint paint;
 
         paint.setColor(SK_ColorBLACK);
         paint.setAntiAlias(true);
         if (fFlags & kStroke_Flag) {
             paint.setStyle(SkPaint::kStroke_Style);
         }
 
         SkRandom rand;
 
         SkRect r;
 
-        for (int i = 0; i < 5000; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             SkScalar radius = rand.nextUScalar1() * 3;
             r.fLeft = rand.nextUScalar1() * 300;
             r.fTop =  rand.nextUScalar1() * 300;
             r.fRight =  r.fLeft + 2 * radius;
             r.fBottom = r.fTop + 2 * radius;
 
             if (fFlags & kStroke_Flag) {
                 paint.setStrokeWidth(rand.nextUScalar1() * 5.0f);
             }
 
@@ skipping 16 matching lines @@
 
 // Chrome creates its own round rects with each corner possibly being different.
 // In its "zero radius" incarnation it creates degenerate round rects.
 // Note: PathTest::test_arb_round_rect_is_convex and
 // test_arb_zero_rad_round_rect_is_rect perform almost exactly
 // the same test (but with no drawing)
 class ArbRoundRectBench : public SkBenchmark {
 protected:
     SkString            fName;
 
-    enum {
-        N = SkBENCHLOOP(100)
-    };
 public:
     ArbRoundRectBench(void* param, bool zeroRad) : INHERITED(param), fZeroRad(zeroRad) {
         if (zeroRad) {
             fName.printf("zeroradroundrect");
         } else {
             fName.printf("arbroundrect");
         }
     }
 
 protected:
@@ skipping 40 matching lines @@
         add_corner_arc(path, r, xCorner, yCorner, 180);
         path->close();
 
         SkASSERT(path->isConvex());
     }
 
     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
         SkRandom rand;
         SkRect r;
 
-        for (int i = 0; i < 5000; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             SkPaint paint;
             paint.setColor(0xff000000 | rand.nextU());
             paint.setAntiAlias(true);
 
             SkScalar size = rand.nextUScalar1() * 30;
             if (size < SK_Scalar1) {
                 continue;
             }
             r.fLeft = rand.nextUScalar1() * 300;
             r.fTop =  rand.nextUScalar1() * 300;
@@ skipping 47 matching lines @@
                 break;
         }
     }
 
 private:
     virtual const char* onGetName() SK_OVERRIDE {
         return fName.c_str();
     }
 
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             const SkRect& rect = fQueryRects[i % kQueryRectCnt];
             fParity = fParity != fPath.conservativelyContainsRect(rect);
         }
     }
 
     virtual void onPreDraw() SK_OVERRIDE {
         fQueryRects.setCount(kQueryRectCnt);
 
         SkRandom rand;
         for (int i = 0; i < kQueryRectCnt; ++i) {
             SkSize size;
             SkPoint xy;
             size.fWidth = rand.nextRangeScalar(kQueryMin.fWidth,  kQueryMax.fWidth);
             size.fHeight = rand.nextRangeScalar(kQueryMin.fHeight, kQueryMax.fHeight);
             xy.fX = rand.nextRangeScalar(kBounds.fLeft, kBounds.fRight - size.fWidth);
             xy.fY = rand.nextRangeScalar(kBounds.fTop, kBounds.fBottom - size.fHeight);
 
             fQueryRects[i] = SkRect::MakeXYWH(xy.fX, xy.fY, size.fWidth, size.fHeight);
         }
     }
 
     virtual void onPostDraw() SK_OVERRIDE {
         fQueryRects.setCount(0);
     }
 
     enum {
-        N = SkBENCHLOOP(100000),
         kQueryRectCnt = 400,
     };
     static const SkRect kBounds;   // bounds for all random query rects
     static const SkSize kQueryMin; // minimum query rect size, should be <= kQueryMax
     static const SkSize kQueryMax; // max query rect size, should < kBounds
     static const SkRect kBaseRect; // rect that is used to construct the path
     static const SkScalar kRRRadii[2]; // x and y radii for round rect
 
     SkString            fName;
     SkPath              fPath;
     bool                fParity;
     SkTDArray<SkRect>   fQueryRects;
 
     typedef SkBenchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkGeometry.h"
 
 class ConicBench_Chop5 : public SkBenchmark {
-    enum {
-        N = 100000
-    };
     SkConic fRQ;
 public:
     ConicBench_Chop5(void* param) : INHERITED(param) {
         fRQ.fPts[0].set(0, 0);
         fRQ.fPts[1].set(100, 0);
         fRQ.fPts[2].set(100, 100);
         fRQ.fW = SkScalarCos(SK_ScalarPI/4);
     }
 
 private:
     virtual const char* onGetName() SK_OVERRIDE {
         return "ratquad-chop-0.5";
     }
 
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
         SkConic dst[2];
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             fRQ.chopAt(0.5f, dst);
         }
     }
 
     typedef SkBenchmark INHERITED;
 };
 
 class ConicBench_ChopHalf : public SkBenchmark {
-    enum {
-        N = 100000
-    };
     SkConic fRQ;
 public:
     ConicBench_ChopHalf(void* param) : INHERITED(param) {
         fRQ.fPts[0].set(0, 0);
         fRQ.fPts[1].set(100, 0);
         fRQ.fPts[2].set(100, 100);
         fRQ.fW = SkScalarCos(SK_ScalarPI/4);
     }
 
 private:
     virtual const char* onGetName() SK_OVERRIDE {
         return "ratquad-chop-half";
     }
 
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
         SkConic dst[2];
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             fRQ.chop(dst);
         }
     }
 
     typedef SkBenchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void rand_conic(SkConic* conic, SkRandom& rand) {
@@ skipping 12 matching lines @@
     ConicBench(void* param) : INHERITED(param) {
         SkRandom rand;
         for (int i = 0; i < CONICS; ++i) {
             rand_conic(&fConics[i], rand);
         }
         fIsRendering = false;
     }
 
 protected:
     enum {
-        N = 20000,
         CONICS = 100
     };
     SkConic fConics[CONICS];
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
 class ConicBench_ComputeError : public ConicBench {
 public:
     ConicBench_ComputeError(void* param) : INHERITED(param) {}
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
         return "conic-compute-error";
     }
 
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
         SkVector err;
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             for (int j = 0; j < CONICS; ++j) {
                 fConics[j].computeAsQuadError(&err);
             }
         }
     }
 
 private:
     typedef ConicBench INHERITED;
 };
 
 class ConicBench_asQuadTol : public ConicBench {
 public:
     ConicBench_asQuadTol(void* param) : INHERITED(param) {}
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
         return "conic-asQuadTol";
     }
 
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             for (int j = 0; j < CONICS; ++j) {
                 fConics[j].asQuadTol(SK_ScalarHalf);
             }
         }
     }
 
 private:
     typedef ConicBench INHERITED;
 };
 
 class ConicBench_quadPow2 : public ConicBench {
 public:
     ConicBench_quadPow2(void* param) : INHERITED(param) {}
 
 protected:
     virtual const char* onGetName() SK_OVERRIDE {
         return "conic-quadPow2";
     }
 
     virtual void onDraw(SkCanvas*) SK_OVERRIDE {
-        for (int i = 0; i < N; ++i) {
+        for (int i = 0; i < this->getLoops(); ++i) {
             for (int j = 0; j < CONICS; ++j) {
                 fConics[j].computeQuadPOW2(SK_ScalarHalf);
             }
         }
     }
 
 private:
     typedef ConicBench INHERITED;
 };
 
@@ skipping 52 matching lines @@
 DEF_BENCH( return new ArbRoundRectBench(p, true); )
 DEF_BENCH( return new ConservativelyContainsBench(p, ConservativelyContainsBench::kRect_Type); )
 DEF_BENCH( return new ConservativelyContainsBench(p, ConservativelyContainsBench::kRoundRect_Type); )
 DEF_BENCH( return new ConservativelyContainsBench(p, ConservativelyContainsBench::kOval_Type); )
 
 DEF_BENCH( return new ConicBench_Chop5(p) )
 DEF_BENCH( return new ConicBench_ChopHalf(p) )
 DEF_BENCH( return new ConicBench_ComputeError(p) )
 DEF_BENCH( return new ConicBench_asQuadTol(p) )
 DEF_BENCH( return new ConicBench_quadPow2(p) )