turn back on gpu tests

dm/DM.cpp

 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
 #include "OverwriteLine.h"
 #include "ProcStats.h"
 #include "SkBBHFactory.h"
 #include "SkCommonFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkMD5.h"
 #include "SkOSFile.h"
 #include "SkTaskGroup.h"
 #include "Test.h"
 #include "Timer.h"
 
 DEFINE_bool(tests, true, "Run tests?");
 DEFINE_string(images, "resources", "Images to decode.");
 //DEFINE_string(src, "gm skp image subset", "Source types to test.");
 DEFINE_string(src, "gm skp", "Source types to test.  TEMPORARILY DISABLED");
 DEFINE_bool(nameByHash, false,
             "If true, write to FLAGS_writePath[0]/<hash>.png instead of "
             "to FLAGS_writePath[0]/<config>/<sourceType>/<name>.png");
 DEFINE_bool2(pathOpsExtended, x, false, "Run extended pathOps tests.");
 DEFINE_string(matrix, "1 0 0 0 1 0 0 0 1",
               "Matrix to apply when using 'matrix' in config.");
+DEFINE_bool(gpu_threading, false, "Allow GPU work to run on multiple threads?");
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 using namespace DM;
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 SK_DECLARE_STATIC_MUTEX(gFailuresMutex);
 static SkTArray<SkString> gFailures;
 
 static void fail(ImplicitString err) {
@@ skipping 95 matching lines @@
 #if SK_SUPPORT_GPU
     return FLAGS_gpu;
 #else
     return false;
 #endif
 }
 
 static Sink* create_sink(const char* tag) {
 #define SINK(t, sink, ...) if (0 == strcmp(t, tag)) { return new sink(__VA_ARGS__); }
     if (gpu_supported()) {
+        typedef GrContextFactory Gr;
         const GrGLStandard api = get_gpu_api();
-        SINK("gpunull",    GPUSink, GrContextFactory::kNull_GLContextType,   api,  0, false);
-        SINK("gpudebug",   GPUSink, GrContextFactory::kDebug_GLContextType,  api,  0, false);
-        SINK("gpu",        GPUSink, GrContextFactory::kNative_GLContextType, api,  0, false);
-        SINK("gpudft",     GPUSink, GrContextFactory::kNative_GLContextType, api,  0,  true);
-        SINK("msaa4",      GPUSink, GrContextFactory::kNative_GLContextType, api,  4, false);
-        SINK("msaa16",     GPUSink, GrContextFactory::kNative_GLContextType, api, 16, false);
-        SINK("nvprmsaa4",  GPUSink, GrContextFactory::kNVPR_GLContextType,   api,  4, false);
-        SINK("nvprmsaa16", GPUSink, GrContextFactory::kNVPR_GLContextType,   api, 16, false);
+        SINK("gpunull",    GPUSink, Gr::kNull_GLContextType,   api,  0, false, FLAGS_gpu_threading);
+        SINK("gpudebug",   GPUSink, Gr::kDebug_GLContextType,  api,  0, false, FLAGS_gpu_threading);
+        SINK("gpu",        GPUSink, Gr::kNative_GLContextType, api,  0, false, FLAGS_gpu_threading);
+        SINK("gpudft",     GPUSink, Gr::kNative_GLContextType, api,  0,  true, FLAGS_gpu_threading);
+        SINK("msaa4",      GPUSink, Gr::kNative_GLContextType, api,  4, false, FLAGS_gpu_threading);
+        SINK("msaa16",     GPUSink, Gr::kNative_GLContextType, api, 16, false, FLAGS_gpu_threading);
+        SINK("nvprmsaa4",  GPUSink, Gr::kNVPR_GLContextType,   api,  4, false, FLAGS_gpu_threading);
+        SINK("nvprmsaa16", GPUSink, Gr::kNVPR_GLContextType,   api, 16, false, FLAGS_gpu_threading);
     #if SK_ANGLE
-        SINK("angle",      GPUSink, GrContextFactory::kANGLE_GLContextType,  api,  0, false);
+        SINK("angle",      GPUSink, Gr::kANGLE_GLContextType,  api,  0, false, FLAGS_gpu_threading);
     #endif
     #if SK_MESA
-        SINK("mesa",       GPUSink, GrContextFactory::kMESA_GLContextType,   api,  0, false);
+        SINK("mesa",       GPUSink, Gr::kMESA_GLContextType,   api,  0, false, FLAGS_gpu_threading);
     #endif
     }
 
     if (FLAGS_cpu) {
         SINK("565",  RasterSink, kRGB_565_SkColorType);
         SINK("8888", RasterSink, kN32_SkColorType);
         // TODO(mtklein): reenable once skiagold can handle .pdf uploads.
         //SINK("pdf",  PDFSink);
     }
 #undef SINK
@@ skipping 173 matching lines @@
     void onReportFailed(const skiatest::Failure& failure) SK_OVERRIDE {
         SkString s;
         failure.getFailureString(&s);
         fail(s);
         JsonWriter::AddTestFailure(failure);
     }
     bool allowExtendedTest() const SK_OVERRIDE { return FLAGS_pathOpsExtended; }
     bool verbose()           const SK_OVERRIDE { return FLAGS_veryVerbose; }
 } gTestReporter;
 
