Add --runOnce flag to run benchs once in release or to force convergence in debug

bench/benchmain.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 "BenchTimer.h"
 #include "ResultsWriter.h"
 #include "SkBenchLogger.h"
@@ skipping 243 matching lines @@
              "normal:         draw to a normal canvas;\n"
              "deferred:       draw to a deferred canvas;\n"
              "deferredSilent: deferred with silent playback;\n"
              "record:         draw to an SkPicture;\n"
              "picturerecord:  draw from an SkPicture to an SkPicture.\n");
 DEFINE_string(config, kDefaultsConfigStr,
               "Run configs given.  By default, runs the configs marked \"runByDefault\" in gConfigs.");
 DEFINE_string(logFile, "", "Also write stdout here.");
 DEFINE_int32(minMs, 20,  "Shortest time we'll allow a benchmark to run.");
 DEFINE_int32(maxMs, 4000, "Longest time we'll allow a benchmark to run.");
+DEFINE_bool(runOnce, kIsDebug, "Run each bench exactly once and don't report timings.");
 DEFINE_double(error, 0.01,
               "Ratio of subsequent bench measurements must drop within 1±error to converge.");
 DEFINE_string(timeFormat, "%9.2f", "Format to print results, in milliseconds per 1000 loops.");
 DEFINE_bool2(verbose, v, false, "Print more.");
 DEFINE_string2(resourcePath, i, "resources", "directory for test resources.");
 DEFINE_string(outResultsFile, "", "If given, the results will be written to the file in JSON format.");
 
 DEFINE_bool(dryRun, false, "Don't actually run the tests, just print what would have been done.");
 
 // Has this bench converged?  First arguments are milliseconds / loop iteration,
@@ skipping 106 matching lines @@
                     config.sampleCount, config.name));
                 configs.remove(i);
                 --i;
                 continue;
             }
         }
     }
 #endif
 
     // All flags should be parsed now.  Report our settings.
-    if (kIsDebug) {
-        logger.logError("bench was built in Debug mode, so we're going to hide the times."
-                        "  It's for your own good!\n");
+    if (FLAGS_runOnce) {
+        logger.logError("bench was run with --runOnce, so we're going to hide the times."
+                        " It's for your own good!\n");
     }
     writer.option("mode", FLAGS_mode[0]);
     writer.option("alpha", SkStringPrintf("0x%02X", alpha).c_str());
     writer.option("antialias", SkStringPrintf("%d", FLAGS_forceAA).c_str());
     writer.option("filter", SkStringPrintf("%d", FLAGS_forceFilter).c_str());
     writer.option("dither",  SkTriState::Name[dither]);
 
     writer.option("rotate", SkStringPrintf("%d", FLAGS_rotate).c_str());
     writer.option("scale", SkStringPrintf("%d", FLAGS_scale).c_str());
     writer.option("clip", SkStringPrintf("%d", FLAGS_clip).c_str());
@@ skipping 249 matching lines @@
     //                                 bench->getName(), frameIntervalTotalLoops,
     //                                 timer.fWall, loopsPerFrame);
                         }
                     }
 
                     const double current = timer.fWall / loopsPerIter;
                     if (FLAGS_verbose && current > previous) { SkDebugf("↑"); }
                     if (FLAGS_verbose) { SkDebugf("%.3g ", current); }
                     converged = HasConverged(previous, current, timer.fWall);
                     previous = current;
-                } while (!kIsDebug && !converged);
+                } while (!FLAGS_runOnce && !converged);
             }
             if (FLAGS_verbose) { SkDebugf("\n"); }
 
             if (!FLAGS_dryRun && FLAGS_outDir.count() && SkBenchmark::kNonRendering_Backend != config.backend) {
                 SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
                 if (image.get()) {
                     saveFile(bench->getName(), config.name, FLAGS_outDir[0],
                              image);
                 }
             }
 
-            if (kIsDebug) {
-                // Let's not mislead ourselves by looking at Debug build bench times!
+            if (FLAGS_runOnce) {
+                // Let's not mislead ourselves by looking at Debug build or single iteration bench times!
                 continue;
             }
 
             // Normalize to ms per 1000 iterations.
             const double normalize = 1000.0 / loopsPerIter;
             const struct { char shortName; const char* longName; double ms; } times[] = {
                 {'w', "msecs",  normalize * timer.fWall},
                 {'W', "Wmsecs", normalize * timer.fTruncatedWall},
                 {'c', "cmsecs", normalize * timer.fCpu},
                 {'C', "Cmsecs", normalize * timer.fTruncatedCpu},
@@ skipping 12 matching lines @@
     gContextFactory.destroyContexts();
 #endif
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif