Adding support for parsing extended gpu config parameters in 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 "nanobench.h"
@@ skipping 167 matching lines @@
                                                                        this->config.ctxOptions),
                                                          SkSurface::kNo_Budgeted, info,
                                                          this->config.samples, &props));
         this->gl = gGrFactory->getContextInfo(this->config.ctxType,
                                               this->config.ctxOptions).fGLContext;
         if (!this->surface.get()) {
             return false;
         }
         if (!this->gl->fenceSyncSupport()) {
             SkDebugf("WARNING: GL context for config \"%s\" does not support fence sync. "
-                     "Timings might not be accurate.\n", this->config.name);
+                     "Timings might not be accurate.\n", this->config.name.c_str());
         }
         return true;
     }
     void fillOptions(ResultsWriter* log) override {
         const GrGLubyte* version;
         SK_GL_RET(*this->gl, version, GetString(GR_GL_VERSION));
         log->configOption("GL_VERSION", (const char*)(version));
 
         SK_GL_RET(*this->gl, version, GetString(GR_GL_RENDERER));
         log->configOption("GL_RENDERER", (const char*) version);
@@ skipping 166 matching lines @@
 
     // Pretty much the same deal as the calibration: do some warmup to make
     // sure we're timing steady-state pipelined frames.
     for (int i = 0; i < maxGpuFrameLag - 1; i++) {
         time(loops, bench, target);
     }
 
     return loops;
 }
 
-static SkString to_lower(const char* str) {
-    SkString lower(str);
-    for (size_t i = 0; i < lower.size(); i++) {
-        lower[i] = tolower(lower[i]);
-    }
-    return lower;
-}
-
-static bool is_cpu_config_allowed(const char* name) {
-    for (int i = 0; i < FLAGS_config.count(); i++) {
-        if (to_lower(FLAGS_config[i]).equals(name)) {
-            return true;
-        }
-    }
-    return false;
-}
-
-#if SK_SUPPORT_GPU
-static bool is_gpu_config_allowed(const char* name, GrContextFactory::GLContextType ctxType,
-                                  GrContextFactory::GLContextOptions ctxOptions,
-                                  int sampleCnt) {
-    if (!is_cpu_config_allowed(name)) {
-        return false;
-    }
-    if (const GrContext* ctx = gGrFactory->get(ctxType, ctxOptions)) {
-        return sampleCnt <= ctx->caps()->maxSampleCount();
-    }
-    return false;
-}
-#endif
-
 #if SK_SUPPORT_GPU
 #define kBogusGLContextType GrContextFactory::kNative_GLContextType
 #define kBogusGLContextOptions GrContextFactory::kNone_GLContextOptions
 #else
 #define kBogusGLContextType 0
 #define kBogusGLContextOptions 0
 #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, kBogusGLContextOptions, \
-                              false };                                     \
-            configs->push(config);                                         \
+static void create_config(const SkCommandLineConfig* config, SkTArray<Config>* configs) {
+
+#if SK_SUPPORT_GPU
+    if (const auto* gpuConfig = config->asConfigGpu()) {
+        if (!FLAGS_gpu)
+            return;
+
+        const auto ctxOptions = gpuConfig->getUseNVPR() ? GrContextFactory::kEnableNVPR_GLContextOptions 
+                                                        : GrContextFactory::kNone_GLContextOptions;
+        const auto ctxType = gpuConfig->getContextType();
+        const auto sampleCount = gpuConfig->getSamples();
+
+        if (const GrContext* ctx = gGrFactory->get(ctxType, ctxOptions)) {
+            const auto maxSampleCount = ctx->caps()->maxSampleCount();
+            if (sampleCount > ctx->caps()->maxSampleCount()) {
+                SkDebugf("Configuration sample count %d exceeds maximum %d.\n",
+                    sampleCount, maxSampleCount);
+                return;
+            }
+        } else {
+            SkDebugf("No context was available matching config type and options.\n");
+            return;
+        }
+
+        Config target = {
+            config->getTag(),
+            Benchmark::kGPU_Backend,
+            kN32_SkColorType,
+            kPremul_SkAlphaType,
+            sampleCount,
+            ctxType,
+            ctxOptions,        
+            false };
+
+        configs->push_back(target);
+        return;
+    }
+#endif
+
+    #define CPU_CONFIG(name, backend, color, alpha)                                  \
+        if (config->getTag().equals(#name)) {                                        \
+            Config config = { SkString(#name), Benchmark::backend, color, alpha, 0,  \
+                              kBogusGLContextType, kBogusGLContextOptions,           \
+                              false };                                               \
+            configs->push_back(config);                                              \
+            return;                                                                  \
         }
 
     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, ctxOptions, samples, useDFText)            \
-        if (is_gpu_config_allowed(#name, GrContextFactory::ctxType,              \
-                                  GrContextFactory::ctxOptions, samples)) {      \
-            Config config = {                                                    \
-                #name,                                                           \
-                Benchmark::kGPU_Backend,                                         \
-                kN32_SkColorType,                                                \
-                kPremul_SkAlphaType,                                             \
-                samples,                                                         \
-                GrContextFactory::ctxType,                                       \
-                GrContextFactory::ctxOptions,                                    \
-                useDFText };                                                     \
-            configs->push(config);                                               \
-        }
-
-    if (FLAGS_gpu) {
-        GPU_CONFIG(gpu, kNative_GLContextType, kNone_GLContextOptions, 0, false)
-        GPU_CONFIG(msaa4, kNative_GLContextType, kNone_GLContextOptions, 4, false)
-        GPU_CONFIG(msaa16, kNative_GLContextType, kNone_GLContextOptions, 16, false)
-        GPU_CONFIG(nvprmsaa4, kNative_GLContextType, kEnableNVPR_GLContextOptions, 4, false)
-        GPU_CONFIG(nvprmsaa16, kNative_GLContextType, kEnableNVPR_GLContextOptions, 16, false)
-        GPU_CONFIG(gpudft, kNative_GLContextType, kNone_GLContextOptions, 0, true)
-        GPU_CONFIG(debug, kDebug_GLContextType, kNone_GLContextOptions, 0, false)
-        GPU_CONFIG(nullgpu, kNull_GLContextType, kNone_GLContextOptions, 0, false)
-#if SK_ANGLE
-#ifdef SK_BUILD_FOR_WIN
-        GPU_CONFIG(angle, kANGLE_GLContextType, kNone_GLContextOptions, 0, false)
-#endif
-        GPU_CONFIG(angle-gl, kANGLE_GL_GLContextType, kNone_GLContextOptions, 0, false)
-#endif
-#if SK_COMMAND_BUFFER
-        GPU_CONFIG(commandbuffer, kCommandBuffer_GLContextType, kNone_GLContextOptions, 0, false)
-#endif
-#if SK_MESA
-        GPU_CONFIG(mesa, kMESA_GLContextType, kNone_GLContextOptions, 0, false)
-#endif
-    }
-#endif
+    #undef CPU_CONFIG
 
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
-    if (is_cpu_config_allowed("hwui")) {
+    if (is_cpu_config_allowed("hwui", config)) {
         Config config = { "hwui", Benchmark::kHWUI_Backend, kRGBA_8888_SkColorType,
                           kPremul_SkAlphaType, 0, kBogusGLContextType, kBogusGLContextOptions,
                           false };
-        configs->push(config);
+        configs->push_back(config);
+        return;
     }
 #endif
 }
 
+// Append all configs that are enabled and supported.
+void create_configs(SkTArray<Config>* configs) {
+    SkCommandLineConfigArray array;
+    ParseConfigs(FLAGS_config, &array);
+    for (int i = 0; i < array.count(); ++i) {
+        create_config(array[i], configs);
+    }
+}
+
 // If bench is enabled for config, returns a Target* for it, otherwise nullptr.
 static Target* is_enabled(Benchmark* bench, const Config& config) {
     if (!bench->isSuitableFor(config.backend)) {
         return nullptr;
     }
 
     SkImageInfo info = SkImageInfo::Make(bench->getSize().fX, bench->getSize().fY,
                                          config.color, config.alpha);
 
     Target* target = nullptr;
@@ skipping 593 matching lines @@
     } else if (FLAGS_quiet) {
         SkDebugf("! -> high variance, ? -> moderate variance\n");
         SkDebugf("    micros   \tbench\n");
     } else if (FLAGS_ms) {
         SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\tsamples\tconfig\tbench\n");
     } else {
         SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\t%-*s\tconfig\tbench\n",
                  FLAGS_samples, "samples");
     }
 
-    SkTDArray<Config> configs;
+    SkTArray<Config> configs;
     create_configs(&configs);
 
     if (FLAGS_keepAlive) {
         start_keepalive();
     }
 
     int runs = 0;
     BenchmarkStream benchStream;
     while (Benchmark* b = benchStream.next()) {
         SkAutoTDelete<Benchmark> bench(b);
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getUniqueName())) {
             continue;
         }
 
-        if (!configs.isEmpty()) {
+        if (!configs.empty()) {
             log->bench(bench->getUniqueName(), bench->getSize().fX, bench->getSize().fY);
             bench->delayedSetup();
         }
         for (int i = 0; i < configs.count(); ++i) {
             Target* target = is_enabled(b, configs[i]);
             if (!target) {
                 continue;
             }
 
             // During HWUI output this canvas may be nullptr.
             SkCanvas* canvas = target->getCanvas();
-            const char* config = target->config.name;
+            const char* config = target->config.name.c_str();
 
             target->setup();
             bench->perCanvasPreDraw(canvas);
 
             int maxFrameLag;
             int loops = target->needsFrameTiming(&maxFrameLag)
                 ? setup_gpu_bench(target, bench.get(), maxFrameLag)
                 : setup_cpu_bench(overhead, target, bench.get());
 
             if (FLAGS_ms) {
@@ skipping 122 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif