Display currently running tests as the keepalive message.

dm/DM.cpp

 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
 #include "DMSrcSinkAndroid.h"
 #include "OverwriteLine.h"
 #include "ProcStats.h"
 #include "SkBBHFactory.h"
 #include "SkChecksum.h"
 #include "SkCommonFlags.h"
 #include "SkForceLinking.h"
@@ skipping 31 matching lines @@
 
 SK_DECLARE_STATIC_MUTEX(gFailuresMutex);
 static SkTArray<SkString> gFailures;
 
 static void fail(ImplicitString err) {
     SkAutoMutexAcquire lock(gFailuresMutex);
     SkDebugf("\n\nFAILURE: %s\n\n", err.c_str());
     gFailures.push_back(err);
 }
 
-static int32_t gPending = 0;  // Atomic.
+static int32_t gPending = 0;  // Atomic.  Total number of running and queued tasks.
+
+SK_DECLARE_STATIC_MUTEX(gRunningMutex);
+static SkTArray<SkString> gRunning;
 
 static void done(double ms,
                  ImplicitString config, ImplicitString src, ImplicitString name,
-                 ImplicitString log) {
+                 ImplicitString note, ImplicitString log) {
+    SkString id = SkStringPrintf("%s %s %s", config.c_str(), src.c_str(), name.c_str());
+    {
+        SkAutoMutexAcquire lock(gRunningMutex);
+        for (int i = 0; i < gRunning.count(); i++) {
+            if (gRunning[i] == id) {
+                gRunning.removeShuffle(i);
+                break;
+            }
+        }
+    }
+    if (!FLAGS_verbose) {
+        note = "";
+    }
     if (!log.isEmpty()) {
         log.prepend("\n");
     }
     auto pending = sk_atomic_dec(&gPending)-1;
-    SkDebugf("%s(%4dMB %5d) %s\t%s %s %s%s", FLAGS_verbose ? "\n" : kSkOverwriteLine
-                                           , sk_tools::getBestResidentSetSizeMB()
-                                           , pending
-                                           , HumanizeMs(ms).c_str()
-                                           , config.c_str()
-                                           , src.c_str()
-                                           , name.c_str()
-                                           , log.c_str());
+    SkDebugf("%s(%4dMB %5d) %s\t%s%s%s", FLAGS_verbose ? "\n" : kSkOverwriteLine
+                                       , sk_tools::getBestResidentSetSizeMB()
+                                       , pending
+                                       , HumanizeMs(ms).c_str()
+                                       , id.c_str()
+                                       , note.c_str()
+                                       , log.c_str());
     // 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(ImplicitString config, ImplicitString src, ImplicitString name) {
+    SkString id = SkStringPrintf("%s %s %s", config.c_str(), src.c_str(), name.c_str());
+    SkAutoMutexAcquire lock(gRunningMutex);
+    gRunning.push_back(id);
+}
+
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 struct Gold : public SkString {
     Gold() : SkString("") {}
     Gold(ImplicitString sink, ImplicitString src, ImplicitString name, ImplicitString md5)
         : SkString("") {
         this->append(sink);
         this->append(src);
         this->append(name);
         this->append(md5);
@@ skipping 225 matching lines @@
 
 // The finest-grained unit of work we can run: draw a single Src into a single Sink,
 // report any errors, and perhaps write out the output: a .png of the bitmap, or a raw stream.
 struct Task {
     Task(const Tagged<Src>& src, const Tagged<Sink>& sink) : src(src), sink(sink) {}
     const Tagged<Src>&  src;
     const Tagged<Sink>& sink;
 
     static void Run(Task* task) {
         SkString name = task->src->name();
+        SkString note;
         SkString whyBlacklisted = is_blacklisted(task->sink.tag, task->src.tag, name.c_str());
+        if (!whyBlacklisted.isEmpty()) {
+            note.appendf(" (--blacklist %s)", whyBlacklisted.c_str());
+        }
         SkString log;
         WallTimer timer;
         timer.start();
         if (!FLAGS_dryRun && whyBlacklisted.isEmpty()) {
             SkBitmap bitmap;
             SkDynamicMemoryWStream stream;
+            start(task->sink.tag, task->src.tag, name.c_str());
             Error err = task->sink->draw(*task->src, &bitmap, &stream, &log);
             if (!err.isEmpty()) {
                 timer.end();
                 if (err.isFatal()) {
                     fail(SkStringPrintf("%s %s %s: %s",
                                         task->sink.tag,
                                         task->src.tag,
                                         name.c_str(),
                                         err.c_str()));
-                } else if (FLAGS_verbose) {
-                    name.appendf(" (skipped: %s)", err.c_str());
+                } else {
+                    note.appendf(" (skipped: %s)", err.c_str());
                 }
-                done(timer.fWall, task->sink.tag, task->src.tag, name, log);
+                done(timer.fWall, task->sink.tag, task->src.tag, name, note, log);
                 return;
             }
             SkAutoTDelete<SkStreamAsset> data(stream.detachAsStream());
 
             SkString md5;
             if (!FLAGS_writePath.isEmpty() || !FLAGS_readPath.isEmpty()) {
                 SkMD5 hash;
                 if (data->getLength()) {
                     hash.writeStream(data, data->getLength());
                     data->rewind();
@@ skipping 21 matching lines @@
                 const char* ext = task->sink->fileExtension();
                 if (data->getLength()) {
                     WriteToDisk(*task, md5, ext, data, data->getLength(), NULL);
                     SkASSERT(bitmap.drawsNothing());
                 } else if (!bitmap.drawsNothing()) {
                     WriteToDisk(*task, md5, ext, NULL, 0, &bitmap);
                 }
             }
         }
         timer.end();
-        if (FLAGS_verbose && !whyBlacklisted.isEmpty()) {
-            name.appendf(" (--blacklist, %s)", whyBlacklisted.c_str());
-        }
-        done(timer.fWall, task->sink.tag, task->src.tag, name, log);
+        done(timer.fWall, task->sink.tag, task->src.tag, name, note, log);
     }
 
     static void WriteToDisk(const Task& task,
                             SkString md5,
                             const char* ext,
                             SkStream* data, size_t len,
                             const SkBitmap* bitmap) {
         JsonWriter::BitmapResult result;
         result.name       = task.src->name();
         result.config     = task.sink.tag;
@@ skipping 96 matching lines @@
             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) {
+        start("unit", "test", test->name);
         GrContextFactory factory;
         test->proc(&reporter, &factory);
     }
     timer.end();
-    done(timer.fWall, "unit", "test", test->name, "");
+    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]);
     }
 }
 
 // Some runs (mostly, Valgrind) are so slow that the bot framework thinks we've hung.
 // This prints something every once in a while so that it knows we're still working.
 static void start_keepalive() {
     struct Loop {
         static void forever(void*) {
             for (;;) {
                 static const int kSec = 300;
             #if defined(SK_BUILD_FOR_WIN)
                 Sleep(kSec * 1000);
             #else
                 sleep(kSec);
             #endif
-                SkDebugf("\nStill alive: doing science, reticulating splines...\n");
+                SkString running;
+                {
+                    SkAutoMutexAcquire lock(gRunningMutex);
+                    for (int i = 0; i < gRunning.count(); i++) {
+                        running.appendf("\n\t%s", gRunning[i].c_str());
+                    }
+                }
+                SkDebugf("\nCurrently running:%s\n", running.c_str());
             }
         }
     };
     static SkThread* intentionallyLeaked = new SkThread(Loop::forever);
     intentionallyLeaked->start();
 }
 
 int dm_main();
 int dm_main() {
     SetupCrashHandler();
@@ skipping 59 matching lines @@
     }
     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