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

runtime/vm/pages.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/pages.h"
 
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
@@ skipping 758 matching lines @@
       HeapMapAsJSONVisitor printer(&page_map);
       page->VisitObjects(&printer);
     }
   }
 }
 #endif  // PRODUCT
 
 
 bool PageSpace::ShouldCollectCode() {
   // Try to collect code if enough time has passed since the last attempt.
-  const int64_t start = OS::GetCurrentTimeMicros();
+  const int64_t start = OS::GetCurrentMonotonicMicros();
   const int64_t last_code_collection_in_us =
       page_space_controller_.last_code_collection_in_us();
 
   if ((start - last_code_collection_in_us) >
       FLAG_code_collection_interval_in_us) {
     if (FLAG_log_code_drop) {
       OS::Print("Trying to detach code.\n");
     }
     page_space_controller_.set_last_code_collection_in_us(start);
     return true;
@@ skipping 55 matching lines @@
       OS::Print("Executable Freelist (before GC):\n");
       freelist_[HeapPage::kExecutable].Print();
     }
 
     if (FLAG_verify_before_gc) {
       OS::PrintErr("Verifying before marking...");
       heap_->VerifyGC();
       OS::PrintErr(" done.\n");
     }
 
-    const int64_t start = OS::GetCurrentTimeMicros();
+    const int64_t start = OS::GetCurrentMonotonicMicros();
 
     // Make code pages writable.
     WriteProtectCode(false);
 
     // Save old value before GCMarker visits the weak persistent handles.
     SpaceUsage usage_before = GetCurrentUsage();
 
     // Mark all reachable old-gen objects.
     bool collect_code = FLAG_collect_code && ShouldCollectCode() &&
                         !isolate->HasAttemptedReload();
     GCMarker marker(heap_);
     marker.MarkObjects(isolate, this, invoke_api_callbacks, collect_code);
     usage_.used_in_words = marker.marked_words();
 
-    int64_t mid1 = OS::GetCurrentTimeMicros();
+    int64_t mid1 = OS::GetCurrentMonotonicMicros();
 
     // Abandon the remainder of the bump allocation block.
     AbandonBumpAllocation();
     // Reset the freelists and setup sweeping.
     freelist_[HeapPage::kData].Reset();
     freelist_[HeapPage::kExecutable].Reset();
 
-    int64_t mid2 = OS::GetCurrentTimeMicros();
+    int64_t mid2 = OS::GetCurrentMonotonicMicros();
     int64_t mid3 = 0;
 
     {
       if (FLAG_verify_before_gc) {
         OS::PrintErr("Verifying before sweeping...");
         heap_->VerifyGC(kAllowMarked);
         OS::PrintErr(" done.\n");
       }
       GCSweeper sweeper;
 
@@ skipping 26 matching lines @@
         bool page_in_use = sweeper.SweepPage(page, freelist, true);
         if (page_in_use) {
           prev_page = page;
         } else {
           FreePage(page, prev_page);
         }
         // Advance to the next page.
         page = next_page;
       }
 
-      mid3 = OS::GetCurrentTimeMicros();
+      mid3 = OS::GetCurrentMonotonicMicros();
 
       if (!FLAG_concurrent_sweep) {
         // Sweep all regular sized pages now.
         prev_page = NULL;
         page = pages_;
         while (page != NULL) {
           HeapPage* next_page = page->next();
           bool page_in_use =
               sweeper.SweepPage(page, &freelist_[page->type()], true);
           if (page_in_use) {
@@ skipping 12 matching lines @@
       } else {
         // Start the concurrent sweeper task now.
         GCSweeper::SweepConcurrent(isolate, pages_, pages_tail_,
                                    &freelist_[HeapPage::kData]);
       }
     }
 
     // Make code pages read-only.
     WriteProtectCode(true);
 
-    int64_t end = OS::GetCurrentTimeMicros();
+    int64_t end = OS::GetCurrentMonotonicMicros();
 
     // Record signals for growth control. Include size of external allocations.
     page_space_controller_.EvaluateGarbageCollection(
         usage_before, GetCurrentUsage(), start, end);
 
     heap_->RecordTime(kMarkObjects, mid1 - start);
     heap_->RecordTime(kResetFreeLists, mid2 - mid1);
     heap_->RecordTime(kSweepPages, mid3 - mid2);
     heap_->RecordTime(kSweepLargePages, end - mid3);
 
@@ skipping 141 matching lines @@
                                          int heap_growth_ratio,
                                          int heap_growth_max,
                                          int garbage_collection_time_ratio)
     : heap_(heap),
       is_enabled_(false),
       grow_heap_(heap_growth_max / 2),
       heap_growth_ratio_(heap_growth_ratio),
       desired_utilization_((100.0 - heap_growth_ratio) / 100.0),
       heap_growth_max_(heap_growth_max),
       garbage_collection_time_ratio_(garbage_collection_time_ratio),
-      last_code_collection_in_us_(OS::GetCurrentTimeMicros()) {}
+      last_code_collection_in_us_(OS::GetCurrentMonotonicMicros()) {}
 
 
 PageSpaceController::~PageSpaceController() {}
 
 
 bool PageSpaceController::NeedsGarbageCollection(SpaceUsage after) const {
   if (!is_enabled_) {
     return false;
   }
   if (heap_growth_ratio_ == 100) {
@@ skipping 130 matching lines @@
     return 0;
   } else {
     ASSERT(total_time >= gc_time);
     int result = static_cast<int>(
         (static_cast<double>(gc_time) / static_cast<double>(total_time)) * 100);
     return result;
   }
 }
 
 }  // namespace dart