Pretenure some strings into bump-allocated block

runtime/vm/freelist.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/freelist.h"
 
 #include <map>
 
 #include "vm/bit_set.h"
 #include "vm/lockers.h"
@@ skipping 217 matching lines @@
   FreeListElement* result = free_lists_[index];
   FreeListElement* next = result->next();
   if (next == NULL && index != kNumLists) {
     free_map_.Set(index, false);
   }
   free_lists_[index] = next;
   return result;
 }
 
 
-intptr_t FreeList::Length(int index) const {
-  MutexLocker ml(mutex_);
+intptr_t FreeList::LengthLocked(int index) const {
   ASSERT(index >= 0);

[Ivan Posva, 2014/08/29 00:07:12]

Please add
DEBUG_ASSERT(mutex_->Owner() == Isolate::Current());
as the first line.

[koda, 2014/08/29 00:52:20]

Done.

   ASSERT(index < kNumLists);
   intptr_t result = 0;
   FreeListElement* element = free_lists_[index];
   while (element != NULL) {
     ++result;
     element = element->next();
   }
   return result;
 }
 
 
 void FreeList::PrintSmall() const {
   int small_sizes = 0;
   int small_objects = 0;
   intptr_t small_bytes = 0;
   for (int i = 0; i < kNumLists; ++i) {
     if (free_lists_[i] == NULL) {
       continue;
     }
     small_sizes += 1;
-    intptr_t list_length = Length(i);
+    intptr_t list_length = LengthLocked(i);
     small_objects += list_length;
     intptr_t list_bytes = list_length * i * kObjectAlignment;
     small_bytes += list_bytes;
     OS::Print("small %3d [%8d bytes] : "
               "%8" Pd " objs; %8.1f KB; %8.1f cum KB\n",
               i,
               i * kObjectAlignment,
               list_length,
               list_bytes / static_cast<double>(KB),
               small_bytes / static_cast<double>(KB));
@@ skipping 62 matching lines @@
   if (is_protected &&
       !VirtualMemory::InSamePage(remainder_address - 1, remainder_address)) {
     bool status =
         VirtualMemory::Protect(reinterpret_cast<void*>(remainder_address),
                                remainder_size,
                                VirtualMemory::kReadExecute);
     ASSERT(status);
   }
 }
 
+
+FreeListElement* FreeList::TryAllocateLarge(intptr_t minimum_size) {
+  MutexLocker ml(mutex_);
+  FreeListElement* previous = NULL;
+  FreeListElement* current = free_lists_[kNumLists];
+  // TODO(koda): Find largest.
+  while (current != NULL) {
+    FreeListElement* next = current->next();
+    if (current->Size() >= minimum_size) {
+      if (previous == NULL) {
+        free_lists_[kNumLists] = next;
+      } else {
+        previous->set_next(next);
+      }
+      return current;
+    }
+    previous = current;
+    current = next;
+  }
+  return NULL;
+}
+
 }  // namespace dart