Optionally run RAW images 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 "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
@@ skipping 565 matching lines @@
         }
     }
 
     SkTArray<SkString> images;
     if (!CollectImages(&images)) {
         return false;
     }
 
     for (auto image : images) {
         push_codec_srcs(image);
-        const char* ext = "";
-        int index = image.findLastOf('.');
-        if (index >= 0 && (size_t) ++index < image.size()) {
-            ext = &image.c_str()[index];
-        }
-        if (brd_supported(ext)) {
+        if (brd_supported(SkStringExtension(image))) {
             push_brd_srcs(image);
         }
     }
 
     return true;
 }
 
 static void push_sink(const SkCommandLineConfig& config, Sink* s) {
     SkAutoTDelete<Sink> sink(s);
 
@@ skipping 550 matching lines @@
     SkDebugf("%d srcs * %d sinks + %d tests == %d tasks\n",
              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]));
+            const int srcEnclave = gSrcs[i]->enclave();
+            if (srcEnclave == kAnyThread_Enclave) {
+                // Use the enclave of the Sink.
+                tasks.push_back(Task(gSrcs[i], gSinks[j]));

[mtklein, 2016/02/08 21:26:54]

This reads weirdly asymmetric now.  Let's really rewrite it rather than grafting
onto it:


for (int i = 0; i < gSrcs.count(); i++) {
  Task task(gSrcs[i], gSinks[j])

   if (task.src->enclave() != kAnyThread_Enclave) {
      enclaves[task.src->enclave()].push_back(task);
   } else {
      enclaves[task.sink->enclave()].push_back(task);
   }
}

Though I think this logic breaks if we start testing RAW against GPU.  The sink
enclave should trump there.

+            } else {
+                // Use the enclave of the Src.
+                enclaves[srcEnclave].push_back(Task(gSrcs[i], gSinks[j]));
+            }
         }
     }
 
     SkTaskGroup tg;
     tg.batch(gThreadedTests.count(), [](int i){ run_test(&gThreadedTests[i]); });
     for (int i = 0; i < kNumEnclaves; i++) {
         SkTArray<Task>* currentEnclave = &enclaves[i];
         switch(i) {

[msarett, 2016/02/08 19:35:37]

Do we need to handle kRAW_Enclave here?  Is it handled by the default?  By using
the default, you don't need to check SK_CODEC_DECODES_RAW?

[scroggo, 2016/02/08 20:08:12]

Yes, it is handled by the default, so no need to check SK_CODEC_DECODES_RAW

             case kAnyThread_Enclave:
                 tg.batch(currentEnclave->count(),
                          [currentEnclave](int j) { Task::Run(&(*currentEnclave)[j]); });
                 break;
             case kGPU_Enclave:
                 tg.add([currentEnclave](){ run_enclave_and_gpu_tests(currentEnclave); });
                 break;
             default:
                 tg.add([currentEnclave](){ run_enclave(currentEnclave); });
                 break;
@@ skipping 119 matching lines @@
                                                            Reporter* reporter,
                                                            GrContextFactory* factory);
 } // namespace skiatest
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif