Avoid evacuation of popular pages.

src/heap/mark-compact.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
@@ skipping 756 matching lines @@
 
   int count = 0;
   int fragmentation = 0;
   int page_number = 0;
   int least_index = -1;
 
   PageIterator it(space);
   while (it.has_next()) {
     Page* p = it.next();
     if (p->NeverEvacuate()) continue;
+    if (p->IsFlagSet(Page::POPULAR_PAGE)) {
+      // This page had slots buffer overflow on previous GC, skip it.
+      p->ClearFlag(Page::POPULAR_PAGE);
+      continue;
+    }
 
     // Invariant: Evacuation candidates are just created when marking is
     // started. At the end of a GC all evacuation candidates are cleared and
     // their slot buffers are released.
     CHECK(!p->IsEvacuationCandidate());
     CHECK(p->slots_buffer() == NULL);
 
     if (FLAG_stress_compaction) {
       if (FLAG_manual_evacuation_candidates_selection) {
         if (p->IsFlagSet(MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING)) {
@@ skipping 3823 matching lines @@
       success = SlotsBuffer::AddTo(
           &slots_buffer_allocator_, target_page->slots_buffer_address(),
           SlotsBuffer::CODE_ENTRY_SLOT, rinfo->constant_pool_entry_address(),
           SlotsBuffer::FAIL_ON_OVERFLOW);
     } else {
       success = SlotsBuffer::AddTo(
           &slots_buffer_allocator_, target_page->slots_buffer_address(),
           SlotTypeForRMode(rmode), rinfo->pc(), SlotsBuffer::FAIL_ON_OVERFLOW);
     }
     if (!success) {
-      EvictEvacuationCandidate(target_page);
+      EvictPopularEvacuationCandidate(target_page);
     }
   }
 }
 
 
-void MarkCompactCollector::EvictEvacuationCandidate(Page* page) {
+void MarkCompactCollector::EvictPopularEvacuationCandidate(Page* page) {
   if (FLAG_trace_fragmentation) {
     PrintF("Page %p is too popular. Disabling evacuation.\n",
            reinterpret_cast<void*>(page));
   }
 
   isolate()->CountUsage(v8::Isolate::UseCounterFeature::kSlotsBufferOverflow);
 
   // TODO(gc) If all evacuation candidates are too popular we
   // should stop slots recording entirely.
   page->ClearEvacuationCandidate();
 
+  DCHECK(!page->IsFlagSet(Page::POPULAR_PAGE));
+  page->SetFlag(Page::POPULAR_PAGE);
+
   // We were not collecting slots on this page that point
   // to other evacuation candidates thus we have to
   // rescan the page after evacuation to discover and update all
   // pointers to evacuated objects.
   page->SetFlag(Page::RESCAN_ON_EVACUATION);
 }
 
 
 void MarkCompactCollector::RecordCodeEntrySlot(Address slot, Code* target) {
   Page* target_page = Page::FromAddress(reinterpret_cast<Address>(target));
   if (target_page->IsEvacuationCandidate() &&
       !ShouldSkipEvacuationSlotRecording(reinterpret_cast<Object**>(slot))) {
     if (!SlotsBuffer::AddTo(&slots_buffer_allocator_,
                             target_page->slots_buffer_address(),
                             SlotsBuffer::CODE_ENTRY_SLOT, slot,
                             SlotsBuffer::FAIL_ON_OVERFLOW)) {
-      EvictEvacuationCandidate(target_page);
+      EvictPopularEvacuationCandidate(target_page);
     }
   }
 }
 
 
 void MarkCompactCollector::RecordCodeTargetPatch(Address pc, Code* target) {
   DCHECK(heap()->gc_state() == Heap::MARK_COMPACT);
   if (is_compacting()) {
     Code* host =
         isolate()->inner_pointer_to_code_cache()->GcSafeFindCodeForInnerPointer(
@@ skipping 66 matching lines @@
   SlotsBuffer* buffer = *buffer_address;
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 }
 }  // namespace v8::internal