Initial idle GC logic.

runtime/vm/heap.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/heap.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/flags.h"
 #include "vm/isolate.h"
@@ skipping 390 matching lines @@
 void Heap::UpdateClassHeapStatsBeforeGC(Heap::Space space) {
   ClassTable* class_table = isolate()->class_table();
   if (space == kNew) {
     class_table->ResetCountersNew();
   } else {
     class_table->ResetCountersOld();
   }
 }
 #endif
 
+void Heap::NotifyIdle(int64_t deadline) {
+  if (new_space_.ShouldPerformIdleScavenge(deadline)) {
+    Thread* thread = Thread::Current();
+    TIMELINE_FUNCTION_GC_DURATION(thread, "IdleGC");
+    int64_t start = OS::GetCurrentMonotonicMicros();
+    CollectNewSpaceGarbage(thread, kIdle);
+    int64_t end = OS::GetCurrentMonotonicMicros();
+    OS::Print("idle scavenge duration=%" Pd64 "us headroom=%" Pd64 "us\n",
+              end - start, deadline - end);
+  }
+}
+
 void Heap::EvacuateNewSpace(Thread* thread, GCReason reason) {
   ASSERT(reason == kFull);
   if (BeginNewSpaceGC(thread)) {
     RecordBeforeGC(kNew, kFull);
     VMTagScope tagScope(thread, VMTag::kGCNewSpaceTagId);
     TIMELINE_FUNCTION_GC_DURATION(thread, "EvacuateNewGeneration");
     NOT_IN_PRODUCT(UpdateClassHeapStatsBeforeGC(kNew));
     new_space_.Evacuate();
     NOT_IN_PRODUCT(isolate()->class_table()->UpdatePromoted());
     RecordAfterGC(kNew);
     PrintStats();
     NOT_IN_PRODUCT(PrintStatsToTimeline(&tds));
     EndNewSpaceGC();
   }
 }
 
 void Heap::CollectNewSpaceGarbage(Thread* thread,
                                   GCReason reason) {
-  ASSERT((reason == kNewSpace) || (reason == kFull));
+  ASSERT((reason == kNewSpace) || (reason == kFull) || (reason == kIdle));
   if (BeginNewSpaceGC(thread)) {
     RecordBeforeGC(kNew, reason);
     {
       VMTagScope tagScope(thread, VMTag::kGCNewSpaceTagId);
       TIMELINE_FUNCTION_GC_DURATION(thread, "CollectNewGeneration");
       NOT_IN_PRODUCT(UpdateClassHeapStatsBeforeGC(kNew));
       new_space_.Scavenge();
       NOT_IN_PRODUCT(isolate()->class_table()->UpdatePromoted());
       RecordAfterGC(kNew);
       PrintStats();
@@ skipping 233 matching lines @@
 const char* Heap::GCReasonToString(GCReason gc_reason) {
   switch (gc_reason) {
     case kNewSpace:
       return "new space";
     case kPromotion:
       return "promotion";
     case kOldSpace:
       return "old space";
     case kFull:
       return "full";
+    case kIdle:
+      return "idle";
     case kGCAtAlloc:
       return "debugging";
     case kGCTestCase:
       return "test case";
     default:
       UNREACHABLE();
       return "";
   }
 }
 
@@ skipping 203 matching lines @@
     : StackResource(thread) {
   Dart::vm_isolate()->heap()->WriteProtect(false);
 }
 
 WritableVMIsolateScope::~WritableVMIsolateScope() {
   ASSERT(Dart::vm_isolate()->heap()->UsedInWords(Heap::kNew) == 0);
   Dart::vm_isolate()->heap()->WriteProtect(true);
 }
 
 }  // namespace dart