DM+VB: WallTimer -> SkTime::GetNSecs().

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 57 matching lines @@
 
 DEFINE_int32(shards, 1, "We're splitting source data into this many shards.");
 DEFINE_int32(shard,  0, "Which shard do I run?");
 DEFINE_bool2(pre_log, p, false, "Log before running each test. May be incomprehensible when threading");
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 using namespace DM;
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
+static double now_ms() { return SkTime::GetNSecs() * 1e-6; }
+
 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.  Total number of running and queued tasks.
@@ skipping 735 matching lines @@
         //   - this Src / Sink combination is on the blacklist;
         //   - it's a dry run.
         SkString note(task->src->veto(task->sink->flags()) ? " (veto)" : "");
         SkString whyBlacklisted = is_blacklisted(task->sink.tag, task->src.tag.c_str(),
                                                  task->src.options.c_str(), name.c_str());
         if (!whyBlacklisted.isEmpty()) {
             note.appendf(" (--blacklist %s)", whyBlacklisted.c_str());
         }
 
         SkString log;
-        WallTimer timer;
-        timer.start();
+        auto timerStart = now_ms();
         if (!FLAGS_dryRun && note.isEmpty()) {
             SkBitmap bitmap;
             SkDynamicMemoryWStream stream;
             if (FLAGS_pre_log) {
                 SkDebugf("\nRunning %s->%s", name.c_str(), task->sink.tag);
             }
             start(task->sink.tag, task->src.tag, task->src.options, name.c_str());
             Error err = task->sink->draw(*task->src, &bitmap, &stream, &log);
             if (!err.isEmpty()) {
-                timer.end();
+                auto elapsed = now_ms() - timerStart;
                 if (err.isFatal()) {
                     fail(SkStringPrintf("%s %s %s %s: %s",
                                         task->sink.tag,
                                         task->src.tag.c_str(),
                                         task->src.options.c_str(),
                                         name.c_str(),
                                         err.c_str()));
                 } else {
                     note.appendf(" (skipped: %s)", err.c_str());
                 }
-                done(timer.fWall, task->sink.tag, task->src.tag, task->src.options,
+                done(elapsed, task->sink.tag, task->src.tag, task->src.options,
                      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());
@@ skipping 33 matching lines @@
             if (!FLAGS_writePath.isEmpty()) {
                 const char* ext = task->sink->fileExtension();
                 if (data->getLength()) {
                     WriteToDisk(*task, md5, ext, data, data->getLength(), nullptr);
                     SkASSERT(bitmap.drawsNothing());
                 } else if (!bitmap.drawsNothing()) {
                     WriteToDisk(*task, md5, ext, nullptr, 0, &bitmap);
                 }
             }
         }
-        timer.end();
-        done(timer.fWall, task->sink.tag, task->src.tag.c_str(), task->src.options.c_str(), name,
-                note, log);
+        done(now_ms()-timerStart, task->sink.tag, task->src.tag.c_str(), task->src.options.c_str(),
+             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 103 matching lines @@
         }
         bool verbose() const override { return FLAGS_veryVerbose; }
     } reporter;
 
     SkString note;
     SkString whyBlacklisted = is_blacklisted("_", "tests", "_", test->name);
     if (!whyBlacklisted.isEmpty()) {
         note.appendf(" (--blacklist %s)", whyBlacklisted.c_str());
     }
 
-    WallTimer timer;
-    timer.start();
+    auto timerStart = now_ms();
     if (!FLAGS_dryRun && whyBlacklisted.isEmpty()) {
         start("unit", "test", "", test->name);
         GrContextFactory factory;
         if (FLAGS_pre_log) {
             SkDebugf("\nRunning test %s", test->name);
         }
         test->proc(&reporter, &factory);
     }
-    timer.end();
-    done(timer.fWall, "unit", "test", "", test->name, note, "");
+    done(now_ms()-timerStart, "unit", "test", "", test->name, note, "");
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 // 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]);
     }
@@ skipping 108 matching lines @@
     #endif  // SK_PDF_IMAGE_STATS
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif