DM: print which task caused the crash.

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 98 matching lines @@
 
 SK_DECLARE_STATIC_MUTEX(gFailuresMutex);
 static SkTArray<SkString> gFailures;
 
 static void fail(const SkString& err) {
     SkAutoMutexAcquire lock(gFailuresMutex);
     SkDebugf("\n\nFAILURE: %s\n\n", err.c_str());
     gFailures.push_back(err);
 }
 
+struct Running {
+    SkString   id;
+    SkThreadID thread;
+
+    void dump() const {
+        info("\t%s\n", id.c_str());
+    }
+};
 
 // We use a spinlock to make locking this in a signal handler _somewhat_ safe.
 static SkSpinlock gMutex;
-static int32_t            gPending;
-static SkTArray<SkString> gRunning;
+static int32_t           gPending;
+static SkTArray<Running> gRunning;
 
 static void done(const char* config, const char* src, const char* srcOptions, const char* name) {
     SkString id = SkStringPrintf("%s %s %s %s", config, src, srcOptions, name);
     vlog("done  %s\n", id.c_str());
     int pending;
     {
         SkAutoMutexAcquire lock(gMutex);
         for (int i = 0; i < gRunning.count(); i++) {
-            if (gRunning[i] == id) {
+            if (gRunning[i].id == id) {
                 gRunning.removeShuffle(i);
                 break;
             }
         }
         pending = --gPending;
     }
     // We write our dm.json file every once in a while in case we crash.
     // Notice this also handles the final dm.json when pending == 0.
     if (pending % 500 == 0) {
         JsonWriter::DumpJson();
     }
 }
 
 static void start(const char* config, const char* src, const char* srcOptions, const char* name) {
     SkString id = SkStringPrintf("%s %s %s %s", config, src, srcOptions, name);
     vlog("start %s\n", id.c_str());
     SkAutoMutexAcquire lock(gMutex);
-    gRunning.push_back(id);
+    gRunning.push_back({id,SkGetThreadID()});
 }
 
 static void print_status() {
     int curr = sk_tools::getCurrResidentSetSizeMB(),
         peak = sk_tools::getMaxResidentSetSizeMB();
     SkString elapsed = HumanizeMs(SkTime::GetMSecs() - kStartMs);
 
     SkAutoMutexAcquire lock(gMutex);
     info("\n%s elapsed, %d active, %d queued, %dMB RAM, %dMB peak\n",
          elapsed.c_str(), gRunning.count(), gPending - gRunning.count(), curr, peak);
     for (auto& task : gRunning) {
-        info("\t%s\n", task.c_str());
+        task.dump();
     }
 }
 
+#if !defined(SK_BUILD_FOR_ANDROID)
+    static void find_culprit() {
+        // Assumes gMutex is locked.
+        SkThreadID thisThread = SkGetThreadID();
+        for (auto& task : gRunning) {
+            if (task.thread == thisThread) {
+                info("Likely culprit:\n");
+                task.dump();
+            }
+        }
+    }
+#endif
+
 #if defined(SK_BUILD_FOR_WIN32)
     static LONG WINAPI crash_handler(EXCEPTION_POINTERS* e) {
         static const struct {
             const char* name;
             DWORD code;
         } kExceptions[] = {
         #define _(E) {#E, E}
             _(EXCEPTION_ACCESS_VIOLATION),
             _(EXCEPTION_BREAKPOINT),
             _(EXCEPTION_INT_DIVIDE_BY_ZERO),
             _(EXCEPTION_STACK_OVERFLOW),
             // TODO: more?
         #undef _
         };
 
         SkAutoMutexAcquire lock(gMutex);
 
         const DWORD code = e->ExceptionRecord->ExceptionCode;
         info("\nCaught exception %u", code);
         for (const auto& exception : kExceptions) {
             if (exception.code == code) {
                 info(" %s", exception.name);
             }
         }
         info(", was running:\n");
         for (auto& task : gRunning) {
-            info("\t%s\n", task.c_str());
+            task.dump();
         }
+        find_culprit();
         fflush(stdout);
 
         // Execute default exception handler... hopefully, exit.
         return EXCEPTION_EXECUTE_HANDLER;
     }
     static void setup_crash_handler() { SetUnhandledExceptionFilter(crash_handler); }
 
 #elif !defined(SK_BUILD_FOR_ANDROID)
     #include <execinfo.h>
     #include <signal.h>
     #include <stdlib.h>
 
     static void crash_handler(int sig) {
         SkAutoMutexAcquire lock(gMutex);
 
         info("\nCaught signal %d [%s], was running:\n", sig, strsignal(sig));
         for (auto& task : gRunning) {
-            info("\t%s\n", task.c_str());
+            task.dump();
         }
+        find_culprit();
 
         void* stack[64];
         int count = backtrace(stack, SK_ARRAY_COUNT(stack));
         char** symbols = backtrace_symbols(stack, count);
         info("\nStack trace:\n");
         for (int i = 0; i < count; i++) {
             info("    %s\n", symbols[i]);
         }
         fflush(stdout);
 
@@ skipping 1185 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