Make sure that we grow the slots buffer when we are in evacuation scope.

src/mark-compact.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 56 matching lines @@
       compacting_(false),
       was_marked_incrementally_(false),
       sweeping_pending_(false),
       pending_sweeper_jobs_semaphore_(0),
       sequential_sweeping_(false),
       tracer_(NULL),
       migration_slots_buffer_(NULL),
       heap_(heap),
       code_flusher_(NULL),
       encountered_weak_collections_(NULL),
-      have_code_to_deoptimize_(false) { }
+      have_code_to_deoptimize_(false),
+      evacuation_scope_(0) { }
 
 #ifdef VERIFY_HEAP
 class VerifyMarkingVisitor: public ObjectVisitor {
  public:
   explicit VerifyMarkingVisitor(Heap* heap) : heap_(heap) {}
 
   void VisitPointers(Object** start, Object** end) {
     for (Object** current = start; current < end; current++) {
       if ((*current)->IsHeapObject()) {
         HeapObject* object = HeapObject::cast(*current);
@@ skipping 2747 matching lines @@
     ASSERT(IsAligned(size, kPointerSize));
 
     for (int remaining = size / kPointerSize; remaining > 0; remaining--) {
       Object* value = Memory::Object_at(src_slot);
 
       Memory::Object_at(dst_slot) = value;
 
       if (heap_->InNewSpace(value)) {
         heap_->store_buffer()->Mark(dst_slot);
       } else if (value->IsHeapObject() && IsOnEvacuationCandidate(value)) {
-        SlotsBuffer::AddTo(&slots_buffer_allocator_,
+        SlotsBuffer::AddTo(heap_,
+                           &slots_buffer_allocator_,
                            &migration_slots_buffer_,
                            reinterpret_cast<Object**>(dst_slot),
                            SlotsBuffer::IGNORE_OVERFLOW);
       }
 
       src_slot += kPointerSize;
       dst_slot += kPointerSize;
     }
 
     if (compacting_ && HeapObject::FromAddress(dst)->IsJSFunction()) {
       Address code_entry_slot = dst + JSFunction::kCodeEntryOffset;
       Address code_entry = Memory::Address_at(code_entry_slot);
 
       if (Page::FromAddress(code_entry)->IsEvacuationCandidate()) {
-        SlotsBuffer::AddTo(&slots_buffer_allocator_,
+        SlotsBuffer::AddTo(heap_,
+                           &slots_buffer_allocator_,
                            &migration_slots_buffer_,
                            SlotsBuffer::CODE_ENTRY_SLOT,
                            code_entry_slot,
                            SlotsBuffer::IGNORE_OVERFLOW);
       }
     }
   } else if (dest == CODE_SPACE) {
     PROFILE(isolate(), CodeMoveEvent(src, dst));
     heap()->MoveBlock(dst, src, size);
-    SlotsBuffer::AddTo(&slots_buffer_allocator_,
+    SlotsBuffer::AddTo(heap_,
+                       &slots_buffer_allocator_,
                        &migration_slots_buffer_,
                        SlotsBuffer::RELOCATED_CODE_OBJECT,
                        dst,
                        SlotsBuffer::IGNORE_OVERFLOW);
     Code::cast(HeapObject::FromAddress(dst))->Relocate(dst - src);
   } else {
     ASSERT(dest == OLD_DATA_SPACE || dest == NEW_SPACE);
     heap()->MoveBlock(dst, src, size);
   }
   Memory::Address_at(src) = dst;
@@ skipping 586 matching lines @@
                              GCTracer::Scope::MC_UPDATE_OLD_TO_NEW_POINTERS);
     StoreBufferRebuildScope scope(heap_,
                                   heap_->store_buffer(),
                                   &Heap::ScavengeStoreBufferCallback);
     heap_->store_buffer()->IteratePointersToNewSpaceAndClearMaps(
         &UpdatePointer);
   }
 
   { GCTracer::Scope gc_scope(tracer_,
                              GCTracer::Scope::MC_UPDATE_POINTERS_TO_EVACUATED);
-    SlotsBuffer::UpdateSlotsRecordedIn(heap_,
-                                       migration_slots_buffer_,
-                                       code_slots_filtering_required);
+    migration_slots_buffer_->UpdateSlotsRecordedIn(
+        code_slots_filtering_required);
     if (FLAG_trace_fragmentation) {
       PrintF("  migration slots buffer: %d\n",
              SlotsBuffer::SizeOfChain(migration_slots_buffer_));
     }
 
     if (compacting_ && was_marked_incrementally_) {
       // It's difficult to filter out slots recorded for large objects.
       LargeObjectIterator it(heap_->lo_space());
       for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
         // LargeObjectSpace is not swept yet thus we have to skip
@@ skipping 11 matching lines @@
 
   int npages = evacuation_candidates_.length();
   { GCTracer::Scope gc_scope(
       tracer_, GCTracer::Scope::MC_UPDATE_POINTERS_BETWEEN_EVACUATED);
     for (int i = 0; i < npages; i++) {
       Page* p = evacuation_candidates_[i];
       ASSERT(p->IsEvacuationCandidate() ||
              p->IsFlagSet(Page::RESCAN_ON_EVACUATION));
 
       if (p->IsEvacuationCandidate()) {
-        SlotsBuffer::UpdateSlotsRecordedIn(heap_,
-                                           p->slots_buffer(),
-                                           code_slots_filtering_required);
+        p->slots_buffer()->UpdateSlotsRecordedIn(code_slots_filtering_required);
         if (FLAG_trace_fragmentation) {
           PrintF("  page %p slots buffer: %d\n",
                  reinterpret_cast<void*>(p),
                  SlotsBuffer::SizeOfChain(p->slots_buffer()));
         }
 
         // Important: skip list should be cleared only after roots were updated
         // because root iteration traverses the stack and might have to find
         // code objects from non-updated pc pointing into evacuation candidate.
         SkipList* list = p->skip_list();
@@ skipping 683 matching lines @@
   state_ = SWEEP_SPACES;
 #endif
   SweeperType how_to_sweep =
       FLAG_lazy_sweeping ? LAZY_CONSERVATIVE : CONSERVATIVE;
   if (AreSweeperThreadsActivated()) {
     if (FLAG_parallel_sweeping) how_to_sweep = PARALLEL_CONSERVATIVE;
     if (FLAG_concurrent_sweeping) how_to_sweep = CONCURRENT_CONSERVATIVE;
   }
   if (sweep_precisely_) how_to_sweep = PRECISE;
 
+  EvacuationScope no_evacuation(this);

[Michael Starzinger, 2014/03/06 10:47:25]

nit: The naming of this scope (the local variable, not the class) is weird,
shouldn't it be called "in_evacuation" instead, because it indicates we are
evacuating now?

Also, can we move it to the top of the function, to right after the "gc_scope"?

   // Unlink evacuation candidates before sweeper threads access the list of
   // pages to avoid race condition.
   UnlinkEvacuationCandidates();
 
   // Noncompacting collections simply sweep the spaces to clear the mark
   // bits and free the nonlive blocks (for old and map spaces).  We sweep
   // the map space last because freeing non-live maps overwrites them and
   // the other spaces rely on possibly non-live maps to get the sizes for
   // non-live objects.
   SequentialSweepingScope scope(this);
@@ skipping 98 matching lines @@
   MarkCompactMarkingVisitor::Initialize();
   IncrementalMarking::Initialize();
 }
 
 
 bool SlotsBuffer::IsTypedSlot(ObjectSlot slot) {
   return reinterpret_cast<uintptr_t>(slot) < NUMBER_OF_SLOT_TYPES;
 }
 
 
-bool SlotsBuffer::AddTo(SlotsBufferAllocator* allocator,
-                        SlotsBuffer** buffer_address,
-                        SlotType type,
-                        Address addr,
-                        AdditionMode mode) {
-  SlotsBuffer* buffer = *buffer_address;
-  if (buffer == NULL || !buffer->HasSpaceForTypedSlot()) {
-    if (mode == FAIL_ON_OVERFLOW && ChainLengthThresholdReached(buffer)) {
-      allocator->DeallocateChain(buffer_address);
-      return false;
-    }
-    buffer = allocator->AllocateBuffer(buffer);
-    *buffer_address = buffer;
-  }
-  ASSERT(buffer->HasSpaceForTypedSlot());
-  buffer->Add(reinterpret_cast<ObjectSlot>(type));
-  buffer->Add(reinterpret_cast<ObjectSlot>(addr));
-  return true;
-}
-
-
 static inline SlotsBuffer::SlotType SlotTypeForRMode(RelocInfo::Mode rmode) {
   if (RelocInfo::IsCodeTarget(rmode)) {
     return SlotsBuffer::CODE_TARGET_SLOT;
   } else if (RelocInfo::IsEmbeddedObject(rmode)) {
     return SlotsBuffer::EMBEDDED_OBJECT_SLOT;
   } else if (RelocInfo::IsDebugBreakSlot(rmode)) {
     return SlotsBuffer::DEBUG_TARGET_SLOT;
   } else if (RelocInfo::IsJSReturn(rmode)) {
     return SlotsBuffer::JS_RETURN_SLOT;
   }
   UNREACHABLE();
   return SlotsBuffer::NUMBER_OF_SLOT_TYPES;
 }
 
 
 void MarkCompactCollector::RecordRelocSlot(RelocInfo* rinfo, Object* target) {
   Page* target_page = Page::FromAddress(reinterpret_cast<Address>(target));
   if (target_page->IsEvacuationCandidate() &&
       (rinfo->host() == NULL ||
        !ShouldSkipEvacuationSlotRecording(rinfo->host()))) {
-    if (!SlotsBuffer::AddTo(&slots_buffer_allocator_,
+    if (!SlotsBuffer::AddTo(heap_,
+                            &slots_buffer_allocator_,
                             target_page->slots_buffer_address(),
                             SlotTypeForRMode(rinfo->rmode()),
                             rinfo->pc(),
                             SlotsBuffer::FAIL_ON_OVERFLOW)) {
       EvictEvacuationCandidate(target_page);
     }
   }
 }
 
 
 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_,
+    if (!SlotsBuffer::AddTo(heap_,
+                            &slots_buffer_allocator_,
                             target_page->slots_buffer_address(),
                             SlotsBuffer::CODE_ENTRY_SLOT,
                             slot,
                             SlotsBuffer::FAIL_ON_OVERFLOW)) {
       EvictEvacuationCandidate(target_page);
     }
   }
 }
 
 
@@ skipping 10 matching lines @@
   }
 }
 
 
 static inline SlotsBuffer::SlotType DecodeSlotType(
     SlotsBuffer::ObjectSlot slot) {
   return static_cast<SlotsBuffer::SlotType>(reinterpret_cast<intptr_t>(slot));
 }
 
 
-void SlotsBuffer::UpdateSlots(Heap* heap) {
-  PointersUpdatingVisitor v(heap);
+void SlotsBuffer::UpdateSlots() {
+  PointersUpdatingVisitor v(heap_);
 
   for (int slot_idx = 0; slot_idx < idx_; ++slot_idx) {
     ObjectSlot slot = slots_[slot_idx];
     if (!IsTypedSlot(slot)) {
-      PointersUpdatingVisitor::UpdateSlot(heap, slot);
+      PointersUpdatingVisitor::UpdateSlot(heap_, slot);
     } else {
       ++slot_idx;
       ASSERT(slot_idx < idx_);
-      UpdateSlot(heap->isolate(),
+      UpdateSlot(heap_->isolate(),
                  &v,
                  DecodeSlotType(slot),
                  reinterpret_cast<Address>(slots_[slot_idx]));
     }
   }
 }
 
 
-void SlotsBuffer::UpdateSlotsWithFilter(Heap* heap) {
-  PointersUpdatingVisitor v(heap);
+void SlotsBuffer::UpdateSlotsWithFilter() {
+  PointersUpdatingVisitor v(heap_);
 
   for (int slot_idx = 0; slot_idx < idx_; ++slot_idx) {
     ObjectSlot slot = slots_[slot_idx];
     if (!IsTypedSlot(slot)) {
       if (!IsOnInvalidatedCodeObject(reinterpret_cast<Address>(slot))) {
-        PointersUpdatingVisitor::UpdateSlot(heap, slot);
+        PointersUpdatingVisitor::UpdateSlot(heap_, slot);
       }
     } else {
       ++slot_idx;
       ASSERT(slot_idx < idx_);
       Address pc = reinterpret_cast<Address>(slots_[slot_idx]);
       if (!IsOnInvalidatedCodeObject(pc)) {
-        UpdateSlot(heap->isolate(),
+        UpdateSlot(heap_->isolate(),
                    &v,
                    DecodeSlotType(slot),
                    reinterpret_cast<Address>(slots_[slot_idx]));
       }
     }
   }
 }
 
 
-SlotsBuffer* SlotsBufferAllocator::AllocateBuffer(SlotsBuffer* next_buffer) {
-  return new SlotsBuffer(next_buffer);
+SlotsBuffer* SlotsBufferAllocator::AllocateBuffer(Heap* heap,
+                                                  SlotsBuffer* next_buffer) {
+  return new SlotsBuffer(heap, next_buffer);
 }
 
 
 void SlotsBufferAllocator::DeallocateBuffer(SlotsBuffer* buffer) {
   delete buffer;
 }
 
 
 void SlotsBufferAllocator::DeallocateChain(SlotsBuffer** buffer_address) {
   SlotsBuffer* buffer = *buffer_address;
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal