nanobench: add --runOnce.

bench/nanobench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "Benchmark.h"
 #include "CrashHandler.h"
 #include "ResultsWriter.h"
 #include "Stats.h"
 #include "Timer.h"
 
 #include "SkCanvas.h"
 #include "SkCommandLineFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkString.h"
 #include "SkSurface.h"
 
 #if SK_SUPPORT_GPU
     #include "GrContextFactory.h"
     GrContextFactory gGrFactory;
 #endif
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
+#if SK_DEBUG
+    DEFINE_bool(runOnce, true, "Run each benchmark just once?");
+#else
+    DEFINE_bool(runOnce, false, "Run each benchmark just once?");
+#endif
+
 DEFINE_int32(samples, 10, "Number of samples to measure for each bench.");
 DEFINE_int32(overheadLoops, 100000, "Loops to estimate timer overhead.");
 DEFINE_double(overheadGoal, 0.0001,
               "Loop until timer overhead is at most this fraction of our measurments.");
 DEFINE_string(match, "", "The usual filters on file names of benchmarks to measure.");
 DEFINE_bool2(quiet, q, false, "Print only bench name and minimum sample.");
 DEFINE_bool2(verbose, v, false, "Print all samples.");
 DEFINE_string(config, "nonrendering 8888 gpu", "Configs to measure. Options: "
               "565 8888 gpu nonrendering debug nullgpu msaa4 msaa16 nvprmsaa4 nvprmsaa16 angle");
 DEFINE_double(gpuMs, 5, "Target bench time in millseconds for GPU.");
@@ skipping 57 matching lines @@
     //
     // Doing some math, we get:
     //
     //  (overhead / FLAGS_overheadGoal) - overhead
     //  ------------------------------------------  < N
     //       bench_plus_overhead - overhead)
     //
     // Luckily, this also works well in practice. :)
     const double numer = overhead / FLAGS_overheadGoal - overhead;
     const double denom = bench_plus_overhead - overhead;
-    const int loops = (int)ceil(numer / denom);
+    const int loops = FLAGS_runOnce ? 1 : (int)ceil(numer / denom);
 
     for (int i = 0; i < FLAGS_samples; i++) {
         samples[i] = time(loops, bench, canvas, NULL) / loops;
     }
     return loops;
 }
 
 #if SK_SUPPORT_GPU
 static int gpu_bench(SkGLContextHelper* gl,
                      Benchmark* bench,
                      SkCanvas* canvas,
                      double* samples) {
     // Make sure we're done with whatever came before.
     SK_GL(*gl, Finish());
 
     // First, figure out how many loops it'll take to get a frame up to FLAGS_gpuMs.
     int loops = 1;
-    double elapsed = 0;
-    do {
-        loops *= 2;
-        // If the GPU lets frames lag at all, we need to make sure we're timing
-        // _this_ round, not still timing last round.  We force this by looping
-        // more times than any reasonable GPU will allow frames to lag.
-        for (int i = 0; i < FLAGS_gpuFrameLag; i++) {
-            elapsed = time(loops, bench, canvas, gl);
-        }
-    } while (elapsed < FLAGS_gpuMs);
+    if (!FLAGS_runOnce) {
+        double elapsed = 0;
+        do {
+            loops *= 2;
+            // If the GPU lets frames lag at all, we need to make sure we're timing
+            // _this_ round, not still timing last round.  We force this by looping
+            // more times than any reasonable GPU will allow frames to lag.
+            for (int i = 0; i < FLAGS_gpuFrameLag; i++) {
+                elapsed = time(loops, bench, canvas, gl);
+            }
+        } while (elapsed < FLAGS_gpuMs);
 
-    // We've overshot at least a little.  Scale back linearly.
-    loops = (int)ceil(loops * FLAGS_gpuMs / elapsed);
+        // We've overshot at least a little.  Scale back linearly.
+        loops = (int)ceil(loops * FLAGS_gpuMs / elapsed);
 
-    // Might as well make sure we're not still timing our calibration.
-    SK_GL(*gl, Finish());
+        // Might as well make sure we're not still timing our calibration.
+        SK_GL(*gl, Finish());
+    }
 
     // Pretty much the same deal as the calibration: do some warmup to make
     // sure we're timing steady-state pipelined frames.
     for (int i = 0; i < FLAGS_gpuFrameLag; i++) {
         time(loops, bench, canvas, gl);
     }
 
     // Now, actually do the timing!
     for (int i = 0; i < FLAGS_samples; i++) {
         samples[i] = time(loops, bench, canvas, gl) / loops;
@@ skipping 94 matching lines @@
     log->option("build", "RELEASE");
 #endif
 }
 
 int tool_main(int argc, char** argv);
 int tool_main(int argc, char** argv) {
     SetupCrashHandler();
     SkAutoGraphics ag;
     SkCommandLineFlags::Parse(argc, argv);
 
+    if (FLAGS_runOnce) {
+        FLAGS_samples     = 1;
+        FLAGS_gpuFrameLag = 0;
+    }
+
     MultiResultsWriter log;
     SkAutoTDelete<JSONResultsWriter> json;
     if (!FLAGS_outResultsFile.isEmpty()) {
         json.reset(SkNEW(JSONResultsWriter(FLAGS_outResultsFile[0])));
         log.add(json.get());
     }
     CallEnd<MultiResultsWriter> ender(log);
     fill_static_options(&log);
 
     const double overhead = estimate_timer_overhead();
     SkAutoTMalloc<double> samples(FLAGS_samples);
 
-    if (FLAGS_verbose) {
+    if (FLAGS_runOnce) {
+        SkDebugf("--runOnce is true; times would only be misleading so we won't print them.\n");
+    } else if (FLAGS_verbose) {
         // No header.
     } else if (FLAGS_quiet) {
         SkDebugf("median\tbench\tconfig\n");
     } else {
         SkDebugf("loops\tmin\tmedian\tmean\tmax\tstddev\tsamples\tconfig\tbench\n");
     }
 
     for (const BenchRegistry* r = BenchRegistry::Head(); r != NULL; r = r->next()) {
         SkAutoTDelete<Benchmark> bench(r->factory()(NULL));
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getName())) {
@@ skipping 20 matching lines @@
 
             const char* config = targets[j]->config;
 
             log.config(config);
             log.timer("min_ms",    stats.min);
             log.timer("median_ms", stats.median);
             log.timer("mean_ms",   stats.mean);
             log.timer("max_ms",    stats.max);
             log.timer("stddev_ms", sqrt(stats.var));
 
-            if (FLAGS_verbose) {
+            if (FLAGS_runOnce) {
+                if (targets.count() == 1) {
+                    config = ""; // Only print the config if we run the same bench on more than one.
+                }
+                SkDebugf("%s\t%s\n", bench->getName(), config);
+            } else if (FLAGS_verbose) {
                 for (int i = 0; i < FLAGS_samples; i++) {
                     SkDebugf("%s  ", humanize(samples[i]).c_str());
                 }
                 SkDebugf("%s\n", bench->getName());
             } else if (FLAGS_quiet) {
                 if (targets.count() == 1) {
                     config = ""; // Only print the config if we run the same bench on more than one.
                 }
                 SkDebugf("%s\t%s\t%s\n", humanize(stats.median).c_str(), bench->getName(), config);
             } else {
@@ skipping 15 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif