Update GC stats, ThreadPool, Timer and ScopedTimer to use monotonic time.

runtime/vm/thread_pool.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/thread_pool.h"
 
 #include "vm/dart.h"
 #include "vm/flags.h"
 #include "vm/lockers.h"
 
 namespace dart {
 
 DEFINE_FLAG(int,
-            worker_timeout_millis,
-            5000,
+            worker_timeout_micros,
+            5000000,

[Cutch, 2016/12/15 22:59:24]

consider keeping the command line flag backwards compatible and just scale the
number before using it.

[rmacnak, 2016/12/15 23:11:27]

Done.

             "Free workers when they have been idle for this amount of time.");
 
 ThreadPool::ThreadPool()
     : shutting_down_(false),
       all_workers_(NULL),
       idle_workers_(NULL),
       count_started_(0),
       count_stopped_(0),
       count_running_(0),
       count_idle_(0),
@@ skipping 337 matching lines @@
 
 void ThreadPool::Worker::SetTask(Task* task) {
   MonitorLocker ml(&monitor_);
   ASSERT(task_ == NULL);
   task_ = task;
   ml.Notify();
 }
 
 
 static int64_t ComputeTimeout(int64_t idle_start) {
-  if (FLAG_worker_timeout_millis <= 0) {
+  if (FLAG_worker_timeout_micros <= 0) {
     // No timeout.
     return 0;
   } else {
-    int64_t waited = OS::GetCurrentTimeMillis() - idle_start;
-    if (waited >= FLAG_worker_timeout_millis) {
+    int64_t waited = OS::GetCurrentMonotonicMicros() - idle_start;
+    if (waited >= FLAG_worker_timeout_micros) {
       // We must have gotten a spurious wakeup just before we timed
       // out.  Give the worker one last desperate chance to live.  We
       // are merciful.
       return 1;
     } else {
-      return FLAG_worker_timeout_millis - waited;
+      return FLAG_worker_timeout_micros - waited;
     }
   }
 }
 
 
 bool ThreadPool::Worker::Loop() {
   MonitorLocker ml(&monitor_);
   int64_t idle_start;
   while (true) {
     ASSERT(task_ != NULL);
     Task* task = task_;
     task_ = NULL;
 
     // Release monitor while handling the task.
     ml.Exit();
     task->Run();
     ASSERT(Isolate::Current() == NULL);
     delete task;
     ml.Enter();
 
     ASSERT(task_ == NULL);
     if (IsDone()) {
       return false;
     }
     ASSERT(!done_);
     pool_->SetIdleAndReapExited(this);
-    idle_start = OS::GetCurrentTimeMillis();
+    idle_start = OS::GetCurrentMonotonicMicros();
     while (true) {
-      Monitor::WaitResult result = ml.Wait(ComputeTimeout(idle_start));
+      Monitor::WaitResult result = ml.WaitMicros(ComputeTimeout(idle_start));
       if (task_ != NULL) {
         // We've found a task.  Process it, regardless of whether the
         // worker is done_.
         break;
       }
       if (IsDone()) {
         return false;
       }
       if ((result == Monitor::kTimedOut) && pool_->ReleaseIdleWorker(this)) {
         return true;
@@ skipping 74 matching lines @@
   }
 
   // Call the thread exit hook here to notify the embedder that the
   // thread pool thread is exiting.
   if (Dart::thread_exit_callback() != NULL) {
     (*Dart::thread_exit_callback())();
   }
 }
 
 }  // namespace dart