Add more safe points in compiler

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/address_sanitizer.h"
 #include "platform/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
@@ skipping 831 matching lines @@
     }
   }
 }
 
 
 void PageSpace::MarkSweep(bool invoke_api_callbacks) {
   Thread* thread = Thread::Current();
   Isolate* isolate = heap_->isolate();
   ASSERT(isolate == Isolate::Current());
 
+  const int64_t pre_wait_for_sweepers = OS::GetCurrentMonotonicMicros();
+
   // Wait for pending tasks to complete and then account for the driver task.
   {
     MonitorLocker locker(tasks_lock());
     while (tasks() > 0) {
       locker.WaitWithSafepointCheck(thread);
     }
     set_tasks(1);
   }
+
+  const int64_t pre_safe_point = OS::GetCurrentMonotonicMicros();
+
   // Ensure that all threads for this isolate are at a safepoint (either
   // stopped or in native code). We have guards around Newgen GC and oldgen GC
   // to ensure that if two threads are racing to collect at the same time the
   // loser skips collection and goes straight to allocation.
   {
     SafepointOperationScope safepoint_scope(thread);
 
+    const int64_t start = OS::GetCurrentMonotonicMicros();
+
     // Perform various cleanup that relies on no tasks interfering.
     isolate->class_table()->FreeOldTables();
 
     NoSafepointScope no_safepoints;
 
     if (FLAG_print_free_list_before_gc) {
       OS::Print("Data Freelist (before GC):\n");
       freelist_[HeapPage::kData].Print();
       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::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_);
@@ skipping 87 matching lines @@
 
     // Make code pages read-only.
     WriteProtectCode(true);
 
     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(kConcurrentSweep, pre_safe_point - pre_wait_for_sweepers);
+    heap_->RecordTime(kSafePoint, start - pre_safe_point);
     heap_->RecordTime(kMarkObjects, mid1 - start);
     heap_->RecordTime(kResetFreeLists, mid2 - mid1);
     heap_->RecordTime(kSweepPages, mid3 - mid2);
     heap_->RecordTime(kSweepLargePages, end - mid3);
 
     if (FLAG_print_free_list_after_gc) {
       OS::Print("Data Freelist (after GC):\n");
       freelist_[HeapPage::kData].Print();
       OS::Print("Executable Freelist (after GC):\n");
       freelist_[HeapPage::kExecutable].Print();
@@ skipping 291 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