Change JSON output of nanobench.

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"
@@ skipping 34 matching lines @@
 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.");
 DEFINE_bool(resetGpuContext, true, "Reset the GrContext before running each bench.");
 DEFINE_int32(maxCalibrationAttempts, 3,
              "Try up to this many times to guess loops for a bench, or skip the bench.");
+DEFINE_string(key, "", "Space-separated key/value pairs to add to JSON.");
+DEFINE_string(gitHash, "", "Git hash to add to JSON.");
 
 
 static SkString humanize(double ms) {
     if (ms > 1e+3) return SkStringPrintf("%.3gs",  ms/1e3);
     if (ms < 1e-3) return SkStringPrintf("%.3gns", ms*1e6);
 #ifdef SK_BUILD_FOR_WIN
     if (ms < 1)    return SkStringPrintf("%.3gus", ms*1e3);
 #else
     if (ms < 1)    return SkStringPrintf("%.3gµs", ms*1e3);
 #endif
@@ skipping 195 matching lines @@
 #else
     log->option("system", "other");
 #endif
 #if defined(SK_DEBUG)
     log->option("build", "DEBUG");
 #else
     log->option("build", "RELEASE");
 #endif
 }
 
+#if SK_SUPPORT_GPU
+static void fill_gpu_options(ResultsWriter* log) {
+    // Need help, how do I get the GL version, vendor, renderer, etc?

[jcgregorio, 2014/07/16 19:11:29]

Open question here, how do I do this?

[bsalomon, 2014/07/16 19:36:29]

You want to tunnel the SkGLContextHelper here (available via
GrContextFactory::getGLContext())

Then you can call:

GLubyte* version;
SK_GL_RET(ctx, version, GetString(GR_GL_VERSION));
log->option("GL_VERSION", (const char*) version);

Same for GL_RENDERER, GL_VENDOR, and maybe GL_SHADING_LANGUAGE_VERSION.

[jcgregorio, 2014/07/17 13:11:51]

Thanks!

On 2014/07/16 19:36:29, bsalomon wrote:

+    log->option("GL_VERSION", "4.4");
+}
+#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])));
+    SkAutoTDelete<NanoJSONResultsWriter> json;
+    if (!FLAGS_outResultsFile.isEmpty() && !FLAGS_gitHash.isEmpty() ) {
+        json.reset(SkNEW(NanoJSONResultsWriter(FLAGS_outResultsFile[0], FLAGS_gitHash[0])));
         log.add(json.get());
     }
     CallEnd<MultiResultsWriter> ender(log);
+
+    if (1 == FLAGS_key.count() % 2) {
+        SkDebugf("ERROR: --key must be passed with an even number of arguments");
+        return 1;
+    }
+    for (int i = 1; i < FLAGS_key.count(); i += 2) {
+        log.key(FLAGS_key[i-1], FLAGS_key[i]);
+    }
     fill_static_options(&log);
 
+#if SK_SUPPORT_GPU
+    fill_gpu_options(&log);
+#endif
+
     const double overhead = estimate_timer_overhead();
     SkAutoTMalloc<double> samples(FLAGS_samples);
 
     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())) {
             continue;
         }
-        log.bench(bench->getName(), bench->getSize().fX, bench->getSize().fY);
+        bool loggedBench = false;

[mtklein, 2014/07/16 19:26:51]

Why this change?

[jcgregorio, 2014/07/17 13:11:51]

So that we only add info to the JSON file if we actually run a test. The way it
was before there would be an entry in the JSON for every possible test, even if
nothing was run, so they would point to empty JSON objects.

 
         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 char* config = targets[j]->config;
 
             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());
 
             if (loops == 0) {
                 SkDebugf("Unable to time %s\t%s (overhead %s)\n",
                          bench->getName(), config, humanize(overhead).c_str());
                 continue;
             }
+            if (!loggedBench) {
+                log.bench(bench->getName(), bench->getSize().fX, bench->getSize().fY);
+                loggedBench = true;
+            }
 
             Stats stats(samples.get(), FLAGS_samples);
             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_runOnce) {
@@ skipping 36 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif