Major bench refactoring.

bench/RectBench.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 "SkCanvas.h"
+#include "SkCommandLineFlags.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
+#include "SkShader.h"
 #include "SkString.h"
-#include "SkShader.h"
+
+DEFINE_double(strokeWidth, -1.0, "If set, use this stroke width in RectBench.");
 
 class RectBench : public SkBenchmark {
 public:
     int fShift, fStroke;
     enum {
         W = 640,
         H = 480,
-        N = SkBENCHLOOP(300)
+        N = 7,  // TODO: polygon and lines assert in debug mode when greater than this.  Ideally 300.
     };
     SkRect  fRects[N];
     SkColor fColors[N];
 
     RectBench(void* param, int shift, int stroke = 0)
         : INHERITED(param)
         , fShift(shift)
         , fStroke(stroke) {
         SkRandom rand;
         const SkScalar offset = SK_Scalar1/3;
@@ skipping 27 matching lines @@
         c->drawRect(r, p);
     }
 
     virtual const char* onGetName() { return computeName("rects"); }
     virtual void onDraw(SkCanvas* canvas) {
         SkPaint paint;
         if (fStroke > 0) {
             paint.setStyle(SkPaint::kStroke_Style);
             paint.setStrokeWidth(SkIntToScalar(fStroke));
         }
-        for (int i = 0; i < N; i++) {
-            paint.setColor(fColors[i]);
+        for (int i = 0; i < this->getLoops(); i++) {
+            paint.setColor(fColors[i % N]);
             this->setupPaint(&paint);
-            this->drawThisRect(canvas, fRects[i], paint);
+            this->drawThisRect(canvas, fRects[i % N], paint);
         }
     }
 private:
     typedef SkBenchmark INHERITED;
 };
 
 class SrcModeRectBench : public RectBench {
 public:
     SrcModeRectBench(void* param) : INHERITED(param, 1, 0) {
         fMode = SkXfermode::Create(SkXfermode::kSrc_Mode);
@@ skipping 54 matching lines @@
         fName = name;
     }
 
 protected:
     virtual void onDraw(SkCanvas* canvas) {
         SkScalar gSizes[] = {
             SkIntToScalar(7), 0
         };
         size_t sizes = SK_ARRAY_COUNT(gSizes);
 
-        if (this->hasStrokeWidth()) {
-            gSizes[0] = this->getStrokeWidth();
+        if (FLAGS_strokeWidth >= 0) {
+            gSizes[0] = FLAGS_strokeWidth;
             sizes = 1;
         }
 
         SkPaint paint;
         paint.setStrokeCap(SkPaint::kRound_Cap);
 
-        for (size_t i = 0; i < sizes; i++) {
-            paint.setStrokeWidth(gSizes[i]);
-            this->setupPaint(&paint);
-            canvas->drawPoints(fMode, N * 2, SkTCast<SkPoint*>(fRects), paint);
-            paint.setColor(fColors[i]);
+        for (int loop = 0; loop < this->getLoops(); loop++) {
+            for (size_t i = 0; i < sizes; i++) {
+                paint.setStrokeWidth(gSizes[i]);
+                this->setupPaint(&paint);
+                canvas->drawPoints(fMode, N * 2, SkTCast<SkPoint*>(fRects), paint);
+                paint.setColor(fColors[i % N]);
+            }
         }
     }
     virtual const char* onGetName() { return fName; }
 };
 
 class AARectBench : public SkBenchmark {
 public:
     enum {
         W = 640,
         H = 480,
@@ skipping 13 matching lines @@
     virtual void onDraw(SkCanvas* canvas) {
         static const SkScalar kHalfRectSize = SkFloatToScalar(0.75f);
 
         SkPaint paint;
         this->setupPaint(&paint);
         paint.setAntiAlias(true);
         paint.setColor(SK_ColorBLACK);
         SkRect r = { -kHalfRectSize, -kHalfRectSize, kHalfRectSize, kHalfRectSize };
         int rot = 0;
 
-        // Draw small aa rects in a grid across the screen
-        for (SkScalar y = kHalfRectSize+SK_Scalar1; y < H; y += 2*kHalfRectSize+2) {
-            for (SkScalar x = kHalfRectSize+SK_Scalar1; x < W; x += 2*kHalfRectSize+2) {
-                canvas->save();
-                canvas->translate(x, y);
+        for (int i = 0; i < this->getLoops(); i++) {
+            // Draw small aa rects in a grid across the screen
+            for (SkScalar y = kHalfRectSize+SK_Scalar1; y < H; y += 2*kHalfRectSize+2) {
+                for (SkScalar x = kHalfRectSize+SK_Scalar1; x < W; x += 2*kHalfRectSize+2) {
+                    canvas->save();
+                    canvas->translate(x, y);
 
-                if (fRotate) {
-                    SkMatrix rotate;
-                    rotate.setRotate(SkIntToScalar(rot));
-                    canvas->concat(rotate);
-                    rot += 10;
+                    if (fRotate) {
+                        SkMatrix rotate;
+                        rotate.setRotate(SkIntToScalar(rot));
+                        canvas->concat(rotate);
+                        rot += 10;
+                    }
+
+                    canvas->drawRect(r, paint);
+                    canvas->restore();
                 }
-
-                canvas->drawRect(r, paint);
-                canvas->restore();
             }
         }
 
     }
 private:
     bool fRotate;
     typedef SkBenchmark INHERITED;
 };
 
 /*******************************************************************************
@@ skipping 17 matching lines @@
         fName = name;
     }
 
 protected:
     virtual void onDraw(SkCanvas* canvas) {
         SkScalar gSizes[] = {
             SkIntToScalar(13), SkIntToScalar(24)
         };
         size_t sizes = SK_ARRAY_COUNT(gSizes);
 
-        if (this->hasStrokeWidth()) {
-            gSizes[0] = this->getStrokeWidth();
+        if (FLAGS_strokeWidth >= 0) {
+            gSizes[0] = FLAGS_strokeWidth;
             sizes = 1;
         }
         SkRandom rand;
         SkColor color = 0xFF000000;
         U8CPU alpha = 0xFF;
         SkPaint paint;
         paint.setStrokeCap(SkPaint::kRound_Cap);
         if (_type == KMaskShader) {
             SkBitmap srcBM;
             srcBM.setConfig(SkBitmap::kARGB_8888_Config, 10, 1);
             srcBM.allocPixels();
             srcBM.eraseColor(0xFF00FF00);
 
             SkShader* s;
             s  = SkShader::CreateBitmapShader(srcBM, SkShader::kClamp_TileMode,
                                               SkShader::kClamp_TileMode);
             paint.setShader(s)->unref();
         }
-        for (size_t i = 0; i < sizes; i++) {
-            switch (_type) {
-                case kMaskOpaque:
-                    color = fColors[i];
-                    alpha = 0xFF;
-                    break;
-                case kMaskBlack:
-                    alpha = 0xFF;
-                    color = 0xFF000000;
-                    break;
-                case kMaskColor:
-                    color = fColors[i];
-                    alpha = rand.nextU() & 255;
-                    break;
-                case KMaskShader:
-                    break;
-            }
-            paint.setStrokeWidth(gSizes[i]);
-            this->setupPaint(&paint);
-            paint.setColor(color);
-            paint.setAlpha(alpha);
-            canvas->drawPoints(fMode, N * 2, SkTCast<SkPoint*>(fRects), paint);
-       }
+        for (int loop = 0; loop < this->getLoops(); loop++) {
+            for (size_t i = 0; i < sizes; i++) {
+                switch (_type) {
+                    case kMaskOpaque:
+                        color = fColors[i];
+                        alpha = 0xFF;
+                        break;
+                    case kMaskBlack:
+                        alpha = 0xFF;
+                        color = 0xFF000000;
+                        break;
+                    case kMaskColor:
+                        color = fColors[i];
+                        alpha = rand.nextU() & 255;
+                        break;
+                    case KMaskShader:
+                        break;
+                }
+                paint.setStrokeWidth(gSizes[i]);
+                this->setupPaint(&paint);
+                paint.setColor(color);
+                paint.setAlpha(alpha);
+                canvas->drawPoints(fMode, N * 2, SkTCast<SkPoint*>(fRects), paint);
+           }
+        }
     }
     virtual const char* onGetName() { return fName; }
 private:
     typedef RectBench INHERITED;
     kMaskType _type;
 };
 
 
 DEF_BENCH( return SkNEW_ARGS(RectBench, (p, 1)); )
 DEF_BENCH( return SkNEW_ARGS(RectBench, (p, 1, 4)); )
@@ skipping 27 matching lines @@
                       BlitMaskBench::kMaskBlack, "maskblack")
                       ); )
 DEF_BENCH( return SkNEW_ARGS(BlitMaskBench,
                       (p, SkCanvas::kPoints_PointMode,
                       BlitMaskBench::kMaskColor, "maskcolor")
                       ); )
 DEF_BENCH( return SkNEW_ARGS(BlitMaskBench,
                      (p, SkCanvas::kPoints_PointMode,
                      BlitMaskBench::KMaskShader, "maskshader")
                      ); )