Optionally run RAW images serially

dm/DM.cpp

Index: dm/DM.cpp
diff --git a/dm/DM.cpp b/dm/DM.cpp
index 456c6abf6f0cee33744ee72ddd536bee60815fd3..f485c712330d7a050342ce0ba68d84eaf61ac2b0 100644
--- a/dm/DM.cpp
+++ b/dm/DM.cpp
@@ -583,12 +583,7 @@ static bool gather_srcs() {
 
     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);
         }
     }
@@ -1159,7 +1154,14 @@ int dm_main() {
     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]));
+            } else {
+                // Use the enclave of the Src.

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

Actually, this is problematic. We'll end up running GPU in different threads
now. Back to the drawing board... (IIUC, the enclave still runs in parallel to
other enclaves - it just prevents Sinks/Srcs in the same enclave from running
simultaneously.)

(FWIW, crrev.com/1677133002 makes this safe in the specific case - we won't run
RAW on GPU anyway, but it's still generally unsafe.)

We could switch this around, and only honor the Src's enclave if the Sink is
kAnyThread. RAW decodes are thread safe, so if they occasionally run
simultaneously it *may* be okay; we're just trying to cut down on memory use.

I'm open to ideas. (And the simplest option, just to turn the bots green, is to
just disable on 5 and 9, like we do for Player)

[msarett, 2016/02/08 20:16:19]

This seems reasonable to me, but I'm not sure I understand completely.  The
Sink's enclave can be kAny or kGPU?  And in the kGPU case, we run
single-threaded?  Where the Src enclave can be kAny or kRaw?  And in the kRAW
case, we run single-threaded?

So why won't this work all the time?

[scroggo, 2016/02/08 21:09:30]

We went a different direction (Mike submitted crrev.com/1675423002, which
changes the way we decide to run things in parallel), but in case you're still
curious:

The (old) way to do things is to run an enclave in its own thread, and
everything else in multiple threads. The key takeaway is that the enclaves run
in parallel. (The new way is fairly similar - serial run on the main thread, and
everything else can run in other threads.)

The Sink can be kAny or kGPU. The Src can be kAny or kRAW. If the Src is kRAW,
we will always run it in the kRAW enclave, even if the Sink is kGPU. So some GPU
Sinks will run in the GPU enclave, and others will run in the RAW enclave, so
they may run at the same time.

+                enclaves[srcEnclave].push_back(Task(gSrcs[i], gSinks[j]));
+            }
         }
     }