stop scaling loops and improve warmup bench

tools/VisualBench/VisualLightweightBenchModule.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  */
 
 #include "VisualLightweightBenchModule.h"
 
@@ skipping 29 matching lines @@
 
 static SkString humanize(double ms) {
     if (FLAGS_verbose) {
         return SkStringPrintf("%llu", (uint64_t)(ms*1e6));
     }
     return HumanizeMs(ms);
 }
 
 #define HUMANIZE(time) humanize(time).c_str()
 
-// A trivial bench to warm up the gpu
+// We draw a big nonAA path to warmup the gpu / cpu
 class WarmupBench : public Benchmark {
 public:
+    WarmupBench() {
+        make_path(fPath);
+    }
 private:
+    static void make_path(SkPath& path) {
+        #include "BigPathBench.inc"
+    }
     const char* onGetName() override { return "warmupbench"; }
     void onDraw(const int loops, SkCanvas* canvas) override {
+        SkPaint paint;
+        paint.setStyle(SkPaint::kStroke_Style);
+        paint.setStrokeWidth(2);
         for (int i = 0; i < loops; i++) {
-            sk_tool_utils::draw_checkerboard(canvas, 0xffffffff, 0xffc6c3c6, 10);
+            canvas->drawPath(fPath, paint);
         }
     }
+    SkPath fPath;
 };
 
 VisualLightweightBenchModule::VisualLightweightBenchModule(VisualBench* owner)
     : fCurrentSample(0)
     , fCurrentFrame(0)
     , fLoops(1)
     , fState(kWarmup_State)
     , fBenchmark(nullptr)
     , fOwner(SkRef(owner))
     , fResults(new ResultsWriter) {
@@ skipping 66 matching lines @@
                  HUMANIZE(stats.mean),
                  HUMANIZE(stats.max),
                  stdDevPercent,
                  stats.plot.c_str(),
                  shortName);
     }
 }
 
 bool VisualLightweightBenchModule::advanceRecordIfNecessary(SkCanvas* canvas) {
     if (!fBenchmark && fState == kWarmup_State) {
+        fOwner->clear(canvas, SK_ColorWHITE, 2);
         fBenchmark.reset(new WarmupBench);
         return true;
     }
 
     if (fBenchmark) {
         return true;
     }
 
     fBenchmark.reset(fBenchmarkStream->next());
     if (!fBenchmark) {
@@ skipping 96 matching lines @@
     fTimer.end();
     return fTimer.fWall;
 }
 
 void VisualLightweightBenchModule::resetTimingState() {
     fCurrentFrame = 0;
     fTimer = WallTimer();
     fOwner->reset();
 }
 
-void VisualLightweightBenchModule::scaleLoops(double elapsedMs) {
-    // Scale back the number of loops
-    fLoops = (int)ceil(fLoops * FLAGS_loopMs / elapsedMs);
-}
-
 inline void VisualLightweightBenchModule::tuneLoops() {
     if (1 << 30 == fLoops) {
         // We're about to wrap.  Something's wrong with the bench.
         SkDebugf("InnerLoops wrapped\n");
         fLoops = 1;
     } else {
         double elapsedMs = this->elapsed();
         if (elapsedMs > FLAGS_loopMs) {
-            this->scaleLoops(elapsedMs);
             this->nextState(kPreWarmTimingPerCanvasPreDraw_State);
         } else {
             fLoops *= 2;
             this->nextState(kPreWarmLoops_State);
         }
         this->resetTimingState();
     }
 }
 
 void VisualLightweightBenchModule::recordMeasurement() {
@@ skipping 20 matching lines @@
         }
         this->resetTimingState();
     } else {
         fCurrentFrame++;
     }
 }
 
 bool VisualLightweightBenchModule::onHandleChar(SkUnichar c) {
     return true;
 }