Pretenure some strings into bump-allocated block

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 15 matching lines @@
 
 DEFINE_FLAG(bool, verbose_gc, false, "Enables verbose GC.");
 DEFINE_FLAG(int, verbose_gc_hdr, 40, "Print verbose GC header interval.");
 DEFINE_FLAG(bool, verify_before_gc, false,
             "Enables heap verification before GC.");
 DEFINE_FLAG(bool, verify_after_gc, false,
             "Enables heap verification after GC.");
 DEFINE_FLAG(bool, gc_at_alloc, false, "GC at every allocation.");
 DEFINE_FLAG(int, new_gen_ext_limit, 64,
             "maximum total external size (MB) in new gen before triggering GC");
+DEFINE_FLAG(int, pretenure_threshold, 98,
+            "Trigger pretenuring when this many percent are promoted.");
+DEFINE_FLAG(int, pretenure_interval, 10,
+            "Back off pretenuring after this many cycles.");
 
 Heap::Heap(Isolate* isolate,
            intptr_t max_new_gen_semi_words,
            intptr_t max_old_gen_words)
-    : isolate_(isolate), read_only_(false), gc_in_progress_(false) {
+    : isolate_(isolate),
+      read_only_(false),
+      gc_in_progress_(false),
+      pretenure_policy_(0) {
   for (int sel = 0;
        sel < kNumWeakSelectors;
        sel++) {
     new_weak_tables_[sel] = new WeakTable();
     old_weak_tables_[sel] = new WeakTable();
   }
   new_space_ = new Scavenger(this,
                              max_new_gen_semi_words,
                              kNewObjectAlignmentOffset);
   old_space_ = new PageSpace(this, max_old_gen_words);
@@ skipping 80 matching lines @@
   addr = old_space_->TryAllocate(size, type, PageSpace::kForceGrowth);
   if (addr != 0) {
     return addr;
   }
   // Give up allocating this object.
   OS::PrintErr(
       "Exhausted heap space, trying to allocate %" Pd " bytes.\n", size);
   return 0;
 }
 
+
+uword Heap::AllocatePretenured(intptr_t size) {
+  ASSERT(isolate()->no_gc_scope_depth() == 0);
+  uword addr = old_space_->TryAllocateDataBump(size, PageSpace::kControlGrowth);
+  if (addr != 0) return addr;
+  return AllocateOld(size, HeapPage::kData);
+}
+
+
 void Heap::AllocateExternal(intptr_t size, Space space) {
   ASSERT(isolate()->no_gc_scope_depth() == 0);
   if (space == kNew) {
     new_space_->AllocateExternal(size);
     if (new_space_->ExternalInWords() > (FLAG_new_gen_ext_limit * MBInWords)) {
       // Attempt to free some external allocation by a scavenge. (If the total
       // remains above the limit, next external alloc will trigger another.)
       CollectGarbage(kNew);
     }
   } else {
@@ skipping 111 matching lines @@
                           GCReason reason) {
   TIMERSCOPE(isolate(), time_gc);
   bool invoke_api_callbacks = (api_callbacks == kInvokeApiCallbacks);
   switch (space) {
     case kNew: {
       VMTagScope tagScope(isolate(), VMTag::kGCNewSpaceTagId);
       RecordBeforeGC(kNew, reason);
       UpdateClassHeapStatsBeforeGC(kNew);
       new_space_->Scavenge(invoke_api_callbacks);
       isolate()->class_table()->UpdatePromoted();
+      UpdatePretenurePolicy();
       RecordAfterGC();
       PrintStats();
       if (old_space_->NeedsGarbageCollection()) {
         // Old collections should call the API callbacks.
         CollectGarbage(kOld, kInvokeApiCallbacks, kPromotion);
       }
       break;
     }
     case kOld:
     case kCode: {
@@ skipping 32 matching lines @@
 
 
 void Heap::CollectAllGarbage() {
   TIMERSCOPE(isolate(), time_gc);
   {
     VMTagScope tagScope(isolate(), VMTag::kGCNewSpaceTagId);
     RecordBeforeGC(kNew, kFull);
     UpdateClassHeapStatsBeforeGC(kNew);
     new_space_->Scavenge(kInvokeApiCallbacks);
     isolate()->class_table()->UpdatePromoted();
+    UpdatePretenurePolicy();
     RecordAfterGC();
     PrintStats();
   }
   {
     VMTagScope tagScope(isolate(), VMTag::kGCOldSpaceTagId);
     RecordBeforeGC(kOld, kFull);
     UpdateClassHeapStatsBeforeGC(kOld);
     old_space_->MarkSweep(kInvokeApiCallbacks);
     RecordAfterGC();
     PrintStats();
   }
 }
 
 
+bool Heap::ShouldPretenure(intptr_t class_id) const {
+  if (class_id == kOneByteStringCid) {
+    return pretenure_policy_ > 0;
+  } else {
+    return false;
+  }
+}
+
+
+void Heap::UpdatePretenurePolicy() {
+  ClassHeapStats* stats =
+      isolate_->class_table()->StatsWithUpdatedSize(kOneByteStringCid);
+  int allocated = stats->pre_gc.new_count;
+  int promo_percent = (allocated == 0) ? 0 :
+      (100 * stats->promoted_count) / allocated;
+  if (promo_percent >= FLAG_pretenure_threshold) {
+    pretenure_policy_ += FLAG_pretenure_interval;
+  } else {
+    pretenure_policy_ = Utils::Maximum(0, pretenure_policy_ - 1);
+  }
+}
+
+
 void Heap::SetGrowthControlState(bool state) {
   old_space_->SetGrowthControlState(state);
 }
 
 
 bool Heap::GrowthControlState() {
   return old_space_->GrowthControlState();
 }
 
 
@@ skipping 299 matching lines @@
     heap->DisableGrowthControl();
 }
 
 
 NoHeapGrowthControlScope::~NoHeapGrowthControlScope() {
     Heap* heap = reinterpret_cast<Isolate*>(isolate())->heap();
     heap->SetGrowthControlState(current_growth_controller_state_);
 }
 
 }  // namespace dart