Add --properties for things like gitHash that describe the current nanobench run.

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 46 matching lines @@
               "Loop until timer overhead is at most this fraction of our measurments.");
 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(gpuCompressAlphaMasks, false, "Compress masks generated from falling back to "
                                           "software path rendering.");
 
 DEFINE_string(outResultsFile, "", "If given, write results here as JSON.");
 DEFINE_int32(maxCalibrationAttempts, 3,
              "Try up to this many times to guess loops for a bench, or skip the bench.");
 DEFINE_int32(maxLoops, 1000000, "Never run a bench more times than this.");
+DEFINE_string(properties, "",
+              "Space-separated key/value pairs to add to JSON identifying this nanobench run.");
 DEFINE_string(key, "",
               "Space-separated key/value pairs to add to JSON identifying this bench config.");
-DEFINE_string(options, "",
-              "Space-separated option/value pairs to add to JSON, logging extra info.");
-DEFINE_string(gitHash, "", "Git hash to add to JSON.");
 
 DEFINE_string(clip, "0,0,1000,1000", "Clip for SKPs.");
 DEFINE_string(scales, "1.0", "Space-separated scales for SKPs.");
 
 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
@@ skipping 303 matching lines @@
 static void create_targets(SkTDArray<Target*>* targets, Benchmark* b,
                            const SkTDArray<Config>& configs) {
     for (int i = 0; i < configs.count(); ++i) {
         if (Target* t = is_enabled(b, configs[i])) {
             targets->push(t);
         }
 
     }
 }
 
-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 SK_SUPPORT_GPU
 static void fill_gpu_options(ResultsWriter* log, SkGLContextHelper* ctx) {
     const GrGLubyte* version;
     SK_GL_RET(*ctx, version, GetString(GR_GL_VERSION));
     log->configOption("GL_VERSION", (const char*)(version));
 
     SK_GL_RET(*ctx, version, GetString(GR_GL_RENDERER));
     log->configOption("GL_RENDERER", (const char*) version);
 
     SK_GL_RET(*ctx, version, GetString(GR_GL_VENDOR));
@@ skipping 127 matching lines @@
     }
 
     if (!FLAGS_writePath.isEmpty()) {
         SkDebugf("Writing files to %s.\n", FLAGS_writePath[0]);
         if (!sk_mkdir(FLAGS_writePath[0])) {
             SkDebugf("Could not create %s. Files won't be written.\n", FLAGS_writePath[0]);
             FLAGS_writePath.set(0, NULL);
         }
     }
 
-    MultiResultsWriter log;
-    SkAutoTDelete<NanoJSONResultsWriter> json;
+    SkAutoTDelete<ResultsWriter> log(SkNEW(ResultsWriter));
     if (!FLAGS_outResultsFile.isEmpty()) {
-        const char* gitHash = FLAGS_gitHash.isEmpty() ? "unknown-revision" : FLAGS_gitHash[0];
-        json.reset(SkNEW(NanoJSONResultsWriter(FLAGS_outResultsFile[0], gitHash)));
-        log.add(json.get());
+        log.reset(SkNEW(NanoJSONResultsWriter(FLAGS_outResultsFile[0])));
     }
-    CallEnd<MultiResultsWriter> ender(log);
+
+    if (1 == FLAGS_properties.count() % 2) {
+        SkDebugf("ERROR: --properties must be passed with an even number of arguments.\n");
+        return 1;
+    }
+    for (int i = 1; i < FLAGS_properties.count(); i += 2) {
+        log->property(FLAGS_properties[i-1], FLAGS_properties[i]);
+    }
 
     if (1 == FLAGS_key.count() % 2) {
         SkDebugf("ERROR: --key must be passed with an even number of arguments.\n");
         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 (1 == FLAGS_options.count() % 2) {
-        SkDebugf("ERROR: --options must be passed with an even number of arguments.\n");
-        return 1;
-    }
-    for (int i = 1; i < FLAGS_options.count(); i += 2) {
-        log.option(FLAGS_options[i-1], FLAGS_options[i]);
+        log->key(FLAGS_key[i-1], FLAGS_key[i]);
     }
 
     const double overhead = estimate_timer_overhead();
     SkDebugf("Timer overhead: %s\n", HUMANIZE(overhead));
 
     SkAutoTMalloc<double> samples(FLAGS_samples);
 
     if (kAutoTuneLoops != FLAGS_loops) {
         SkDebugf("Fixed number of loops; times would only be misleading so we won't print them.\n");
     } else if (FLAGS_verbose) {
@@ skipping 11 matching lines @@
     while (Benchmark* b = benchStream.next()) {
         SkAutoTDelete<Benchmark> bench(b);
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getName())) {
             continue;
         }
 
         SkTDArray<Target*> targets;
         create_targets(&targets, bench.get(), configs);
 
         if (!targets.isEmpty()) {
-            log.bench(bench->getName(), bench->getSize().fX, bench->getSize().fY);
+            log->bench(bench->getName(), bench->getSize().fX, bench->getSize().fY);
             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.name;
 
 #ifdef SK_DEBUG
             // skia:2797  Some SKPs SkASSERT in debug mode.  Skip them for now.
             if (0 == strcmp("565", config) && SkStrContains(bench->getName(), ".skp")) {
                 SkDebugf("Skipping 565 %s.  See skia:2797\n", bench->getName());
@@ skipping 15 matching lines @@
                 pngFilename.append(".png");
                 write_canvas_png(canvas, pngFilename);
             }
 
             if (kFailedLoops == loops) {
                 // Can't be timed.  A warning note has already been printed.
                 continue;
             }
 
             Stats stats(samples.get(), FLAGS_samples);
-            log.config(config);
-            benchStream.fillCurrentOptions(&log);
+            log->config(config);
+            benchStream.fillCurrentOptions(log.get());
 #if SK_SUPPORT_GPU
             if (Benchmark::kGPU_Backend == targets[j]->config.backend) {
-                fill_gpu_options(&log, targets[j]->gl);
+                fill_gpu_options(log.get(), targets[j]->gl);
             }
 #endif
-            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));
+            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 (kAutoTuneLoops != FLAGS_loops) {
                 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]));
                 }
@@ skipping 33 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif