Support using OpenGL ES context on desktop

dm/DM.cpp

 // Main binary for DM.
 // For a high-level overview, please see dm/README.
 
 #include "SkBenchmark.h"
 #include "SkCommandLineFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkPicture.h"
 #include "SkString.h"
 #include "Test.h"
@@ skipping 18 matching lines @@
 #  define RASTERIZE_PDF_PROC NULL
 #endif
 
 #include <ctype.h>
 
 using skiagm::GM;
 using skiagm::GMRegistry;
 using skiatest::Test;
 using skiatest::TestRegistry;
 
+static const char kGpuApiNameGL[] = "gl";
+static const char kGpuApiNameGLES[] = "gles";
+
 DEFINE_int32(threads, -1, "Threads for CPU work. Default NUM_CPUS.");
 DEFINE_int32(gpuThreads, 1, "Threads for GPU work.");
+DEFINE_string(forceGpuApi, "", "Force use of specific gpu API.  Using \"gl\" "

[mtklein, 2014/06/09 14:10:46]

Personally I'd go with just gpuAPI?

Is there any way we can do both GL and GLES in the same process?  Is this a
global thing or can we get two Ganeshes going at once, one GL, one GLES?  We
don't necessarily have to do that today, but it'd help me understand how better
to structure this in DM.

[bsalomon, 2014/06/09 14:15:11]

It definitely *could* be implemented that way. One way of structuring this could
be to have the API as part of the config, though I'd want the configs to be
generated in that case as the x-product is getting larger (msaa sample count,
nvpr-enabled vs disabled, GLES/GL, debug/null/native/mesa/angle)

[mtklein, 2014/06/09 14:20:21]

Yeah, this is fine, we can cross them here inside DM.cpp.  What I'm wondering is
if we really have to choose here, or can we do everything at the same time?

[bsalomon, 2014/06/09 14:29:52]

If we move towards supporting arbitrary members of the x-product of GPU config
variants, the number of configs is too large to run all at once and very
redundant. I think we'll want some idea of defaults that give good coverage and
then have a way for a caller to select an arbitrary subset at the cmd line or
perhaps with a config file.

[Kimmo Kinnunen, 2014/06/16 12:36:40]

Done.

+              "forces OpenGL API. Using \"gles\" forces OpenGL ES API. "
+              "Defaults to empty string, which selects the API native to the "
+              "system.");
 #ifdef SK_BUILD_JSON_WRITER
 DEFINE_string2(expectations, r, "",
                "If a directory, compare generated images against images under this path. "
                "If a file, compare generated images against JSON expectations at this path."
 );
 #else
 DEFINE_string2(expectations, r, "",
                "If a directory, compare generated images against images under this path. "
 );
 #endif
