[heap] Free list refactoring of finding nodes.

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/slots-buffer.h"
@@ skipping 2244 matching lines @@
   // are never performed on the same free lists at the same time in
   // reverse order. Furthermore, we only lock if the PagedSpace containing
   // the free list is know to be globally available, i.e., not local.
   if (!owner()->is_local()) mutex_.Lock();
   if (!other->owner()->is_local()) other->mutex()->Lock();
 
   wasted_bytes = other->wasted_bytes_;
   wasted_bytes_ += wasted_bytes;
   other->wasted_bytes_ = 0;
 
-  usable_bytes += small_list_.Concatenate(other->small_list());
-  usable_bytes += medium_list_.Concatenate(other->medium_list());
-  usable_bytes += large_list_.Concatenate(other->large_list());
-  usable_bytes += huge_list_.Concatenate(other->huge_list());
+  usable_bytes += small_list_.Concatenate(other->GetFreeListCategory(kSmall));
+  usable_bytes += medium_list_.Concatenate(other->GetFreeListCategory(kMedium));
+  usable_bytes += large_list_.Concatenate(other->GetFreeListCategory(kLarge));
+  usable_bytes += huge_list_.Concatenate(other->GetFreeListCategory(kHuge));
 
   if (!other->owner()->is_local()) other->mutex()->Unlock();
   if (!owner()->is_local()) mutex_.Unlock();
   return usable_bytes + wasted_bytes;
 }
 
 
 void FreeList::Reset() {
   small_list_.Reset();
   medium_list_.Reset();
@@ skipping 32 matching lines @@
   } else {
     huge_list_.Free(free_space, size_in_bytes);
     page->add_available_in_huge_free_list(size_in_bytes);
   }
 
   DCHECK(IsVeryLong() || available() == SumFreeLists());
   return 0;
 }
 
 
+FreeSpace* FreeList::FindNodeIn(FreeListCategoryType category, int* node_size) {

[Michael Lippautz, 2015/10/08 14:45:01]

FYI: This one will be used in a follow-up CL for finding memory , similar to
  if (node == nullptr) node = FindNodeIn(kHuge, &node_size);
  if (node == nullptr) node = FindNodeIn(kLarge, &node_size);
  if (node == nullptr) node = FindNodeIn(kMedium, &node_size);
  ...

+  FreeSpace* node = GetFreeListCategory(category)->PickNodeFromList(node_size);
+  if (node != nullptr) {
+    Page::FromAddress(node->address())
+        ->add_available_in_free_list(category, -(*node_size));
+    DCHECK(IsVeryLong() || available() == SumFreeLists());
+  }
+  return node;
+}
+
+
 FreeSpace* FreeList::FindNodeFor(int size_in_bytes, int* node_size) {
   FreeSpace* node = NULL;
   Page* page = NULL;
 
   if (size_in_bytes <= kSmallAllocationMax) {
-    node = small_list_.PickNodeFromList(node_size);
+    node = FindNodeIn(kSmall, node_size);
     if (node != NULL) {
-      DCHECK(size_in_bytes <= *node_size);
-      page = Page::FromAddress(node->address());
-      page->add_available_in_small_free_list(-(*node_size));
       DCHECK(IsVeryLong() || available() == SumFreeLists());
       return node;
     }
   }
 
   if (size_in_bytes <= kMediumAllocationMax) {
-    node = medium_list_.PickNodeFromList(node_size);
+    node = FindNodeIn(kMedium, node_size);
     if (node != NULL) {
-      DCHECK(size_in_bytes <= *node_size);
-      page = Page::FromAddress(node->address());
-      page->add_available_in_medium_free_list(-(*node_size));
       DCHECK(IsVeryLong() || available() == SumFreeLists());
       return node;
     }
   }
 
   if (size_in_bytes <= kLargeAllocationMax) {
-    node = large_list_.PickNodeFromList(node_size);
+    node = FindNodeIn(kLarge, node_size);
     if (node != NULL) {
-      DCHECK(size_in_bytes <= *node_size);
-      page = Page::FromAddress(node->address());
-      page->add_available_in_large_free_list(-(*node_size));
       DCHECK(IsVeryLong() || available() == SumFreeLists());
       return node;
     }
   }
 
   node = huge_list_.SearchForNodeInList(size_in_bytes, node_size);
 
   if (node != NULL) {
     DCHECK(IsVeryLong() || available() == SumFreeLists());
     return node;
@@ skipping 793 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 }  // namespace internal
 }  // namespace v8