Major bench refactoring.

bench/MathBench.cpp

 #include "SkBenchmark.h"
 #include "SkColorPriv.h"
 #include "SkMatrix.h"
 #include "SkRandom.h"
 #include "SkString.h"
 #include "SkPaint.h"
 
 static float sk_fsel(float pred, float result_ge, float result_lt) {
     return pred >= 0 ? result_ge : result_lt;
 }
 
 static float fast_floor(float x) {
 //    float big = sk_fsel(x, 0x1.0p+23, -0x1.0p+23);
     float big = sk_fsel(x, (float)(1 << 23), -(float)(1 << 23));
     return (x + big) - big;
 }
 
 class MathBench : public SkBenchmark {
     enum {
         kBuffer = 100,
-        kLoop   = 10000
     };
     SkString    fName;
     float       fSrc[kBuffer], fDst[kBuffer];
 public:
     MathBench(void* param, const char name[]) : INHERITED(param) {
         fName.printf("math_%s", name);
 
         SkRandom rand;
         for (int i = 0; i < kBuffer; ++i) {
             fSrc[i] = rand.nextSScalar1();
         }
 
         fIsRendering = false;
     }
 
     virtual void performTest(float* SK_RESTRICT dst,
                               const float* SK_RESTRICT src,
                               int count) = 0;
 
 protected:
     virtual int mulLoopCount() const { return 1; }
 
     virtual const char* onGetName() {
         return fName.c_str();
     }
 
     virtual void onDraw(SkCanvas*) {
-        int n = SkBENCHLOOP(kLoop * this->mulLoopCount());
+        int n = this->getLoops() * this->mulLoopCount();
         for (int i = 0; i < n; i++) {
             this->performTest(fDst, fSrc, kBuffer);
         }
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
 class MathBenchU32 : public MathBench {
@@ skipping 180 matching lines @@
     // a + b will be NaN iff either a or b is NaN.
     float value = r.fLeft * 0 + r.fTop * 0 + r.fRight * 0 + r.fBottom * 0;
 
     // value is either NaN or it is finite (zero).
     // value==value will be true iff value is not NaN
     return value == value;
 }
 
 class IsFiniteBench : public SkBenchmark {
     enum {
-        N = SkBENCHLOOP(1000),
-        NN = SkBENCHLOOP(1000),
+        N = 1000,
     };
     float fData[N];
 public:
 
     IsFiniteBench(void* param, int index) : INHERITED(param) {
         SkRandom rand;
 
         for (int i = 0; i < N; ++i) {
             fData[i] = rand.nextSScalar1();
         }
 
         if (index < 0) {
             fProc = NULL;
             fName = "isfinite_rect";
         } else {
             fProc = gRec[index].fProc;
             fName = gRec[index].fName;
         }
         fIsRendering = false;
     }
 
 protected:
     virtual void onDraw(SkCanvas*) {
         IsFiniteProc proc = fProc;
         const float* data = fData;
         // do this so the compiler won't throw away the function call
         int counter = 0;
 
         if (proc) {
-            for (int j = 0; j < NN; ++j) {
+            for (int j = 0; j < this->getLoops(); ++j) {
                 for (int i = 0; i < N - 4; ++i) {
                     counter += proc(&data[i]);
                 }
             }
         } else {
-            for (int j = 0; j < NN; ++j) {
+            for (int j = 0; j < this->getLoops(); ++j) {
                 for (int i = 0; i < N - 4; ++i) {
                     const SkRect* r = reinterpret_cast<const SkRect*>(&data[i]);
                     if (false) { // avoid bit rot, suppress warning
                         isFinite(*r);
                     }
                     counter += r->isFinite();
                 }
             }
         }
 
         SkPaint paint;
         if (paint.getAlpha() == 0) {
             SkDebugf("%d\n", counter);
         }
     }
 
     virtual const char* onGetName() {
         return fName;
     }
 
 private:
     IsFiniteProc    fProc;
     const char*     fName;
 
     typedef SkBenchmark INHERITED;
 };
 
 class FloorBench : public SkBenchmark {
     enum {
-        ARRAY = SkBENCHLOOP(1000),
-        LOOP = SkBENCHLOOP(1000),
+        ARRAY = 1000,
     };
     float fData[ARRAY];
     bool fFast;
 public:
 
     FloorBench(void* param, bool fast) : INHERITED(param), fFast(fast) {
         SkRandom rand;
 
         for (int i = 0; i < ARRAY; ++i) {
             fData[i] = rand.nextSScalar1();
         }
 
         if (fast) {
             fName = "floor_fast";
         } else {
             fName = "floor_std";
         }
         fIsRendering = false;
     }
 
     virtual void process(float) {}
 
 protected:
     virtual void onDraw(SkCanvas*) {
         SkRandom rand;
         float accum = 0;
         const float* data = fData;
 
         if (fFast) {
-            for (int j = 0; j < LOOP; ++j) {
+            for (int j = 0; j < this->getLoops(); ++j) {
                 for (int i = 0; i < ARRAY; ++i) {
                     accum += fast_floor(data[i]);
                 }
                 this->process(accum);
             }
         } else {
-            for (int j = 0; j < LOOP; ++j) {
+            for (int j = 0; j < this->getLoops(); ++j) {
                 for (int i = 0; i < ARRAY; ++i) {
                     accum += sk_float_floor(data[i]);
                 }
                 this->process(accum);
             }
         }
     }
 
     virtual const char* onGetName() {
         return fName;
     }
 
 private:
     const char*     fName;
 
     typedef SkBenchmark INHERITED;
 };
 
 class CLZBench : public SkBenchmark {
     enum {
-        ARRAY = SkBENCHLOOP(1000),
-        LOOP = SkBENCHLOOP(5000),
+        ARRAY = 1000,
     };
     uint32_t fData[ARRAY];
     bool fUsePortable;
 
 public:
     CLZBench(void* param, bool usePortable)
         : INHERITED(param)
         , fUsePortable(usePortable) {
 
         SkRandom rand;
@@ skipping 10 matching lines @@
     }
 
     // just so the compiler doesn't remove our loops
     virtual void process(int) {}
 
 protected:
     virtual void onDraw(SkCanvas*) {
         int accum = 0;
 
         if (fUsePortable) {
-            for (int j = 0; j < LOOP; ++j) {
+            for (int j = 0; j < this->getLoops(); ++j) {
                 for (int i = 0; i < ARRAY; ++i) {
                     accum += SkCLZ_portable(fData[i]);
                 }
                 this->process(accum);
             }
         } else {
-            for (int j = 0; j < LOOP; ++j) {
+            for (int j = 0; j < this->getLoops(); ++j) {
                 for (int i = 0; i < ARRAY; ++i) {
                     accum += SkCLZ(fData[i]);
                 }
                 this->process(accum);
             }
         }
     }
 
     virtual const char* onGetName() {
         return fName;
     }
 
 private:
     const char* fName;
 
     typedef SkBenchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class NormalizeBench : public SkBenchmark {
     enum {
-        ARRAY = SkBENCHLOOP(1000),
-        LOOP = SkBENCHLOOP(1000),
+        ARRAY =1000,
     };
     SkVector fVec[ARRAY];
 
 public:
     NormalizeBench(void* param)
     : INHERITED(param) {
 
         SkRandom rand;
         for (int i = 0; i < ARRAY; ++i) {
             fVec[i].set(rand.nextSScalar1(), rand.nextSScalar1());
         }
 
         fName = "point_normalize";
         fIsRendering = false;
     }
 
     // just so the compiler doesn't remove our loops
     virtual void process(int) {}
 
 protected:
     virtual void onDraw(SkCanvas*) {
         int accum = 0;
 
-        for (int j = 0; j < LOOP; ++j) {
+        for (int j = 0; j < this->getLoops(); ++j) {
             for (int i = 0; i < ARRAY; ++i) {
                 accum += fVec[i].normalize();
             }
             this->process(accum);
         }
     }
 
     virtual const char* onGetName() {
         return fName;
     }
 
 private:
     const char* fName;
 
     typedef SkBenchmark INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class FixedMathBench : public SkBenchmark {
     enum {
-        N = SkBENCHLOOP(1000),
-        NN = SkBENCHLOOP(1000),
+        N = 1000,
     };
     float fData[N];
     SkFixed fResult[N];
 public:
 
     FixedMathBench(void* param) : INHERITED(param) {
         SkRandom rand;
-        for (int i = 0; i < N; ++i) {
-            fData[i] = rand.nextSScalar1();
+        for (int i = 0; i < this->getLoops(); ++i) {
+            fData[i%N] = rand.nextSScalar1();
         }
 
         fIsRendering = false;
     }
 
 protected:
     virtual void onDraw(SkCanvas*) {
-        for (int j = 0; j < NN; ++j) {
+        for (int j = 0; j < this->getLoops(); ++j) {
             for (int i = 0; i < N - 4; ++i) {
                 fResult[i] = SkFloatToFixed(fData[i]);
             }
         }
 
         SkPaint paint;
         if (paint.getAlpha() == 0) {
             SkDebugf("%d\n", fResult[0]);
         }
     }
@@ skipping 24 matching lines @@
 
 DEF_BENCH( return new FloorBench(p, false); )
 DEF_BENCH( return new FloorBench(p, true); )
 
 DEF_BENCH( return new CLZBench(p, false); )
 DEF_BENCH( return new CLZBench(p, true); )
 
 DEF_BENCH( return new NormalizeBench(p); )
 
 DEF_BENCH( return new FixedMathBench(p); )