- Promote objects early when a large percentage is being

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 <algorithm>
 #include <map>
 #include <utility>
 
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/store_buffer.h"
 #include "vm/verifier.h"
 #include "vm/visitor.h"
 #include "vm/weak_table.h"
 #include "vm/object_id_ring.h"
 
 namespace dart {
 
+  DEFINE_FLAG(int, early_tenuring_threshold, 66, "Skip TO space when promoting"
+                                                 " above this percentage.");
+
 // Scavenger uses RawObject::kMarkBit to distinguish forwaded and non-forwarded
 // objects. The kMarkBit does not intersect with the target address because of
 // object alignment.
 enum {
   kForwardingMask = 1 << RawObject::kMarkBit,
   kNotForwarded = 0,
   kForwarded = kForwardingMask,
 };
 
 
@@ skipping 328 matching lines @@
   // objects.
   MemoryRegion* temp = from_;
   from_ = to_;
   to_ = temp;
   top_ = FirstObjectStart();
   resolved_top_ = top_;
   end_ = to_->end();
 }
 
 
-void Scavenger::Epilogue(Isolate* isolate, bool invoke_api_callbacks) {
+void Scavenger::Epilogue(Isolate* isolate,
+                         ScavengerVisitor* visitor,
+                         bool invoke_api_callbacks) {
   // All objects in the to space have been copied from the from space at this
   // moment.
-  survivor_end_ = top_;
+  int promotion_ratio = static_cast<int>(
+      (static_cast<double>(visitor->bytes_promoted()) /
+       static_cast<double>(to_->size())) * 100.0);
+  if (promotion_ratio < FLAG_early_tenuring_threshold) {
+    // Remember the limit to which objects have been copied.
+    survivor_end_ = top_;
+  } else {
+    // Move survivor end to the end of the to_ space, making all surviving
+    // objects candidates for promotion.
+    survivor_end_ = end_;
+  }
 
 #if defined(DEBUG)
   VerifyStoreBufferPointerVisitor verify_store_buffer_visitor(isolate, to_);
   heap_->IterateOldPointers(&verify_store_buffer_visitor);
 
   memset(from_->pointer(), 0xf3, from_->size());
 #endif  // defined(DEBUG)
   if (invoke_api_callbacks) {
     isolate->gc_epilogue_callbacks().Invoke();
   }
@@ skipping 280 matching lines @@
   ProcessToSpace(&visitor);
   int64_t middle = OS::GetCurrentTimeMicros();
   IterateWeakReferences(isolate, &visitor);
   ScavengerWeakVisitor weak_visitor(this);
   IterateWeakRoots(isolate, &weak_visitor, invoke_api_callbacks);
   visitor.Finalize();
   ProcessWeakTables();
   int64_t end = OS::GetCurrentTimeMicros();
   heap_->RecordTime(kProcessToSpace, middle - start);
   heap_->RecordTime(kIterateWeaks, end - middle);
-  Epilogue(isolate, invoke_api_callbacks);
+  Epilogue(isolate, &visitor, invoke_api_callbacks);
 
   if (FLAG_verify_after_gc) {
     OS::PrintErr("Verifying after Scavenge...");
     heap_->Verify();
     OS::PrintErr(" done.\n");
   }
 
   // Done scavenging. Reset the marker.
   ASSERT(scavenging_);
   scavenging_ = false;
 }
 
 
 void Scavenger::WriteProtect(bool read_only) {
   space_->Protect(
       read_only ? VirtualMemory::kReadOnly : VirtualMemory::kReadWrite);
 }
 
 
 }  // namespace dart