Reland of "[heap] Add more tasks for parallel compaction"

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 1483 matching lines @@
     // or because incremental marking wants to get a chance to do a step. Set
     // the new limit accordingly.
     Address new_top = old_top + aligned_size_in_bytes;
     InlineAllocationStep(new_top, new_top);
     UpdateInlineAllocationLimit(aligned_size_in_bytes);
   }
   return true;
 }
 
 
 void NewSpace::InlineAllocationStep(Address top, Address new_top) {

[Hannes Payer (out of office), 2015/09/25 13:04:51]

Uh, looks like you added another CL to your CL.

[Hannes Payer (out of office), 2015/09/25 13:07:38]

Ah, wrong diff view. Thanks for pointing this out.

[Michael Lippautz, 2015/09/25 13:28:49]

Acknowledged.

[Michael Lippautz, 2015/09/25 13:28:50]

Acknowledged.

   if (top_on_previous_step_) {
     int bytes_allocated = static_cast<int>(top - top_on_previous_step_);
     heap()->incremental_marking()->Step(bytes_allocated,
                                         IncrementalMarking::GC_VIA_STACK_GUARD);
     top_on_previous_step_ = new_top;
   }
 }
 
 #ifdef VERIFY_HEAP
 // We do not use the SemiSpaceIterator because verification doesn't assume
@@ skipping 689 matching lines @@
 intptr_t FreeList::Concatenate(FreeList* free_list) {
   intptr_t free_bytes = 0;
   free_bytes += small_list_.Concatenate(free_list->small_list());
   free_bytes += medium_list_.Concatenate(free_list->medium_list());
   free_bytes += large_list_.Concatenate(free_list->large_list());
   free_bytes += huge_list_.Concatenate(free_list->huge_list());
   return free_bytes;
 }
 
 
+FreeSpace* PagedSpace::TryRemoveMemory() {
+  FreeSpace* space = nullptr;
+  int node_size = 0;
+  space = free_list()->FindNodeIn(FreeList::kHuge, &node_size);
+  if (space == nullptr)
+    space = free_list()->FindNodeIn(FreeList::kLarge, &node_size);
+  if (space == nullptr)
+    space = free_list()->FindNodeIn(FreeList::kMedium, &node_size);
+  if (space == nullptr)
+    space = free_list()->FindNodeIn(FreeList::kSmall, &node_size);
+  if (space != nullptr) {
+    accounting_stats_.AllocateBytes(node_size);
+  }
+  return space;
+}
+
+
+void PagedSpace::DivideMemory(CompactionSpaceCollection** other, int num,
+                              intptr_t limit) {
+  CHECK(num > 0);
+  CHECK(other != nullptr);
+
+  if (limit == 0) limit = std::numeric_limits<intptr_t>::max();
+
+  EmptyAllocationInfo();
+
+  int index = 0;
+  FreeSpace* node = nullptr;
+  for (CompactionSpace* space = other[index]->Get(identity());
+       ((node = TryRemoveMemory()) != nullptr) &&
+       (space->free_list()->available() < limit);
+       space = other[++index % num]->Get(identity())) {
+    CHECK(space->identity() == identity());
+    space->AddMemory(node->address(), node->size());
+  }
+}
+
+
 void FreeList::Reset() {
   small_list_.Reset();
   medium_list_.Reset();
   large_list_.Reset();
   huge_list_.Reset();
 }
 
 
 int FreeList::Free(Address start, int size_in_bytes) {
   if (size_in_bytes == 0) return 0;
@@ skipping 23 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;
 }
 
 
+void FreeList::UpdateFragmentationStats(FreeListCategoryType category,
+                                        Address address, int size) {
+  Page* page = Page::FromAddress(address);
+  switch (category) {
+    case kSmall:
+      page->add_available_in_small_free_list(size);
+      break;
+    case kMedium:
+      page->add_available_in_medium_free_list(size);
+      break;
+    case kLarge:
+      page->add_available_in_large_free_list(size);
+      break;
+    case kHuge:
+      page->add_available_in_huge_free_list(size);
+      break;
+    default:
+      UNREACHABLE();
+  }
+}
+
+
+FreeSpace* FreeList::FindNodeIn(FreeListCategoryType category, int* node_size) {
+  FreeSpace* node = GetFreeListCategory(category)->PickNodeFromList(node_size);
+  if (node != nullptr) {
+    UpdateFragmentationStats(category, node->address(), -(*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);
-    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());
+    node = FindNodeIn(kSmall, node_size);
+    if (node != nullptr) {
+      DCHECK(size_in_bytes <= node->size());
       return node;
     }
   }
 
   if (size_in_bytes <= kMediumAllocationMax) {
-    node = medium_list_.PickNodeFromList(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());
+    node = FindNodeIn(kMedium, node_size);
+    if (node != nullptr) {
+      DCHECK(size_in_bytes <= node->size());
       return node;
     }
   }
 
   if (size_in_bytes <= kLargeAllocationMax) {
-    node = large_list_.PickNodeFromList(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());
+    node = FindNodeIn(kLarge, node_size);
+    if (node != nullptr) {
+      DCHECK(size_in_bytes <= node->size());
       return node;
     }
   }
 
   int huge_list_available = huge_list_.available();
   FreeSpace* top_node = huge_list_.top();
   for (FreeSpace** cur = &top_node; *cur != NULL;
        cur = (*cur)->next_address()) {
     FreeSpace* cur_node = *cur;
     while (cur_node != NULL &&
@@ skipping 235 matching lines @@
   free_list_.Reset();
 }
 
 
 intptr_t PagedSpace::SizeOfObjects() {
   DCHECK(!FLAG_concurrent_sweeping ||
          heap()->mark_compact_collector()->sweeping_in_progress() ||
          (unswept_free_bytes_ == 0));
   const intptr_t size = Size() - unswept_free_bytes_ - (limit() - top());
   DCHECK_GE(size, 0);
-  USE(size);
   return size;
 }
 
 
 // After we have booted, we have created a map which represents free space
 // on the heap.  If there was already a free list then the elements on it
 // were created with the wrong FreeSpaceMap (normally NULL), so we need to
 // fix them.
 void PagedSpace::RepairFreeListsAfterDeserialization() {
   free_list_.RepairLists(heap());
@@ skipping 583 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 }  // namespace internal
 }  // namespace v8