More natural way to serialize GPU tasks and 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"
@@ skipping 335 matching lines @@
 static void run_enclave(SkTArray<Task>* tasks) {
     for (int i = 0; i < tasks->count(); i++) {
         Task::Run(tasks->begin() + i);
     }
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 // Unit tests don't fit so well into the Src/Sink model, so we give them special treatment.
 
-static SkTDArray<skiatest::Test> gCPUTests, gGPUTests;
+static SkTDArray<skiatest::Test> gThreadedTests, gGPUTests;
 
 static void gather_tests() {
     if (!FLAGS_src.contains("tests")) {
         return;
     }
     for (const skiatest::TestRegistry* r = skiatest::TestRegistry::Head(); r;
          r = r->next()) {
         // Despite its name, factory() is returning a reference to
         // link-time static const POD data.
         const skiatest::Test& test = r->factory();
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, test.name)) {
             continue;
         }
         if (test.needsGpu && gpu_supported()) {
-            gGPUTests.push(test);
+            (FLAGS_gpu_threading ? gThreadedTests : gGPUTests).push(test);
         } else if (!test.needsGpu && FLAGS_cpu) {
-            gCPUTests.push(test);
+            gThreadedTests.push(test);
         }
     }
 }
 
 static void run_test(skiatest::Test* test) {
     struct : public skiatest::Reporter {
         void reportFailed(const skiatest::Failure& failure) SK_OVERRIDE {
             fail(failure.toString());
             JsonWriter::AddTestFailure(failure);
         }
         bool allowExtendedTest() const SK_OVERRIDE {
             return FLAGS_pathOpsExtended;
         }
         bool verbose() const SK_OVERRIDE { return FLAGS_veryVerbose; }
     } reporter;
     WallTimer timer;
     timer.start();
     if (!FLAGS_dryRun) {
-        test->proc(&reporter, GetThreadLocalGrContextFactory());
+        GrContextFactory factory;
+        test->proc(&reporter, &factory);
     }
     timer.end();
     done(timer.fWall, "unit", "test", test->name);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
+// If we're isolating all GPU-bound work to one thread (the default), this function runs all that.
+static void run_enclave_and_gpu_tests(SkTArray<Task>* tasks) {
+    run_enclave(tasks);
+    for (int i = 0; i < gGPUTests.count(); i++) {
+        run_test(&gGPUTests[i]);
+    }
+}
+
 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() + gCPUTests.count() + gGPUTests.count();
+    gPending = gSrcs.count() * gSinks.count() + gThreadedTests.count() + gGPUTests.count();
     SkDebugf("%d srcs * %d sinks + %d tests == %d tasks\n",
-             gSrcs.count(), gSinks.count(), gCPUTests.count() + gGPUTests.count(), gPending);
+             gSrcs.count(), gSinks.count(), gThreadedTests.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.
     // 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,   gCPUTests.begin(),   gCPUTests.count());
-        if (FLAGS_gpu_threading) {
-            tg.batch(run_test,  gGPUTests.begin(),   gGPUTests.count());
-        #if !defined(SK_BUILD_FOR_WIN32)
-        } else {
-            for (int i = 0; i < gGPUTests.count(); i++) {
-                run_test(&gGPUTests[i]);
-            }
-        #endif
+    tg.batch(run_test, gThreadedTests.begin(), gThreadedTests.count());
+    for (int i = 0; i < kNumEnclaves; i++) {
+        switch(i) {
+            case kAnyThread_Enclave:
+                tg.batch(Task::Run, enclaves[i].begin(), enclaves[i].count());
+                break;
+            case kGPU_Enclave:
+                tg.add(run_enclave_and_gpu_tests, &enclaves[i]);
+                break;
+            default:
+                tg.add(run_enclave, &enclaves[i]);
+                break;
         }
+    }
     tg.wait();
     // At this point we're back in single-threaded land.
 
-    // This is not ideal for parallelism, but Windows seems crash-prone if we run
-    // these GPU tests in parallel with any GPU Src/Sink work.  Everyone else seems fine.
-#if defined(SK_BUILD_FOR_WIN32)
-    for (int i = 0; i < gGPUTests.count(); i++) {
-        run_test(&gGPUTests[i]);
-    }
-#endif
-
     SkDebugf("\n");
     JsonWriter::DumpJson();
 
     if (gFailures.count() > 0) {
         SkDebugf("Failures:\n");
         for (int i = 0; i < gFailures.count(); i++) {
             SkDebugf("\t%s\n", gFailures[i].c_str());
         }
         SkDebugf("%d failures\n", gFailures.count());
         return 1;
     }
     if (gPending > 0) {
         SkDebugf("Hrm, we didn't seem to run everything we intended to!  Please file a bug.\n");
         return 1;
     }
     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