nanobench: add median and --cpu/--gpu

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 20 matching lines @@
 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.");
 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.");
+
 
 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 135 matching lines @@
     const int w = bench->getSize().fX,
               h = bench->getSize().fY;
     const SkImageInfo _8888 = { w, h, kN32_SkColorType,     kPremul_SkAlphaType },
                        _565 = { w, h, kRGB_565_SkColorType, kOpaque_SkAlphaType };
 
     #define CPU_TARGET(config, backend, code)                              \
         if (Target* t = is_enabled(bench, Benchmark::backend, #config)) {  \
             t->surface.reset(code);                                        \
             targets->push(t);                                              \
         }
-    CPU_TARGET(nonrendering, kNonRendering_Backend, NULL)
-    CPU_TARGET(8888, kRaster_Backend, SkSurface::NewRaster(_8888))
-    CPU_TARGET(565,  kRaster_Backend, SkSurface::NewRaster(_565))
+    if (FLAGS_cpu) {
+        CPU_TARGET(nonrendering, kNonRendering_Backend, NULL)
+        CPU_TARGET(8888, kRaster_Backend, SkSurface::NewRaster(_8888))
+        CPU_TARGET(565,  kRaster_Backend, SkSurface::NewRaster(_565))
+    }
 
 #if SK_SUPPORT_GPU
     #define GPU_TARGET(config, ctxType, info, samples)                                            \
         if (Target* t = is_enabled(bench, Benchmark::kGPU_Backend, #config)) {                    \
             t->surface.reset(SkSurface::NewRenderTarget(gGrFactory.get(ctxType), info, samples)); \
             t->gl = gGrFactory.getGLContext(ctxType);                                             \
             targets->push(t);                                                                     \
         }
-    GPU_TARGET(gpu,      GrContextFactory::kNative_GLContextType, _8888, 0)
-    GPU_TARGET(msaa4,    GrContextFactory::kNative_GLContextType, _8888, 4)
-    GPU_TARGET(msaa16,   GrContextFactory::kNative_GLContextType, _8888, 16)
-    GPU_TARGET(nvprmsaa4,  GrContextFactory::kNVPR_GLContextType, _8888, 4)
-    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
+    if (FLAGS_gpu) {
+        GPU_TARGET(gpu,      GrContextFactory::kNative_GLContextType, _8888, 0)
+        GPU_TARGET(msaa4,    GrContextFactory::kNative_GLContextType, _8888, 4)
+        GPU_TARGET(msaa16,   GrContextFactory::kNative_GLContextType, _8888, 16)
+        GPU_TARGET(nvprmsaa4,  GrContextFactory::kNVPR_GLContextType, _8888, 4)
+        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
 }
 
 int tool_main(int argc, char** argv);
 int tool_main(int argc, char** argv) {
     SetupCrashHandler();
     SkAutoGraphics ag;
     SkCommandLineFlags::Parse(argc, argv);
 
     const double overhead = estimate_timer_overhead();
     SkAutoTMalloc<double> samples(FLAGS_samples);
 
-    // TODO: display add median, use it in --quiet mode
-
     if (FLAGS_verbose) {
         // No header.
     } else if (FLAGS_quiet) {
-        SkDebugf("min\tbench\tconfig\n");
+        SkDebugf("median\tbench\tconfig\n");
     } else {
-        SkDebugf("loops\tmin\tmean\tmax\tstddev\tconfig\tbench\n");
+        SkDebugf("loops\tmin\tmedian\tmean\tmax\tstddev\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;
         }
 
         SkTDArray<Target*> targets;
         create_targets(bench.get(), &targets);
@@ skipping 15 matching lines @@
             const char* config = targets[j]->config;
             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.min).c_str(), bench->getName(), config);
+                SkDebugf("%s\t%s\t%s\n", humanize(stats.median).c_str(), bench->getName(), config);
             } else {
                 const double stddev_percent = 100 * sqrt(stats.var) / stats.mean;
-                SkDebugf("%d\t%s\t%s\t%s\t%.0f%%\t%s\t%s\n"
+                SkDebugf("%d\t%s\t%s\t%s\t%s\t%.0f%%\t%s\t%s\n"
                         , loops
                         , humanize(stats.min).c_str()
+                        , humanize(stats.median).c_str()
                         , humanize(stats.mean).c_str()
                         , humanize(stats.max).c_str()
                         , stddev_percent
                         , config
                         , bench->getName()
                         );
             }
         }
         targets.deleteAll();
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif