[heap] Add two tiny free list categories.

src/heap/spaces.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/heap/spaces.h"
 
 #include "src/base/bits.h"
 #include "src/base/platform/platform.h"
 #include "src/full-codegen/full-codegen.h"
 #include "src/heap/slot-set.h"
@@ skipping 2361 matching lines @@
 
 
 int FreeList::Free(Address start, int size_in_bytes) {
   if (size_in_bytes == 0) return 0;
 
   owner()->heap()->CreateFillerObjectAt(start, size_in_bytes,
                                         ClearRecordedSlots::kNo);
 
   Page* page = Page::FromAddress(start);
 
-  // Early return to drop too-small blocks on the floor.
-  if (size_in_bytes <= kSmallListMin) {
+  // Blocks have to be a minimum size to hold free list items.
+  if (size_in_bytes < kMinBlockSize) {
     page->add_wasted_memory(size_in_bytes);
     wasted_bytes_ += size_in_bytes;
     return size_in_bytes;
   }
 
   FreeSpace* free_space = FreeSpace::cast(HeapObject::FromAddress(start));
   // Insert other blocks at the head of a free list of the appropriate
   // magnitude.
   FreeListCategoryType type = SelectFreeListCategoryType(size_in_bytes);
   category_[type].Free(free_space, size_in_bytes);
@@ skipping 36 matching lines @@
     page->add_available_in_free_list(-(*node_size));
     DCHECK(IsVeryLong() || Available() == SumFreeLists());
     return node;
   }
 
   // We need a huge block of memory, but we didn't find anything in the huge
   // list.
   if (type == kHuge) return nullptr;
 
   // Now search the best fitting free list for a node that has at least the
-  // requested size. This takes linear time in the number of elements.
+  // requested size.
   type = SelectFreeListCategoryType(size_in_bytes);
   node = category_[type].PickNodeFromList(size_in_bytes, node_size);
   if (node != nullptr) {
     DCHECK(size_in_bytes <= *node_size);
     page = Page::FromAddress(node->address());
     page->add_available_in_free_list(-(*node_size));
   }
 
   DCHECK(IsVeryLong() || Available() == SumFreeLists());
   return node;
 }
 
 
 FreeSpace* FreeList::TryRemoveMemory(intptr_t hint_size_in_bytes) {
   hint_size_in_bytes = RoundDown(hint_size_in_bytes, kPointerSize);
   base::LockGuard<base::Mutex> guard(&mutex_);
   FreeSpace* node = nullptr;
   int node_size = 0;
   // Try to find a node that fits exactly.
   node = FindNodeFor(static_cast<int>(hint_size_in_bytes), &node_size);
   // If no node could be found get as much memory as possible.
   if (node == nullptr) node = FindNodeIn(kHuge, &node_size);
   if (node == nullptr) node = FindNodeIn(kLarge, &node_size);
   if (node != nullptr) {
-    // We round up the size to (kSmallListMin + kPointerSize) to (a) have a
+    // We round up the size to (kMinBlockSize + kPointerSize) to (a) have a
     // size larger then the minimum size required for FreeSpace, and (b) to get
     // a block that can actually be freed into some FreeList later on.
-    if (hint_size_in_bytes <= kSmallListMin) {
-      hint_size_in_bytes = kSmallListMin + kPointerSize;
+    if (hint_size_in_bytes <= kMinBlockSize) {
+      hint_size_in_bytes = kMinBlockSize + kPointerSize;
     }
     // Give back left overs that were not required by {size_in_bytes}.
     intptr_t left_over = node_size - hint_size_in_bytes;
 
-    // Do not bother to return anything below {kSmallListMin} as it would be
+    // Do not bother to return anything below {kMinBlockSize} as it would be
     // immediately discarded anyways.
-    if (left_over > kSmallListMin) {
+    if (left_over > kMinBlockSize) {
       Free(node->address() + hint_size_in_bytes, static_cast<int>(left_over));
       node->set_size(static_cast<int>(hint_size_in_bytes));
     }
   }
   return node;
 }
 
 
 // Allocation on the old space free list.  If it succeeds then a new linear
 // allocation space has been set up with the top and limit of the space.  If
@@ skipping 755 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 }  // namespace internal
 }  // namespace v8