Add --serial mode to dm, runs unit tests serially

dm/DM.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
 #include "DMSrcSinkAndroid.h"
@@ skipping 53 matching lines @@
 
 DEFINE_string2(readPath, r, "", "If set check for equality with golden results in this directory.");
 
 DEFINE_string(uninterestingHashesFile, "",
         "File containing a list of uninteresting hashes. If a result hashes to something in "
         "this list, no image is written for that result.");
 
 DEFINE_int32(shards, 1, "We're splitting source data into this many shards.");
 DEFINE_int32(shard,  0, "Which shard do I run?");
 
+DEFINE_string2(solo, s, nullptr,
+               "Run the specified tests alone, before creating multiple threads.\n"
+               "Test names must match exactly.  Multiple tests may be separated by spaces.");
+
 DEFINE_string(mskps, "", "Directory to read mskps from, or a single mskp file.");
 
 DEFINE_string(svgs, "", "Directory to read SVGs from, or a single SVG file.");
 
 using namespace DM;
 using sk_gpu_test::GrContextFactory;
 using sk_gpu_test::GLTestContext;
 using sk_gpu_test::ContextInfo;
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
@@ skipping 1115 matching lines @@
                 return;
             }
         }
     }
 };
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 // Unit tests don't fit so well into the Src/Sink model, so we give them special treatment.
 
-static SkTDArray<skiatest::Test> gParallelTests, gSerialTests;
+static SkTDArray<skiatest::Test> gParallelTests, gSerialTests, gSoloTests;
 
 static void gather_tests() {
     if (!FLAGS_src.contains("tests")) {
         return;
     }
     for (const skiatest::TestRegistry* r = skiatest::TestRegistry::Head(); r; r = r->next()) {
         if (!in_shard()) {
             continue;
         }
         // 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 (FLAGS_solo.contains(test.name)) {
+            gSoloTests.push(test);
+            continue;
+        }
         if (test.needsGpu && gpu_supported()) {
             (FLAGS_gpu_threading ? gParallelTests : gSerialTests).push(test);
         } else if (!test.needsGpu && FLAGS_cpu) {
             gParallelTests.push(test);
         }
     }
 }
 
 static void run_test(skiatest::Test test) {
     struct : public skiatest::Reporter {
@@ skipping 75 matching lines @@
     gather_gold();
     gather_uninteresting_hashes();
 
     if (!gather_srcs()) {
         return 1;
     }
     if (!gather_sinks()) {
         return 1;
     }
     gather_tests();
+
+    // First, run memory intensive tests serially.
+    if (gSoloTests.count() > 0) {
+        info("Running %d tests serially...\n", gSoloTests.count());
+        for (auto test : gSoloTests) { run_test(test); }
+    }
+
     gPending = gSrcs.count() * gSinks.count() + gParallelTests.count() + gSerialTests.count();
     info("%d srcs * %d sinks + %d tests == %d tasks",
          gSrcs.count(), gSinks.count(), gParallelTests.count() + gSerialTests.count(), gPending);
     SkAutoTDelete<SkThread> statusThread(start_status_thread());
 
     // Kick off as much parallel work as we can, making note of any serial work we'll need to do.
     SkTaskGroup parallel;
     SkTArray<Task> serial;
 
     for (auto& sink : gSinks)
@@ skipping 105 matching lines @@
 #endif
 }
 } // namespace skiatest
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif