DM: tally notes at the end rather than showing them as they finish.

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 65 matching lines @@
 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.  Total number of running and queued tasks.
 
-SK_DECLARE_STATIC_MUTEX(gRunningMutex);
-static SkTArray<SkString> gRunning;
+SK_DECLARE_STATIC_MUTEX(gRunningAndTallyMutex);
+static SkTArray<SkString>        gRunning;
+static SkTHashMap<SkString, int> gNoteTally;
 
 static void done(double ms,
                  ImplicitString config, ImplicitString src, ImplicitString srcOptions,
                  ImplicitString name, ImplicitString note, ImplicitString log) {
     SkString id = SkStringPrintf("%s %s %s %s", config.c_str(), src.c_str(),
                                                 srcOptions.c_str(), name.c_str());
     {
-        SkAutoMutexAcquire lock(gRunningMutex);
+        SkAutoMutexAcquire lock(gRunningAndTallyMutex);
         for (int i = 0; i < gRunning.count(); i++) {
             if (gRunning[i] == id) {
                 gRunning.removeShuffle(i);
                 break;
             }
         }
-    }
-    if (!FLAGS_verbose) {
-        note = "";
+        if (!note.isEmpty()) {
+            if (int* tally = gNoteTally.find(note)) {
+                *tally += 1;
+            } else {
+                gNoteTally.set(note, 1);
+            }
+        }
     }
     if (!log.isEmpty()) {
         log.prepend("\n");
     }
     auto pending = sk_atomic_dec(&gPending)-1;
-    if (!FLAGS_quiet) {
-        SkDebugf("%s(%4d/%-4dMB %6d) %s\t%s%s%s", FLAGS_verbose ? "\n" : kSkOverwriteLine
+    if (!FLAGS_quiet && note.isEmpty()) {
+        SkDebugf("%s(%4d/%-4dMB %6d) %s\t%s%s", FLAGS_verbose ? "\n" : kSkOverwriteLine
                                            , sk_tools::getCurrResidentSetSizeMB()
                                            , sk_tools::getMaxResidentSetSizeMB()
                                            , 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 srcOptions, ImplicitString name) {
     SkString id = SkStringPrintf("%s %s %s %s", config.c_str(), src.c_str(),
                                                 srcOptions.c_str(), name.c_str());
-    SkAutoMutexAcquire lock(gRunningMutex);
+    SkAutoMutexAcquire lock(gRunningAndTallyMutex);
     gRunning.push_back(id);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 struct Gold : public SkString {
     Gold() : SkString("") {}
     Gold(ImplicitString sink, ImplicitString src, ImplicitString srcOptions,
          ImplicitString name, ImplicitString md5)
         : SkString("") {
@@ skipping 892 matching lines @@
         static void forever(void*) {
             for (;;) {
                 static const int kSec = 300;
             #if defined(SK_BUILD_FOR_WIN)
                 Sleep(kSec * 1000);
             #else
                 sleep(kSec);
             #endif
                 SkString running;
                 {
-                    SkAutoMutexAcquire lock(gRunningMutex);
+                    SkAutoMutexAcquire lock(gRunningAndTallyMutex);
                     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();
@@ skipping 56 matching lines @@
                 break;
             default:
                 tg.add(run_enclave, &enclaves[i]);
                 break;
         }
     }
     tg.wait();
     // At this point we're back in single-threaded land.
     sk_tool_utils::release_portable_typefaces();
 
+    if (FLAGS_verbose && gNoteTally.count() > 0) {
+        SkDebugf("\nNote tally:\n");
+        gNoteTally.foreach([](const SkString& note, int* tally) {
+            SkDebugf("%dx\t%s\n", *tally, note.c_str());
+        });
+    }
+
     SkDebugf("\n");
     if (gFailures.count() > 0) {
         SkDebugf("Failures:\n");
         for (int i = 0; i < gFailures.count(); i++) {
             SkDebugf("\t%s\n", gFailures[i].c_str());
         }
         SkDebugf("%d failures\n", gFailures.count());
         return 1;
     }
     if (gPending > 0) {
@@ skipping 66 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