nanobench: support --outResultsFile

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"
 
@@ skipping 12 matching lines @@
 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.");
 DEFINE_int32(gpuFrameLag, 5, "Overestimate of maximum number of frames GPU allows to lag.");
 
 DEFINE_bool(cpu, true, "Master switch for CPU-bound work.");
 DEFINE_bool(gpu, true, "Master switch for GPU-bound work.");
 
+DEFINE_string(outResultsFile, "", "If given, write results here as JSON.");
+
 
 static SkString humanize(double ms) {
     if (ms > 1e+3) return SkStringPrintf("%.3gs",  ms/1e3);
     if (ms < 1e-3) return SkStringPrintf("%.3gns", ms*1e6);
     if (ms < 1)    return SkStringPrintf("%.3gµs", ms*1e3);
     return SkStringPrintf("%.3gms", ms);
 }
 
 static double time(int loops, Benchmark* bench, SkCanvas* canvas, SkGLContextHelper* gl) {
     WallTimer timer;
@@ skipping 163 matching lines @@
         GPU_TARGET(nvprmsaa16, GrContextFactory::kNVPR_GLContextType, _8888, 16)
         GPU_TARGET(debug,     GrContextFactory::kDebug_GLContextType, _8888, 0)
         GPU_TARGET(nullgpu,    GrContextFactory::kNull_GLContextType, _8888, 0)
         #if SK_ANGLE
             GPU_TARGET(angle, GrContextFactory::kANGLE_GLContextType, _8888, 0)
         #endif
     }
 #endif
 }
 
+static void fill_static_options(ResultsWriter* log) {
+#if defined(SK_BUILD_FOR_WIN32)
+    log->option("system", "WIN32");
+#elif defined(SK_BUILD_FOR_MAC)
+    log->option("system", "MAC");
+#elif defined(SK_BUILD_FOR_ANDROID)
+    log->option("system", "ANDROID");
+#elif defined(SK_BUILD_FOR_UNIX)
+    log->option("system", "UNIX");
+#else
+    log->option("system", "other");
+#endif
+#if defined(SK_DEBUG)
+    log->option("build", "DEBUG");
+#else
+    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);
 
+    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) {
         // 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())) {
             continue;
         }
+        log.bench(bench->getName(), bench->getSize().fX, bench->getSize().fY);
 
         SkTDArray<Target*> targets;
         create_targets(bench.get(), &targets);
 
         bench->preDraw();
         for (int j = 0; j < targets.count(); j++) {
             SkCanvas* canvas = targets[j]->surface.get() ? targets[j]->surface->getCanvas() : NULL;
 
             const int loops =
 #if SK_SUPPORT_GPU
                 Benchmark::kGPU_Backend == targets[j]->backend
                 ? gpu_bench(targets[j]->gl, bench.get(), canvas, samples.get())
                 :
 #endif
                  cpu_bench(       overhead, bench.get(), canvas, samples.get());
 
             Stats stats(samples.get(), FLAGS_samples);
 
             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) {
                 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);
@@ skipping 16 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif