Refactoring: get rid of the SkBenchmark void* parameter.

bench/MatrixBench.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 "SkMatrix.h"
 #include "SkMatrixUtils.h"
 #include "SkRandom.h"
 #include "SkString.h"
 
 class MatrixBench : public SkBenchmark {
     SkString    fName;
 public:
-    MatrixBench(void* param, const char name[]) : INHERITED(param) {
+    MatrixBench(const char name[])  {
         fName.printf("matrix_%s", name);
         fIsRendering = false;
     }
 
     virtual void performTest() = 0;
 
 protected:
     virtual int mulLoopCount() const { return 1; }
 
     virtual const char* onGetName() {
@@ skipping 17 matching lines @@
 
 #define always_do(pred)                     \
     do {                                    \
         if (pred) {                         \
             ++gMatrixBench_NonStaticGlobal; \
         }                                   \
     } while (0)
 
 class EqualsMatrixBench : public MatrixBench {
 public:
-    EqualsMatrixBench(void* param) : INHERITED(param, "equals") {}
+    EqualsMatrixBench() : INHERITED("equals") {}
 protected:
     virtual void performTest() {
         SkMatrix m0, m1, m2;
 
         m0.reset();
         m1.reset();
         m2.reset();
         always_do(m0 == m1);
         always_do(m1 == m2);
         always_do(m2 == m0);
     }
 private:
     typedef MatrixBench INHERITED;
 };
 
 class ScaleMatrixBench : public MatrixBench {
 public:
-    ScaleMatrixBench(void* param) : INHERITED(param, "scale") {
+    ScaleMatrixBench() : INHERITED("scale") {
         fSX = fSY = SkFloatToScalar(1.5f);
         fM0.reset();
         fM1.setScale(fSX, fSY);
         fM2.setTranslate(fSX, fSY);
     }
 protected:
     virtual void performTest() {
         SkMatrix m;
         m = fM0; m.preScale(fSX, fSY);
         m = fM1; m.preScale(fSX, fSY);
@@ skipping 12 matching lines @@
     SkRandom rand;
     for (int i = 0; i < 9; i++) {
         array[i] = rand.nextSScalar1();
     }
 }
 
 // Test the performance of setConcat() non-perspective case:
 // using floating point precision only.
 class FloatConcatMatrixBench : public MatrixBench {
 public:
-    FloatConcatMatrixBench(void* p) : INHERITED(p, "concat_floatfloat") {
+    FloatConcatMatrixBench() : INHERITED("concat_floatfloat") {
         init9(mya);
         init9(myb);
         init9(myr);
     }
 protected:
     virtual int mulLoopCount() const { return 4; }
 
     static inline void muladdmul(float a, float b, float c, float d,
                                    float* result) {
       *result = a * b + c * d;
@@ skipping 22 matching lines @@
 
 static inline float SkDoubleToFloat(double x) {
     return static_cast<float>(x);
 }
 
 // Test the performance of setConcat() non-perspective case:
 // using floating point precision but casting up to float for
 // intermediate results during computations.
 class FloatDoubleConcatMatrixBench : public MatrixBench {
 public:
-    FloatDoubleConcatMatrixBench(void* p) : INHERITED(p, "concat_floatdouble") {
+    FloatDoubleConcatMatrixBench() : INHERITED("concat_floatdouble") {
         init9(mya);
         init9(myb);
         init9(myr);
     }
 protected:
     virtual int mulLoopCount() const { return 4; }
 
     static inline void muladdmul(float a, float b, float c, float d,
                                    float* result) {
       *result = SkDoubleToFloat((double)a * b + (double)c * d);
@@ skipping 17 matching lines @@
     float mya [9];
     float myb [9];
     float myr [9];
     typedef MatrixBench INHERITED;
 };
 
 // Test the performance of setConcat() non-perspective case:
 // using double precision only.
 class DoubleConcatMatrixBench : public MatrixBench {
 public:
-    DoubleConcatMatrixBench(void* p) : INHERITED(p, "concat_double") {
+    DoubleConcatMatrixBench() : INHERITED("concat_double") {
         init9(mya);
         init9(myb);
         init9(myr);
     }
 protected:
     virtual int mulLoopCount() const { return 4; }
 
     static inline void muladdmul(double a, double b, double c, double d,
                                    double* result) {
       *result = a * b + c * d;
@@ skipping 15 matching lines @@
     }
 private:
     double mya [9];
     double myb [9];
     double myr [9];
     typedef MatrixBench INHERITED;
 };
 
 class GetTypeMatrixBench : public MatrixBench {
 public:
-    GetTypeMatrixBench(void* param)
-        : INHERITED(param, "gettype") {
+    GetTypeMatrixBench()
+        : INHERITED("gettype") {
         fArray[0] = (float) fRnd.nextS();
         fArray[1] = (float) fRnd.nextS();
         fArray[2] = (float) fRnd.nextS();
         fArray[3] = (float) fRnd.nextS();
         fArray[4] = (float) fRnd.nextS();
         fArray[5] = (float) fRnd.nextS();
         fArray[6] = (float) fRnd.nextS();
         fArray[7] = (float) fRnd.nextS();
         fArray[8] = (float) fRnd.nextS();
     }
@@ skipping 23 matching lines @@
     }
 private:
     SkMatrix fMatrix;
     float fArray[9];
     SkRandom fRnd;
     typedef MatrixBench INHERITED;
 };
 
 class ScaleTransMixedMatrixBench : public MatrixBench {
  public:
-    ScaleTransMixedMatrixBench(void* p) : INHERITED(p, "scaletrans_mixed") {
+    ScaleTransMixedMatrixBench() : INHERITED("scaletrans_mixed") {
         fMatrix.setAll(fRandom.nextSScalar1(), fRandom.nextSScalar1(), fRandom.nextSScalar1(),
                        fRandom.nextSScalar1(), fRandom.nextSScalar1(), fRandom.nextSScalar1(),
                        fRandom.nextSScalar1(), fRandom.nextSScalar1(), fRandom.nextSScalar1());
         int i;
         for (i = 0; i < kCount; i++) {
             fSrc[i].fX = fRandom.nextSScalar1();
             fSrc[i].fY = fRandom.nextSScalar1();
             fDst[i].fX = fRandom.nextSScalar1();
             fDst[i].fY = fRandom.nextSScalar1();
         }
@@ skipping 20 matching lines @@
     };
     SkMatrix fMatrix;
     SkPoint fSrc [kCount];
     SkPoint fDst [kCount];
     SkRandom fRandom;
     typedef MatrixBench INHERITED;
 };
 
 class ScaleTransDoubleMatrixBench : public MatrixBench {
  public:
-    ScaleTransDoubleMatrixBench(void* p) : INHERITED(p, "scaletrans_double") {
+    ScaleTransDoubleMatrixBench() : INHERITED("scaletrans_double") {
         init9(fMatrix);
         int i;
         for (i = 0; i < kCount; i++) {
             fSrc[i].fX = fRandom.nextSScalar1();
             fSrc[i].fY = fRandom.nextSScalar1();
             fDst[i].fX = fRandom.nextSScalar1();
             fDst[i].fY = fRandom.nextSScalar1();
         }
     }
  protected:
@@ skipping 19 matching lines @@
     };
     double fMatrix [9];
     SkPoint fSrc [kCount];
     SkPoint fDst [kCount];
     SkRandom fRandom;
     typedef MatrixBench INHERITED;
 };
 
 class DecomposeMatrixBench : public MatrixBench {
 public:
-    DecomposeMatrixBench(void* param) : INHERITED(param, "decompose") {}
+    DecomposeMatrixBench() : INHERITED("decompose") {}
 
 protected:
     virtual void onPreDraw() {
         for (int i = 0; i < 10; ++i) {
             SkScalar rot0 = (fRandom.nextBool()) ? fRandom.nextRangeF(-180, 180) : 0.0f;
             SkScalar sx = fRandom.nextRangeF(-3000.f, 3000.f);
             SkScalar sy = (fRandom.nextBool()) ? fRandom.nextRangeF(-3000.f, 3000.f) : sx;
             SkScalar rot1 = fRandom.nextRangeF(-180, 180);
             fMatrix[i].setRotate(rot0);
             fMatrix[i].postScale(sx, sy);
             fMatrix[i].postRotate(rot1);
         }
     }
     virtual void performTest() {
         SkPoint rotation1, scale, rotation2;
         for (int i = 0; i < 10; ++i) {
             (void) SkDecomposeUpper2x2(fMatrix[i], &rotation1, &scale, &rotation2);
         }
     }
 private:
     SkMatrix fMatrix[10];
     SkRandom fRandom;
     typedef MatrixBench INHERITED;
 };
 
 class InvertMapRectMatrixBench : public MatrixBench {
 public:
-    InvertMapRectMatrixBench(void* param, const char* name, int flags)
-        : INHERITED(param, name)
+    InvertMapRectMatrixBench(const char* name, int flags)
+        : INHERITED(name)
         , fFlags(flags) {
         fMatrix.reset();
         fIteration = 0;
         if (flags & kScale_Flag) {
             fMatrix.postScale(SkFloatToScalar(1.5f), SkFloatToScalar(2.5f));
         }
         if (flags & kTranslate_Flag) {
             fMatrix.postTranslate(SkFloatToScalar(1.5f), SkFloatToScalar(2.5f));
         }
         if (flags & kRotate_Flag) {
@@ skipping 33 matching lines @@
     }
 private:
     SkMatrix fMatrix;
     int fFlags;
     unsigned fIteration;
     typedef MatrixBench INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new EqualsMatrixBench(p); )
-DEF_BENCH( return new ScaleMatrixBench(p); )
-DEF_BENCH( return new FloatConcatMatrixBench(p); )
-DEF_BENCH( return new FloatDoubleConcatMatrixBench(p); )
-DEF_BENCH( return new DoubleConcatMatrixBench(p); )
-DEF_BENCH( return new GetTypeMatrixBench(p); )
-DEF_BENCH( return new DecomposeMatrixBench(p); )
+DEF_BENCH( return new EqualsMatrixBench(); )
+DEF_BENCH( return new ScaleMatrixBench(); )
+DEF_BENCH( return new FloatConcatMatrixBench(); )
+DEF_BENCH( return new FloatDoubleConcatMatrixBench(); )
+DEF_BENCH( return new DoubleConcatMatrixBench(); )
+DEF_BENCH( return new GetTypeMatrixBench(); )
+DEF_BENCH( return new DecomposeMatrixBench(); )
 
-DEF_BENCH( return new InvertMapRectMatrixBench(p, "invert_maprect_identity", 0); )
+DEF_BENCH( return new InvertMapRectMatrixBench("invert_maprect_identity", 0); )
 
-DEF_BENCH(return new InvertMapRectMatrixBench(p,
+DEF_BENCH(return new InvertMapRectMatrixBench(
                                   "invert_maprect_rectstaysrect",
                                   InvertMapRectMatrixBench::kScale_Flag |
                                   InvertMapRectMatrixBench::kTranslate_Flag); )
 
-DEF_BENCH(return new InvertMapRectMatrixBench(p,
+DEF_BENCH(return new InvertMapRectMatrixBench(
                                   "invert_maprect_translate",
                                   InvertMapRectMatrixBench::kTranslate_Flag); )
 
-DEF_BENCH(return new InvertMapRectMatrixBench(p,
+DEF_BENCH(return new InvertMapRectMatrixBench(
                                   "invert_maprect_nonpersp",
                                   InvertMapRectMatrixBench::kScale_Flag |
                                   InvertMapRectMatrixBench::kRotate_Flag |
                                   InvertMapRectMatrixBench::kTranslate_Flag); )
 
-DEF_BENCH( return new InvertMapRectMatrixBench(p,
+DEF_BENCH( return new InvertMapRectMatrixBench(
                                "invert_maprect_persp",
                                InvertMapRectMatrixBench::kPerspective_Flag); )
 
-DEF_BENCH( return new InvertMapRectMatrixBench(p,
+DEF_BENCH( return new InvertMapRectMatrixBench(
                            "invert_maprect_typemask_rectstaysrect",
                            InvertMapRectMatrixBench::kUncachedTypeMask_Flag |
                            InvertMapRectMatrixBench::kScale_Flag |
                            InvertMapRectMatrixBench::kTranslate_Flag); )
 
-DEF_BENCH( return new InvertMapRectMatrixBench(p,
+DEF_BENCH( return new InvertMapRectMatrixBench(
                            "invert_maprect_typemask_nonpersp",
                            InvertMapRectMatrixBench::kUncachedTypeMask_Flag |
                            InvertMapRectMatrixBench::kScale_Flag |
                            InvertMapRectMatrixBench::kRotate_Flag |
                            InvertMapRectMatrixBench::kTranslate_Flag); )
 
-DEF_BENCH( return new ScaleTransMixedMatrixBench(p); )
-DEF_BENCH( return new ScaleTransDoubleMatrixBench(p); )
+DEF_BENCH( return new ScaleTransMixedMatrixBench(); )
+DEF_BENCH( return new ScaleTransDoubleMatrixBench(); )