@@ skipping 42 matching lines @@
 #endif
 static const GrContextFactory::GLContextType mesa   =
 #if SK_MESA
 GrContextFactory::kMESA_GLContextType;
 #else
 native;
 #endif
 
 static void kick_off_gms(const SkTDArray<GMRegistry::Factory>& gms,
                          const SkTArray<SkString>& configs,
+                         GrGLStandard forcedGpuApi,
                          const DM::Expectations& expectations,
                          DM::Reporter* reporter,
                          DM::TaskRunner* tasks) {
 #define START(name, type, ...)                                                        \
     if (lowercase(configs[j]).equals(name)) {                                         \
         tasks->add(SkNEW_ARGS(DM::type,                                               \
                     (name, reporter, tasks, expectations, gms[i], ## __VA_ARGS__)));  \
     }
     for (int i = 0; i < gms.count(); i++) {
         for (int j = 0; j < configs.count(); j++) {
             START("565",        CpuGMTask, kRGB_565_SkColorType);
             START("8888",       CpuGMTask, kN32_SkColorType);
-            START("gpu",        GpuGMTask, native, 0);
-            START("msaa4",      GpuGMTask, native, 4);
-            START("msaa16",     GpuGMTask, native, 16);
-            START("nvprmsaa4",  GpuGMTask, nvpr,  4);
-            START("nvprmsaa16", GpuGMTask, nvpr, 16);
-            START("gpunull",    GpuGMTask, null,   0);
-            START("gpudebug",   GpuGMTask, debug,  0);
-            START("angle",      GpuGMTask, angle,  0);
-            START("mesa",       GpuGMTask, mesa,   0);
+            START("gpu",        GpuGMTask, native, forcedGpuApi, 0);
+            START("msaa4",      GpuGMTask, native, forcedGpuApi, 4);
+            START("msaa16",     GpuGMTask, native, forcedGpuApi, 16);
+            START("nvprmsaa4",  GpuGMTask, nvpr, forcedGpuApi, 4);
+            START("nvprmsaa16", GpuGMTask, nvpr, forcedGpuApi, 16);
+            START("gpunull",    GpuGMTask, null, forcedGpuApi, 0);
+            START("gpudebug",   GpuGMTask, debug, forcedGpuApi, 0);
+            START("angle",      GpuGMTask, angle, forcedGpuApi, 0);
+            START("mesa",       GpuGMTask, mesa, forcedGpuApi, 0);
             START("pdf",        PDFTask,   RASTERIZE_PDF_PROC);
         }
     }
 #undef START
 }
 
 static void kick_off_benches(const SkTDArray<BenchRegistry::Factory>& benches,
                              const SkTArray<SkString>& configs,
+                             GrGLStandard forcedGpuApi,
                              DM::Reporter* reporter,
                              DM::TaskRunner* tasks) {
 #define START(name, type, ...)                                                                 \
     if (lowercase(configs[j]).equals(name)) {                                                  \
         tasks->add(SkNEW_ARGS(DM::type, (name, reporter, tasks, benches[i], ## __VA_ARGS__))); \
     }
     for (int i = 0; i < benches.count(); i++) {
         for (int j = 0; j < configs.count(); j++) {
             START("nonrendering", NonRenderingBenchTask);
             START("565",          CpuBenchTask, kRGB_565_SkColorType);
             START("8888",         CpuBenchTask, kN32_SkColorType);
-            START("gpu",          GpuBenchTask, native, 0);
-            START("msaa4",        GpuBenchTask, native, 4);
-            START("msaa16",       GpuBenchTask, native, 16);
-            START("nvprmsaa4",    GpuBenchTask, nvpr,   4);
-            START("nvprmsaa16",   GpuBenchTask, nvpr,   16);
-            START("gpunull",      GpuBenchTask, null,   0);
-            START("gpudebug",     GpuBenchTask, debug,  0);
-            START("angle",        GpuBenchTask, angle,  0);
-            START("mesa",         GpuBenchTask, mesa,   0);
+            START("gpu",          GpuBenchTask, native, forcedGpuApi, 0);
+            START("msaa4",        GpuBenchTask, native, forcedGpuApi, 4);
+            START("msaa16",       GpuBenchTask, native, forcedGpuApi, 16);
+            START("nvprmsaa4",    GpuBenchTask, nvpr,   forcedGpuApi, 4);
+            START("nvprmsaa16",   GpuBenchTask, nvpr,   forcedGpuApi, 16);
+            START("gpunull",      GpuBenchTask, null,   forcedGpuApi, 0);
+            START("gpudebug",     GpuBenchTask, debug,  forcedGpuApi, 0);
+            START("angle",        GpuBenchTask, angle,  forcedGpuApi, 0);
+            START("mesa",         GpuBenchTask, mesa,   forcedGpuApi, 0);
         }
     }
 #undef START
 }
 
 static void kick_off_tests(const SkTDArray<TestRegistry::Factory>& tests,
                            DM::Reporter* reporter,
                            DM::TaskRunner* tasks) {
     for (int i = 0; i < tests.count(); i++) {
         SkAutoTDelete<Test> test(tests[i](NULL));
@@ skipping 39 matching lines @@
         return;
     }
 
     SkDebugf("Failures:\n");
     for (int i = 0; i < failures.count(); i++) {
         SkDebugf("  %s\n", failures[i].c_str());
     }
     SkDebugf("%d failures.\n", failures.count());
 }
 
+static void get_forced_gpu_api_if_matches(GrGLStandard* forcedGpuApi) {

[mtklein, 2014/06/09 14:10:45]

Simplify?

static GrGLStandard get_gl_standard() {
  if (FLAGS_gpuAPI.contains("gl"))   { return kGL_GrGLStandard;   }
  if (FLAGS_gpuAPI.conaints("gles")) { return kGLES_GrGLStandard; }
  return kNone_GrGLStandard;
}

[Kimmo Kinnunen, 2014/06/16 12:36:39]

Done.

+    if (1 == FLAGS_forceGpuApi.count()) {
+        if (strcmp(FLAGS_forceGpuApi[0], kGpuApiNameGL) == 0) {
+            *forcedGpuApi = kGL_GrGLStandard;
+            return;
+        } else if (strcmp(FLAGS_forceGpuApi[0], kGpuApiNameGLES) == 0) {
+            *forcedGpuApi = kGLES_GrGLStandard;
+            return;
+        }
+    }
+    *forcedGpuApi = kNone_GrGLStandard;

[mtklein, 2014/06/09 14:10:45]

What happens if I run DM in None mode?  Does that pick up the default?

[Kimmo Kinnunen, 2014/06/16 12:36:39]

Yeah. None picks up the default for the platform.

+}
+
 template <typename T, typename Registry>
 static void append_matching_factories(Registry* head, SkTDArray<typename Registry::Factory>* out) {
     for (const Registry* reg = head; reg != NULL; reg = reg->next()) {
         SkAutoTDelete<T> forName(reg->factory()(NULL));
         if (!SkCommandLineFlags::ShouldSkip(FLAGS_match, forName->getName())) {
             *out->append() = reg->factory();
         }
     }
 }
 
@@ skipping 10 matching lines @@
 #endif
     GM::SetResourcePath(FLAGS_resources[0]);
     SkBenchmark::SetResourcePath(FLAGS_resources[0]);
     Test::SetResourcePath(FLAGS_resources[0]);
 
     SkTArray<SkString> configs;
     for (int i = 0; i < FLAGS_config.count(); i++) {
         SkStrSplit(FLAGS_config[i], ", ", &configs);
     }
 
+    GrGLStandard forcedGpuApi = kNone_GrGLStandard;
+    get_forced_gpu_api_if_matches(&forcedGpuApi);
+
     SkTDArray<GMRegistry::Factory> gms;
     SkAutoTDelete<DM::Expectations> expectations(SkNEW(DM::NoExpectations));
     if (FLAGS_gms) {
         append_matching_factories<GM>(GMRegistry::Head(), &gms);
 
         if (FLAGS_expectations.count() > 0) {
             const char* path = FLAGS_expectations[0];
             if (sk_isdir(path)) {
                 expectations.reset(SkNEW_ARGS(DM::WriteTask::Expectations, (path)));
             } else {
@@ skipping 11 matching lines @@
 
     SkTDArray<TestRegistry::Factory> tests;
     if (FLAGS_tests) {
         append_matching_factories<Test>(TestRegistry::Head(), &tests);
     }
 
     SkDebugf("(%d GMs, %d benches) x %d configs, %d tests\n",
              gms.count(), benches.count(), configs.count(), tests.count());
     DM::Reporter reporter;
     DM::TaskRunner tasks(FLAGS_threads, FLAGS_gpuThreads);
-    kick_off_gms(gms, configs, *expectations, &reporter, &tasks);
-    kick_off_benches(benches, configs, &reporter, &tasks);
+    kick_off_gms(gms, configs, forcedGpuApi, *expectations, &reporter, &tasks);

[mtklein, 2014/06/09 14:10:45]

e.g. could we logically just loop over GPU APIs here instead of picking one?

[Kimmo Kinnunen, 2014/06/16 12:36:39]

IIUC from the discussion above, this was not needed.

[bsalomon, 2014/06/16 14:25:10]

+1 for leaving any running of multiple APIs in a single invocation as future
work.

+    kick_off_benches(benches, configs, forcedGpuApi, &reporter, &tasks);
     kick_off_tests(tests, &reporter, &tasks);
     kick_off_skps(&reporter, &tasks);
     tasks.wait();
 
     SkDebugf("\n");
 
     SkTArray<SkString> failures;
     reporter.getFailures(&failures);
     report_failures(failures);
     return failures.count() > 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char** argv) {
     return tool_main(argc, argv);
 }
 #endif