Synchronize on concurrent slot buffer entries during migration.

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/heap/mark-compact.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
@@ skipping 2672 matching lines @@
   while (weak_cell_obj != Smi::FromInt(0)) {
     WeakCell* weak_cell = reinterpret_cast<WeakCell*>(weak_cell_obj);
     weak_cell_obj = weak_cell->next();
     weak_cell->clear_next(heap());
   }
   heap()->set_encountered_weak_cells(Smi::FromInt(0));
 }
 
 
 void MarkCompactCollector::RecordMigratedSlot(Object* value, Address slot) {
+  // When parallel compaction is in progress, store and slots buffer entries
+  // require synchronization.
   if (heap_->InNewSpace(value)) {
     if (parallel_compaction_in_progress_) {
       heap_->store_buffer()->MarkSynchronized(slot);
     } else {
       heap_->store_buffer()->Mark(slot);
     }
   } else if (value->IsHeapObject() && IsOnEvacuationCandidate(value)) {
+    if (parallel_compaction_in_progress_) {
+      SlotsBuffer::AddToSynchronized(
+          &slots_buffer_allocator_, &migration_slots_buffer_,
+          &migration_slots_buffer_mutex_, reinterpret_cast<Object**>(slot),
+          SlotsBuffer::IGNORE_OVERFLOW);
+    } else {
+      SlotsBuffer::AddTo(&slots_buffer_allocator_, &migration_slots_buffer_,
+                         reinterpret_cast<Object**>(slot),
+                         SlotsBuffer::IGNORE_OVERFLOW);
+    }
+  }
+}
+
+
+void MarkCompactCollector::RecordMigratedCodeEntrySlot(
+    Address code_entry, Address code_entry_slot) {
+  if (Page::FromAddress(code_entry)->IsEvacuationCandidate()) {
+    if (parallel_compaction_in_progress_) {
+      SlotsBuffer::AddToSynchronized(
+          &slots_buffer_allocator_, &migration_slots_buffer_,
+          &migration_slots_buffer_mutex_, SlotsBuffer::CODE_ENTRY_SLOT,
+          code_entry_slot, SlotsBuffer::IGNORE_OVERFLOW);
+    } else {
+      SlotsBuffer::AddTo(&slots_buffer_allocator_, &migration_slots_buffer_,
+                         SlotsBuffer::CODE_ENTRY_SLOT, code_entry_slot,
+                         SlotsBuffer::IGNORE_OVERFLOW);
+    }
+  }
+}
+
+
+void MarkCompactCollector::RecordMigratedCodeObjectSlot(Address code_object) {
+  if (parallel_compaction_in_progress_) {
+    SlotsBuffer::AddToSynchronized(
+        &slots_buffer_allocator_, &migration_slots_buffer_,
+        &migration_slots_buffer_mutex_, SlotsBuffer::RELOCATED_CODE_OBJECT,
+        code_object, SlotsBuffer::IGNORE_OVERFLOW);
+  } else {
     SlotsBuffer::AddTo(&slots_buffer_allocator_, &migration_slots_buffer_,
-                       reinterpret_cast<Object**>(slot),
+                       SlotsBuffer::RELOCATED_CODE_OBJECT, code_object,
                        SlotsBuffer::IGNORE_OVERFLOW);
   }
 }
 
 
 // We scavenge new space simultaneously with sweeping. This is done in two
 // passes.
 //
 // The first pass migrates all alive objects from one semispace to another or
 // promotes them to old space.  Forwarding address is written directly into
@@ skipping 24 matching lines @@
         break;
 
       case HeapObjectContents::kRawValues:
         MigrateObjectRaw(dst, src, size);
         break;
     }
 
     if (compacting_ && dst->IsJSFunction()) {
       Address code_entry_slot = dst->address() + JSFunction::kCodeEntryOffset;
       Address code_entry = Memory::Address_at(code_entry_slot);
-
-      if (Page::FromAddress(code_entry)->IsEvacuationCandidate()) {
-        SlotsBuffer::AddTo(&slots_buffer_allocator_, &migration_slots_buffer_,
-                           SlotsBuffer::CODE_ENTRY_SLOT, code_entry_slot,
-                           SlotsBuffer::IGNORE_OVERFLOW);
-      }
+      RecordMigratedCodeEntrySlot(code_entry, code_entry_slot);
     }
   } else if (dest == CODE_SPACE) {
     PROFILE(isolate(), CodeMoveEvent(src_addr, dst_addr));
     heap()->MoveBlock(dst_addr, src_addr, size);
-    SlotsBuffer::AddTo(&slots_buffer_allocator_, &migration_slots_buffer_,
-                       SlotsBuffer::RELOCATED_CODE_OBJECT, dst_addr,
-                       SlotsBuffer::IGNORE_OVERFLOW);
+    RecordMigratedCodeObjectSlot(dst_addr);
     Code::cast(dst)->Relocate(dst_addr - src_addr);
   } else {
     DCHECK(dest == NEW_SPACE);
     heap()->MoveBlock(dst_addr, src_addr, size);
   }
   heap()->OnMoveEvent(dst, src, size);
   Memory::Address_at(src_addr) = dst_addr;
 }
 
 
@@ skipping 1711 matching lines @@
   MarkCompactMarkingVisitor::Initialize();
   IncrementalMarking::Initialize();
 }
 
 
 bool SlotsBuffer::IsTypedSlot(ObjectSlot slot) {
   return reinterpret_cast<uintptr_t>(slot) < NUMBER_OF_SLOT_TYPES;
 }
 
 
+bool SlotsBuffer::AddToSynchronized(SlotsBufferAllocator* allocator,
+                                    SlotsBuffer** buffer_address,
+                                    base::Mutex* buffer_mutex, SlotType type,
+                                    Address addr, AdditionMode mode) {
+  base::LockGuard<base::Mutex> lock_guard(buffer_mutex);
+  return AddTo(allocator, buffer_address, type, addr, mode);
+}
+
+
 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);
@@ skipping 251 matching lines @@
   SlotsBuffer* buffer = *buffer_address;
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 }  // namespace internal
 }  // namespace v8