Bump allocation for promotion

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"
@@ skipping 752 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) {
+uword PageSpace::TryAllocateDataBumpInternal(intptr_t size,
+                                             GrowthPolicy growth_policy,
+                                             bool is_locked) {
   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);
+      return is_locked ?
+          TryAllocateDataLocked(size, growth_policy) :
+          TryAllocate(size, HeapPage::kData, growth_policy);
     }
-    FreeListElement* block = freelist_[HeapPage::kData].TryAllocateLarge(size);
+    FreeListElement* block = is_locked ?
+        freelist_[HeapPage::kData].TryAllocateLargeLocked(size) :
+        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);
+                                    is_locked);
     }
     intptr_t block_size = block->Size();
+    if (remaining > 0) {
+      if (is_locked) {
+        freelist_[HeapPage::kData].FreeLocked(bump_top_, remaining);
+      } else {
+        freelist_[HeapPage::kData].Free(bump_top_, remaining);
+      }
+    }
     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;
 }
 
 
+uword PageSpace::TryAllocateDataBump(intptr_t size,
+                                     GrowthPolicy growth_policy) {
+  return TryAllocateDataBumpInternal(size, growth_policy, false);
+}
+
+
+uword PageSpace::TryAllocateDataBumpLocked(intptr_t size,
+                                           GrowthPolicy growth_policy) {
+  return TryAllocateDataBumpInternal(size, growth_policy, true);
+}
+
+
+uword PageSpace::TryAllocatePromoLocked(intptr_t size,
+                                        GrowthPolicy growth_policy) {
+  FreeList* freelist = &freelist_[HeapPage::kData];
+  uword result = freelist->TryAllocateSmallLocked(size);
+  if (result != 0) {
+    usage_.used_in_words += size >> kWordSizeLog2;
+    return result;
+  }
+  result = TryAllocateDataBumpLocked(size, growth_policy);
+  if (result != 0) return result;
+  return TryAllocateDataLocked(size, growth_policy);
+}
+
+
 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 112 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