-static SkTArray<SkAutoTDelete<skiatest::Test>, kMemcpyOK> gTests;
+static SkTArray<SkAutoTDelete<skiatest::Test>, kMemcpyOK> gCPUTests, gGPUTests;
 
 static void gather_tests() {
     if (!FLAGS_tests) {
         return;
     }
     for (const skiatest::TestRegistry* r = skiatest::TestRegistry::Head(); r; r = r->next()) {
         SkAutoTDelete<skiatest::Test> test(r->factory()(NULL));
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, test->getName())) {
             continue;
         }
-        if (test->isGPUTest() /*&& !gpu_supported()*/) {  // TEMPORARILY DISABLED
-            continue;
+
+        test->setReporter(&gTestReporter);
+        if (test->isGPUTest() && gpu_supported()) {
+            gGPUTests.push_back().reset(test.detach());
+        } else if (!test->isGPUTest() && FLAGS_cpu) {
+            gCPUTests.push_back().reset(test.detach());
         }
-        if (!test->isGPUTest() && !FLAGS_cpu) {
-            continue;
-        }
-        test->setReporter(&gTestReporter);
-        gTests.push_back().reset(test.detach());
     }
 }
 
 static void run_test(SkAutoTDelete<skiatest::Test>* t) {
     WallTimer timer;
     timer.start();
     skiatest::Test* test = t->get();
     if (!FLAGS_dryRun) {
-        GrContextFactory grFactory;
-        test->setGrContextFactory(&grFactory);
+        test->setGrContextFactory(GetThreadLocalGrContextFactory());
         test->run();
         if (!test->passed()) {
             fail(SkStringPrintf("test %s failed", test->getName()));
         }
     }
     timer.end();
     done(timer.fWall, "unit", "test", test->getName());
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 int dm_main();
 int dm_main() {
     SetupCrashHandler();
     SkAutoGraphics ag;
     SkTaskGroup::Enabler enabled(FLAGS_threads);
 
     gather_srcs();
     gather_sinks();
     gather_tests();
 
-    gPending = gSrcs.count() * gSinks.count() + gTests.count();
+    gPending = gSrcs.count() * gSinks.count() + gCPUTests.count() + gGPUTests.count();
     SkDebugf("%d srcs * %d sinks + %d tests == %d tasks\n",
-             gSrcs.count(), gSinks.count(), gTests.count(), gPending);
+             gSrcs.count(), gSinks.count(), gCPUTests.count() + gGPUTests.count(), gPending);
 
     // We try to exploit as much parallelism as is safe.  Most Src/Sink pairs run on any thread,
     // but Sinks that identify as part of a particular enclave run serially on a single thread.
-    // Tests run on any thread, with a separate GrContextFactory for each GPU test.
+    // CPU tests run on any thread.  GPU tests depend on --gpu_threading.
     SkTArray<Task> enclaves[kNumEnclaves];
     for (int j = 0; j < gSinks.count(); j++) {
         SkTArray<Task>& tasks = enclaves[gSinks[j]->enclave()];
         for (int i = 0; i < gSrcs.count(); i++) {
             tasks.push_back(Task(gSrcs[i], gSinks[j]));
         }
     }
 
     SK_COMPILE_ASSERT(kAnyThread_Enclave == 0, AnyThreadZero);
     SkTaskGroup tg;
         tg.batch(  Task::Run, enclaves[0].begin(), enclaves[0].count());
         tg.batch(run_enclave,          enclaves+1,      kNumEnclaves-1);
-        tg.batch(   run_test,      gTests.begin(),      gTests.count());
+        tg.batch(   run_test,   gCPUTests.begin(),   gCPUTests.count());
+        if (FLAGS_gpu_threading) {
+            tg.batch(run_test,  gGPUTests.begin(),   gGPUTests.count());
+        } else {
+            for (int i = 0; i < gGPUTests.count(); i++) {
+                run_test(&gGPUTests[i]);
+            }
+        }
     tg.wait();
 
     // At this point we're back in single-threaded land.
 
     if (!FLAGS_verbose) {
         SkDebugf("\n");
     }
 
     JsonWriter::DumpJson();
 
@@ skipping 11 matching lines @@
     }
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif