WIP: idle scavenge

runtime/vm/scavenger.cc

 // Copyright (c) 2011, 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/scavenger.h"
 
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
@@ skipping 402 matching lines @@
   double avg_frac = stats_history_.Get(0).PromoCandidatesSuccessFraction();
   if (stats_history_.Size() >= 2) {
     // Previous scavenge is only given half as much weight.
     avg_frac += 0.5 * stats_history_.Get(1).PromoCandidatesSuccessFraction();
     avg_frac /= 1.0 + 0.5;  // Normalize.
   }
   if (avg_frac < (FLAG_early_tenuring_threshold / 100.0)) {
     // Remember the limit to which objects have been copied.
     survivor_end_ = top_;
   } else {
+    OS::Print("early tenuring!\n");
     // Move survivor end to the end of the to_ space, making all surviving
     // objects candidates for promotion next time.
     survivor_end_ = end_;
   }
 #if defined(DEBUG)
   // We can only safely verify the store buffers from old space if there is no
   // concurrent old space task. At the same time we prevent new tasks from
   // being spawned.
   {
     PageSpace* page_space = heap_->old_space();
@@ skipping 402 matching lines @@
   }
 
   // Prepare for a scavenge.
   SpaceUsage usage_before = GetCurrentUsage();
   intptr_t promo_candidate_words =
       (survivor_end_ - FirstObjectStart()) / kWordSize;
   SemiSpace* from = Prologue(isolate, invoke_api_callbacks);
   // The API prologue/epilogue may create/destroy zones, so we must not
   // depend on zone allocations surviving beyond the epilogue callback.
   {
+    intptr_t scavenge_rate = ScavengeRateInBytesPerMicro();
+    intptr_t est_time = usage_before.used_in_words * kWordSize / scavenge_rate;
+
     StackZone zone(thread);
     // Setup the visitor and run the scavenge.
     ScavengerVisitor visitor(isolate, this, from);
     page_space->AcquireDataLock();
     IterateRoots(isolate, &visitor);
     int64_t start = OS::GetCurrentMonotonicMicros();
     ProcessToSpace(&visitor);
     int64_t middle = OS::GetCurrentMonotonicMicros();
     {
       TIMELINE_FUNCTION_GC_DURATION(thread, "WeakHandleProcessing");
       ScavengerWeakVisitor weak_visitor(thread, this);
       IterateWeakRoots(isolate, &weak_visitor);
     }
     ProcessWeakReferences();
     page_space->ReleaseDataLock();
 
     // Scavenge finished. Run accounting.
     int64_t end = OS::GetCurrentMonotonicMicros();
     heap_->RecordTime(kProcessToSpace, middle - start);
     heap_->RecordTime(kIterateWeaks, end - middle);
+    SpaceUsage usage_after = GetCurrentUsage();
     stats_history_.Add(ScavengeStats(
-        start, end, usage_before, GetCurrentUsage(), promo_candidate_words,
+        start, end, usage_before, usage_after, promo_candidate_words,
         visitor.bytes_promoted() >> kWordSizeLog2));
+
+    intptr_t size_before = usage_before.used_in_words * kWordSize;
+    intptr_t survivor_tenured = visitor.bytes_promoted();
+    intptr_t survivor_nontenured = usage_after.used_in_words * kWordSize;
+    intptr_t actual_time = end - start;
+
+    OS::Print("rate=%7" Pd "B/us, "
+              "size=%5" Pd "kB, "
+              "survivor=%lf, "
+              "tenured=%lf, "
+              "nontenured=%lf, "
+              "estimated=%5" Pd "ms, "
+              "actual=%5" Pd "ms, "
+              "headroom=%5" Pd "us\n",
+              scavenge_rate,
+              size_before / KB,
+              (double)(survivor_tenured+survivor_nontenured)/(double)size_before,
+              (double)(survivor_tenured)/(double)size_before,
+              (double)(survivor_nontenured)/(double)size_before,
+              est_time / 1000,
+              actual_time / 1000,
+              (est_time - actual_time)
+              );
   }
   Epilogue(isolate, from, invoke_api_callbacks);
 
   // TODO(koda): Make verification more compatible with concurrent sweep.
   if (FLAG_verify_after_gc && !FLAG_concurrent_sweep) {
     OS::PrintErr("Verifying after Scavenge...");
     heap_->Verify(kForbidMarked);
     OS::PrintErr(" done.\n");
   }
 
@@ skipping 85 matching lines @@
   return free_space >> kWordSizeLog2;
 }
 
 int64_t Scavenger::UsedInWords() const {
   int64_t free_space_in_tlab = FreeSpaceInWords(heap_->isolate());
   int64_t max_space_used = (top_ - FirstObjectStart()) >> kWordSizeLog2;
   return max_space_used - free_space_in_tlab;
 }
 
 }  // namespace dart