Make blurcircles2 run as a benchmark

gm/blurcircles2.cpp

Index: gm/blurcircles2.cpp
diff --git a/gm/blurcircles2.cpp b/gm/blurcircles2.cpp
index 284c1ab24e1a4399b3cb5852d45bc8f8cae716c7..c2ef3605e48c72a4b5c50ad9c458fab3dcfc6978 100644
--- a/gm/blurcircles2.cpp
+++ b/gm/blurcircles2.cpp
@@ -20,6 +20,9 @@
  *
  * In Sample mode this draws a single circle and almost-circle with animating radius and blur
  * radius.
+ *
+ * Bench mode draws the same as GM mode but without the comparison almost-circle paths. It also
+ * slightly perturbs the blur and circle radii to stress caching of blurred profiles in GPU mode.
  */
 class BlurCircles2GM : public skiagm::GM {
 public:
@@ -32,6 +35,8 @@ public:
     }
 
 protected:
+    bool runAsBench() const override { return true; }
+
     SkString onShortName() override { return SkString("blurcircles2"); }
 
     SkISize onISize() override {
@@ -69,6 +74,7 @@ protected:
                 canvas->drawPath(almostCircle, paint);
             canvas->restore();
         } else {
+            bool benchMode = this->getMode() == kBench_Mode;
             canvas->save();
             static constexpr SkScalar kPad = 5;
             static constexpr SkScalar kRadiusSteps = 5;
@@ -76,36 +82,50 @@ protected:
             canvas->translate(kPad + kMinRadius + kMaxBlurRadius,
                               kPad + kMinRadius + kMaxBlurRadius);
             SkScalar lineWidth = 0;
-            for (int r = 0; r < kRadiusSteps - 1; ++r) {
-                const SkScalar radius = r * (kMaxRadius - kMinRadius) / kBlurRadiusSteps +
-                                        kMinRadius;
-                lineWidth += 2 * (radius + kMaxBlurRadius) + kPad;
+            if (!benchMode) {
+                for (int r = 0; r < kRadiusSteps - 1; ++r) {
+                    const SkScalar radius = r * (kMaxRadius - kMinRadius) / kBlurRadiusSteps +
+                                            kMinRadius;
+                    lineWidth += 2 * (radius + kMaxBlurRadius) + kPad;
+                }
             }
             for (int br = 0; br < kBlurRadiusSteps; ++br) {
-                const SkScalar blurRadius = br * (kMaxBlurRadius - kMinBlurRadius) /
-                                            kBlurRadiusSteps + kMinBlurRadius;
+                SkScalar blurRadius = br * (kMaxBlurRadius - kMinBlurRadius) /
+                                      kBlurRadiusSteps + kMinBlurRadius;
+                if (benchMode) {
+                    blurRadius += fRandom.nextSScalar1() * (kMaxBlurRadius - kMinBlurRadius) /
+                                                           kBlurRadiusSteps;
+                }
                 const SkScalar maxRowR = blurRadius + kMaxRadius;
                 paint.setMaskFilter(blurMaker(blurRadius));
                 canvas->save();
                 for (int r = 0; r < kRadiusSteps; ++r) {

[robertphillips, 2016/05/16 14:26:30]

Should this kBlurRadiusSteps be kRadiusSteps ?
Would kDeltaBlurRadius & kDeltaRadius constants help ?

[bsalomon, 2016/05/16 16:16:39]

Done.

-                    const SkScalar radius = r * (kMaxRadius - kMinRadius) / kBlurRadiusSteps +
-                                            kMinRadius;
+                    SkScalar radius = r * (kMaxRadius - kMinRadius) / kBlurRadiusSteps + kMinRadius;
+                    if (benchMode) {
+                        radius += fRandom.nextSScalar1() * (kMaxRadius - kMinRadius) / kRadiusSteps;
+                    }
                     SkPath almostCircle;
-                    almostCircleMaker(radius, &almostCircle);
+                    if (!benchMode) {
+                        almostCircleMaker(radius, &almostCircle);
+                    }
                     canvas->save();
                         canvas->drawCircle(0, 0, radius, paint);
                         canvas->translate(0, 2 * maxRowR + kPad);
+                    if (!benchMode) {
                         canvas->drawPath(almostCircle, paint);
+                    }
                     canvas->restore();
                     const SkScalar maxColR = radius + kMaxBlurRadius;
                     canvas->translate(maxColR * 2 + kPad, 0);
                 }
                 canvas->restore();
-                SkPaint blackPaint;
-                blackPaint.setColor(SK_ColorBLACK);
-                const SkScalar lineY = 3 * maxRowR + 1.5f * kPad;
-                if (br != kBlurRadiusSteps - 1) {
-                    canvas->drawLine(0, lineY, lineWidth, lineY, blackPaint);
+                if (!benchMode) {
+                    SkPaint blackPaint;
+                    blackPaint.setColor(SK_ColorBLACK);
+                    const SkScalar lineY = 3 * maxRowR + 1.5f * kPad;
+                    if (br != kBlurRadiusSteps - 1) {
+                        canvas->drawLine(0, lineY, lineWidth, lineY, blackPaint);
+                    }
                 }
                 canvas->translate(0, maxRowR * 4 + 2 * kPad);
             }
@@ -135,6 +155,8 @@ private:
     SkScalar    fAnimRadius;
     SkScalar    fAnimBlurRadius;
 
+    SkRandom    fRandom;
+
     typedef skiagm::GM INHERITED;
 };