nanobench: support GMs-as-benches

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 "GMBench.h"
 #include "ResultsWriter.h"
 #include "Stats.h"
 #include "Timer.h"
 
 #include "SkCanvas.h"
 #include "SkCommonFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkString.h"
 #include "SkSurface.h"
@@ skipping 210 matching lines @@
         return sampleCnt <= ctx->getMaxSampleCount();
     }
     return false;
 }
 #endif
 
 #if SK_SUPPORT_GPU
 #define kBogusGLContextType GrContextFactory::kNative_GLContextType
 #else
 #define kBogusGLContextType 0
-#endif 
+#endif
 
 // Append all configs that are enabled and supported.
 static void create_configs(SkTDArray<Config>* configs) {
     #define CPU_CONFIG(name, backend, color, alpha)                                               \
         if (is_cpu_config_allowed(#name)) {                                                       \
             Config config = { #name, Benchmark::backend, color, alpha, 0, kBogusGLContextType };  \
             configs->push(config);                                                                \
         }
-         
+
     if (FLAGS_cpu) {
         CPU_CONFIG(nonrendering, kNonRendering_Backend, kUnknown_SkColorType, kUnpremul_SkAlphaType)
         CPU_CONFIG(8888, kRaster_Backend, kN32_SkColorType, kPremul_SkAlphaType)
         CPU_CONFIG(565, kRaster_Backend, kRGB_565_SkColorType, kOpaque_SkAlphaType)
     }
 
 #if SK_SUPPORT_GPU
     #define GPU_CONFIG(name, ctxType, samples)                                   \
         if (is_gpu_config_allowed(#name, GrContextFactory::ctxType, samples)) {  \
             Config config = {                                                    \
                 #name,                                                           \
                 Benchmark::kGPU_Backend,                                         \
                 kN32_SkColorType,                                                \
                 kPremul_SkAlphaType,                                             \
                 samples,                                                         \
                 GrContextFactory::ctxType };                                     \
             configs->push(config);                                               \
         }
-         
+
     if (FLAGS_gpu) {
         GPU_CONFIG(gpu, kNative_GLContextType, 0)
         GPU_CONFIG(msaa4, kNative_GLContextType, 4)
         GPU_CONFIG(msaa16, kNative_GLContextType, 16)
         GPU_CONFIG(nvprmsaa4, kNVPR_GLContextType, 4)
         GPU_CONFIG(nvprmsaa16, kNVPR_GLContextType, 16)
         GPU_CONFIG(debug, kDebug_GLContextType, 0)
         GPU_CONFIG(nullgpu, kNull_GLContextType, 0)
     }
 #endif
@@ skipping 31 matching lines @@
     return target;
 }
 
 // Creates targets for a benchmark and a set of configs.
 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");
@@ skipping 14 matching lines @@
     log->configOption("GL_RENDERER", (const char*) version);
 
     SK_GL_RET(*ctx, version, GetString(GR_GL_VENDOR));
     log->configOption("GL_VENDOR", (const char*) version);
 
     SK_GL_RET(*ctx, version, GetString(GR_GL_SHADING_LANGUAGE_VERSION));
     log->configOption("GL_SHADING_LANGUAGE_VERSION", (const char*) version);
 }
 #endif
 
+class BenchmarkStream {
+public:
+    BenchmarkStream() : fBenches(BenchRegistry::Head()) , fGMs(skiagm::GMRegistry::Head()) {}
+
+    Benchmark* next(const char** sourceType) {
+        if (fBenches) {
+            Benchmark* bench = fBenches->factory()(NULL);
+            fBenches = fBenches->next();
+            *sourceType = "bench";
+            return bench;
+        }
+        while (fGMs) {
+            SkAutoTDelete<skiagm::GM> gm(fGMs->factory()(NULL));
+            fGMs = fGMs->next();
+            if (gm->getFlags() & skiagm::GM::kAsBench_Flag) {
+                *sourceType = "gm";
+                return SkNEW_ARGS(GMBench, (gm.detach()));
+            }
+        }
+        return NULL;
+    }
+private:
+    const BenchRegistry* fBenches;
+    const skiagm::GMRegistry* fGMs;
+};
+
 int nanobench_main();
 int nanobench_main() {
     SetupCrashHandler();
     SkAutoGraphics ag;
 
     if (FLAGS_runOnce) {
         FLAGS_samples     = 1;
         FLAGS_gpuFrameLag = 0;
     }
 
@@ skipping 26 matching lines @@
         // No header.
     } else if (FLAGS_quiet) {
         SkDebugf("median\tbench\tconfig\n");
     } else {
         SkDebugf("loops\tmin\tmedian\tmean\tmax\tstddev\tsamples\tconfig\tbench\n");
     }
 
     SkTDArray<Config> configs;
     create_configs(&configs);
 
-    for (const BenchRegistry* r = BenchRegistry::Head(); r != NULL; r = r->next()) {
-        SkAutoTDelete<Benchmark> bench(r->factory()(NULL));
+    BenchmarkStream benches;
+    const char* sourceType;
+    while (Benchmark* b = benches.next(&sourceType)) {
+        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);
             bench->preDraw();
@@ skipping 11 matching lines @@
                  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));
                 continue;
             }
 
             Stats stats(samples.get(), FLAGS_samples);
             log.config(config);
+            log.configOption("source_type", sourceType);
 #if SK_SUPPORT_GPU
             if (Benchmark::kGPU_Backend == targets[j]->config.backend) {
                 fill_gpu_options(&log, 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));
@@ skipping 42 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif