Pretenure some strings into bump-allocated block

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/assert.h"
 #include "vm/compiler_stats.h"
 #include "vm/gc_marker.h"
 #include "vm/gc_sweeper.h"
 #include "vm/lockers.h"
 #include "vm/object.h"
 #include "vm/thread.h"
 #include "vm/virtual_memory.h"
 
 namespace dart {
 
 DEFINE_FLAG(int, heap_growth_space_ratio, 20,
             "The desired maximum percentage of free space after GC");
 DEFINE_FLAG(int, heap_growth_time_ratio, 3,
             "The desired maximum percentage of time spent in GC");
-DEFINE_FLAG(int, heap_growth_rate, 256,
+DEFINE_FLAG(int, heap_growth_rate, 280,
             "The max number of pages the heap can grow at a time");
 DEFINE_FLAG(bool, print_free_list_before_gc, false,
             "Print free list statistics before a GC");
 DEFINE_FLAG(bool, print_free_list_after_gc, false,
             "Print free list statistics after a GC");
 DEFINE_FLAG(bool, collect_code, true,
             "Attempt to GC infrequently used code.");
 DEFINE_FLAG(int, code_collection_interval_in_us, 30000000,
             "Time between attempts to collect unused code.");
 DEFINE_FLAG(bool, log_code_drop, false,
             "Emit a log message when pointers to unused code are dropped.");
 DEFINE_FLAG(bool, always_drop_code, false,
             "Always try to drop code if the function's usage counter is >= 0");
 DEFINE_FLAG(bool, concurrent_sweep, false,
             "Concurrent sweep for old generation.");
+DEFINE_FLAG(bool, log_growth, false, "Log PageSpace growth policy decisions.");
 
 HeapPage* HeapPage::Initialize(VirtualMemory* memory, PageType type) {
   ASSERT(memory->size() > VirtualMemory::PageSize());
   bool is_executable = (type == kExecutable);
   memory->Commit(is_executable);
 
   HeapPage* result = reinterpret_cast<HeapPage*>(memory->address());
   result->memory_ = memory;
   result->next_ = NULL;
   result->executable_ = is_executable;
@@ skipping 74 matching lines @@
 
 PageSpace::PageSpace(Heap* heap, intptr_t max_capacity_in_words)
     : freelist_(),
       heap_(heap),
       pages_lock_(new Mutex()),
       pages_(NULL),
       pages_tail_(NULL),
       exec_pages_(NULL),
       exec_pages_tail_(NULL),
       large_pages_(NULL),
+      bump_top_(0),
+      bump_end_(0),
       max_capacity_in_words_(max_capacity_in_words),
       tasks_lock_(new Monitor()),
       tasks_(0),
       page_space_controller_(heap,
                              FLAG_heap_growth_space_ratio,
                              FLAG_heap_growth_rate,
                              FLAG_heap_growth_time_ratio),
       gc_time_micros_(0),
       collections_(0) {
 }
@@ skipping 132 matching lines @@
 void PageSpace::FreePages(HeapPage* pages) {
   HeapPage* page = pages;
   while (page != NULL) {
     HeapPage* next = page->next();
     page->Deallocate();
     page = next;
   }
 }
 
 
+uword PageSpace::TryAllocateInFreshPage(intptr_t size,
+                                        HeapPage::PageType type,
+                                        GrowthPolicy growth_policy,
+                                        bool is_locked) {
+  ASSERT(size < kAllocatablePageSize);
+  uword result = 0;
+  SpaceUsage after_allocation = usage_;
+  after_allocation.used_in_words += size >> kWordSizeLog2;
+  // Can we grow by one page?
+  after_allocation.capacity_in_words += kPageSizeInWords;
+  if ((growth_policy == kForceGrowth ||
+       !page_space_controller_.NeedsGarbageCollection(after_allocation)) &&
+      CanIncreaseCapacityInWords(kPageSizeInWords)) {
+    HeapPage* page = AllocatePage(type);
+    ASSERT(page != NULL);
+    // Start of the newly allocated page is the allocated object.
+    result = page->object_start();
+    usage_ = after_allocation;
+    // Enqueue the remainder in the free list.
+    uword free_start = result + size;
+    intptr_t free_size = page->object_end() - free_start;
+    if (free_size > 0) {
+      if (is_locked) {
+        freelist_[type].FreeLocked(free_start, free_size);
+      } else {
+        freelist_[type].Free(free_start, free_size);
+      }
+    }
+  }
+  return result;
+}
+
+
 uword PageSpace::TryAllocateInternal(intptr_t size,
                             HeapPage::PageType type,
                             GrowthPolicy growth_policy,
                             bool is_protected,
                             bool is_locked) {
   ASSERT(size >= kObjectAlignment);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   uword result = 0;
-  SpaceUsage after_allocation = usage_;
-  after_allocation.used_in_words += size >> kWordSizeLog2;
   if (size < kAllocatablePageSize) {
     if (is_locked) {
       result = freelist_[type].TryAllocateLocked(size, is_protected);
     } else {
       result = freelist_[type].TryAllocate(size, is_protected);
     }
     if (result == 0) {
-      // Can we grow by one page?
-      after_allocation.capacity_in_words += kPageSizeInWords;
-      if ((!page_space_controller_.NeedsGarbageCollection(after_allocation) ||
-           growth_policy == kForceGrowth) &&
-          CanIncreaseCapacityInWords(kPageSizeInWords)) {
-        HeapPage* page = AllocatePage(type);
-        ASSERT(page != NULL);
-        // Start of the newly allocated page is the allocated object.
-        result = page->object_start();
-        // Enqueue the remainder in the free list.
-        uword free_start = result + size;
-        intptr_t free_size = page->object_end() - free_start;
-        if (free_size > 0) {
-          if (is_locked) {
-            freelist_[type].FreeLocked(free_start, free_size);
-          } else {
-            freelist_[type].Free(free_start, free_size);
-          }
-        }
-      }
+      result = TryAllocateInFreshPage(size, type, growth_policy, is_locked);
     }
   } else {
     // Large page allocation.
     intptr_t page_size_in_words = LargePageSizeInWordsFor(size);
     if ((page_size_in_words << kWordSizeLog2) < size) {
       // On overflow we fail to allocate.
       return 0;
     }
+    SpaceUsage after_allocation = usage_;
+    after_allocation.used_in_words += size >> kWordSizeLog2;
     after_allocation.capacity_in_words += page_size_in_words;
-    if ((!page_space_controller_.NeedsGarbageCollection(after_allocation) ||
-         growth_policy == kForceGrowth) &&
+    if ((growth_policy == kForceGrowth ||
+         !page_space_controller_.NeedsGarbageCollection(after_allocation)) &&
         CanIncreaseCapacityInWords(page_size_in_words)) {
       HeapPage* page = AllocateLargePage(size, type);
       if (page != NULL) {
         result = page->object_start();
+        usage_ = after_allocation;
       }
     }
   }
   if (result != 0) {
-    usage_ = after_allocation;
     if (FLAG_compiler_stats && (type == HeapPage::kExecutable)) {
       CompilerStats::code_allocated += size;
     }
   }
   ASSERT((result & kObjectAlignmentMask) == kOldObjectAlignmentOffset);
   return result;
 }
 
 
   void PageSpace::AcquireDataLock() {
@@ skipping 270 matching lines @@
   SpaceUsage usage_before = usage_;
 
   // Mark all reachable old-gen objects.
   bool collect_code = FLAG_collect_code && ShouldCollectCode();
   GCMarker marker(heap_);
   marker.MarkObjects(isolate, this, invoke_api_callbacks, collect_code);
   usage_.used_in_words = marker.marked_words();
 
   int64_t mid1 = OS::GetCurrentTimeMicros();
 
-  // Reset the bump allocation page to unused.
+  // Abandon the remainder of the bump allocation block.
+  bump_top_ = 0;
+  bump_end_ = 0;
   // Reset the freelists and setup sweeping.
   freelist_[HeapPage::kData].Reset();
   freelist_[HeapPage::kExecutable].Reset();
 
   int64_t mid2 = OS::GetCurrentTimeMicros();
   int64_t mid3 = 0;
 
   {
     GCSweeper sweeper(heap_);
 
@@ skipping 86 matching lines @@
 
   // Done, reset the task count.
   {
     MonitorLocker ml(tasks_lock());
     set_tasks(tasks() - 1);
     ml.Notify();
   }
 }
 
 
+uword PageSpace::TryAllocateDataBump(intptr_t size,
+                                     GrowthPolicy growth_policy) {
+  ASSERT(size >= kObjectAlignment);
+  ASSERT(Utils::IsAligned(size, kObjectAlignment));
+  intptr_t remaining = bump_end_ - bump_top_;
+  if (remaining < size) {
+    // Checking this first would be logical, but needlessly slow.
+    if (size >= kAllocatablePageSize) {
+      return TryAllocate(size, HeapPage::kData, growth_policy);
+    }
+    FreeListElement* block = freelist_[HeapPage::kData].TryAllocateLarge(size);
+    if (block == NULL) {
+      // Allocating from a new page (if growth policy allows) will have the
+      // side-effect of populating the freelist with a large block. The next
+      // bump allocation request will have a chance to consume that block.
+      // TODO(koda): Could take freelist lock just once instead of twice.
+      return TryAllocateInFreshPage(size,
+                                    HeapPage::kData,
+                                    growth_policy,
+                                    /* is_locked = */ false);
+    }
+    intptr_t block_size = block->Size();
+    bump_top_ = reinterpret_cast<uword>(block);
+    bump_end_ = bump_top_ + block_size;
+    remaining = block_size;
+  }
+  ASSERT(remaining >= size);
+  uword result = bump_top_;
+  bump_top_ += size;
+  usage_.used_in_words += size >> kWordSizeLog2;
+  remaining -= size;
+  if (remaining > 0) {
+    FreeListElement::AsElement(bump_top_, remaining);
+  }
+  return result;
+}
+
+
 PageSpaceController::PageSpaceController(Heap* heap,
                                          int heap_growth_ratio,
                                          int heap_growth_max,
                                          int garbage_collection_time_ratio)
     : heap_(heap),
       is_enabled_(false),
       grow_heap_(heap_growth_max / 2),
       heap_growth_ratio_(heap_growth_ratio),
       desired_utilization_((100.0 - heap_growth_ratio) / 100.0),
       heap_growth_max_(heap_growth_max),
@@ skipping 25 matching lines @@
   // To avoid waste, the first GC should be triggered before too long. After
   // kInitialTimeoutSeconds, gradually lower the capacity limit.
   static const double kInitialTimeoutSeconds = 1.00;
   if (history_.IsEmpty()) {
     double seconds_since_init = MicrosecondsToSeconds(
         OS::GetCurrentTimeMicros() - heap_->isolate()->start_time());
     if (seconds_since_init > kInitialTimeoutSeconds) {
       multiplier *= seconds_since_init / kInitialTimeoutSeconds;
     }
   }
-  return capacity_increase_in_pages * multiplier > grow_heap_;
+  bool needs_gc = capacity_increase_in_pages * multiplier > grow_heap_;
+  if (FLAG_log_growth) {
+    OS::PrintErr("%s: %" Pd " * %f %s %" Pd "\n",
+                 needs_gc ? "NEEDS GC" : "grow",
+                 capacity_increase_in_pages,
+                 multiplier,
+                 needs_gc ? ">" : "<=",
+                 grow_heap_);
+  }
+  return needs_gc;
 }
 
 
 void PageSpaceController::EvaluateGarbageCollection(
     SpaceUsage before, SpaceUsage after, int64_t start, int64_t end) {
   ASSERT(end >= start);
   history_.AddGarbageCollectionTime(start, end);
   int gc_time_fraction = history_.GarbageCollectionTimeFraction();
   heap_->RecordData(PageSpace::kGCTimeFraction, gc_time_fraction);
 
@@ skipping 57 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