Untangle slots buffer part 1: Make invalid slots filtering part of MarkCompactCollector.

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 272 matching lines @@
   return compacting_;
 }
 
 
 void MarkCompactCollector::ClearInvalidStoreAndSlotsBufferEntries() {
   heap_->store_buffer()->ClearInvalidStoreBufferEntries();
 
   int number_of_pages = evacuation_candidates_.length();
   for (int i = 0; i < number_of_pages; i++) {
     Page* p = evacuation_candidates_[i];
-    SlotsBuffer::RemoveInvalidSlots(heap_, p->slots_buffer());
+    ClearInvalidSlotsBufferEntries(p->slots_buffer());
+  }
+}
+
+
+void MarkCompactCollector::ClearInvalidSlotsBufferEntries(SlotsBuffer* buffer) {
+  // Remove entries by replacing them with an old-space slot containing a smi
+  // that is located in an unmovable page.
+  const SlotsBuffer::ObjectSlot kRemovedEntry = HeapObject::RawField(
+      heap_->empty_fixed_array(), FixedArrayBase::kLengthOffset);
+  DCHECK(Page::FromAddress(reinterpret_cast<Address>(kRemovedEntry))
+             ->NeverEvacuate());
+
+  while (buffer != NULL) {
+    for (int slot_idx = 0; slot_idx < buffer->Size(); ++slot_idx) {
+      SlotsBuffer::ObjectSlot slot = buffer->Get(slot_idx);
+      if (!SlotsBuffer::IsTypedSlot(slot)) {
+        Object* object = *slot;
+        if ((object->IsHeapObject() && heap_->InNewSpace(object)) ||
+            !heap_->mark_compact_collector()->IsSlotInLiveObject(
+                reinterpret_cast<Address>(slot))) {
+          buffer->Set(slot_idx, kRemovedEntry);
+        }
+      } else {
+        ++slot_idx;
+        DCHECK(slot_idx < buffer->Size());
+      }
+    }
+    buffer = buffer->next();
   }
 }
 
 
 #ifdef VERIFY_HEAP
+void VerifySlots(Heap* heap, SlotsBuffer* buffer) {
+  while (buffer != NULL) {
+    for (int slot_idx = 0; slot_idx < buffer->Size(); ++slot_idx) {
+      SlotsBuffer::ObjectSlot slot = buffer->Get(slot_idx);
+      if (!SlotsBuffer::IsTypedSlot(slot)) {
+        Object* object = *slot;
+        if (object->IsHeapObject()) {
+          HeapObject* heap_object = HeapObject::cast(object);
+          CHECK(!heap->InNewSpace(object));
+          heap->mark_compact_collector()->VerifyIsSlotInLiveObject(
+              reinterpret_cast<Address>(slot), heap_object);
+        }
+      } else {
+        ++slot_idx;
+        DCHECK(slot_idx < buffer->Size());
+      }
+    }
+    buffer = buffer->next();
+  }
+}
+
+
 static void VerifyValidSlotsBufferEntries(Heap* heap, PagedSpace* space) {
   PageIterator it(space);
   while (it.has_next()) {
     Page* p = it.next();
-    SlotsBuffer::VerifySlots(heap, p->slots_buffer());
+    VerifySlots(heap, p->slots_buffer());
   }
 }
 
 
 static void VerifyValidStoreAndSlotsBufferEntries(Heap* heap) {
   heap->store_buffer()->VerifyValidStoreBufferEntries();
 
   VerifyValidSlotsBufferEntries(heap, heap->old_space());
   VerifyValidSlotsBufferEntries(heap, heap->code_space());
   VerifyValidSlotsBufferEntries(heap, heap->map_space());
-
-  LargeObjectIterator it(heap->lo_space());

[Michael Lippautz, 2015/08/18 09:22:05]

\o/

-  for (HeapObject* object = it.Next(); object != NULL; object = it.Next()) {
-    MemoryChunk* chunk = MemoryChunk::FromAddress(object->address());
-    SlotsBuffer::VerifySlots(heap, chunk->slots_buffer());
-  }
 }
 #endif
 
 
 void MarkCompactCollector::CollectGarbage() {
   // Make sure that Prepare() has been called. The individual steps below will
   // update the state as they proceed.
   DCHECK(state_ == PREPARE_GC);
 
   MarkLiveObjects();
@@ skipping 4131 matching lines @@
     buffer = allocator->AllocateBuffer(buffer);
     *buffer_address = buffer;
   }
   DCHECK(buffer->HasSpaceForTypedSlot());
   buffer->Add(reinterpret_cast<ObjectSlot>(type));
   buffer->Add(reinterpret_cast<ObjectSlot>(addr));
   return true;
 }
 
 
-void SlotsBuffer::RemoveInvalidSlots(Heap* heap, SlotsBuffer* buffer) {
-  // Remove entries by replacing them with an old-space slot containing a smi
-  // that is located in an unmovable page.
-  const ObjectSlot kRemovedEntry = HeapObject::RawField(
-      heap->empty_fixed_array(), FixedArrayBase::kLengthOffset);
-  DCHECK(Page::FromAddress(reinterpret_cast<Address>(kRemovedEntry))
-             ->NeverEvacuate());
-
-  while (buffer != NULL) {
-    SlotsBuffer::ObjectSlot* slots = buffer->slots_;
-    intptr_t slots_count = buffer->idx_;
-
-    for (int slot_idx = 0; slot_idx < slots_count; ++slot_idx) {
-      ObjectSlot slot = slots[slot_idx];
-      if (!IsTypedSlot(slot)) {
-        Object* object = *slot;
-        if ((object->IsHeapObject() && heap->InNewSpace(object)) ||
-            !heap->mark_compact_collector()->IsSlotInLiveObject(
-                reinterpret_cast<Address>(slot))) {
-          slots[slot_idx] = kRemovedEntry;
-        }
-      } else {
-        ++slot_idx;
-        DCHECK(slot_idx < slots_count);
-      }
-    }
-    buffer = buffer->next();
-  }
-}
-
-
 void SlotsBuffer::RemoveObjectSlots(Heap* heap, SlotsBuffer* buffer,
                                     Address start_slot, Address end_slot) {
   // Remove entries by replacing them with an old-space slot containing a smi
   // that is located in an unmovable page.
   const ObjectSlot kRemovedEntry = HeapObject::RawField(
       heap->empty_fixed_array(), FixedArrayBase::kLengthOffset);
   DCHECK(Page::FromAddress(reinterpret_cast<Address>(kRemovedEntry))
              ->NeverEvacuate());
 
   while (buffer != NULL) {
@@ skipping 15 matching lines @@
       } else {
         is_typed_slot = true;
         DCHECK(slot_idx < slots_count);
       }
     }
     buffer = buffer->next();
   }
 }
 
 
-void SlotsBuffer::VerifySlots(Heap* heap, SlotsBuffer* buffer) {
-  while (buffer != NULL) {
-    SlotsBuffer::ObjectSlot* slots = buffer->slots_;
-    intptr_t slots_count = buffer->idx_;
-
-    for (int slot_idx = 0; slot_idx < slots_count; ++slot_idx) {
-      ObjectSlot slot = slots[slot_idx];
-      if (!IsTypedSlot(slot)) {
-        Object* object = *slot;
-        if (object->IsHeapObject()) {
-          HeapObject* heap_object = HeapObject::cast(object);
-          CHECK(!heap->InNewSpace(object));
-          heap->mark_compact_collector()->VerifyIsSlotInLiveObject(
-              reinterpret_cast<Address>(slot), heap_object);
-        }
-      } else {
-        ++slot_idx;
-        DCHECK(slot_idx < slots_count);
-      }
-    }
-    buffer = buffer->next();
-  }
-}
-
-
 static inline SlotsBuffer::SlotType SlotTypeForRMode(RelocInfo::Mode rmode) {
   if (RelocInfo::IsCodeTarget(rmode)) {
     return SlotsBuffer::CODE_TARGET_SLOT;
   } else if (RelocInfo::IsCell(rmode)) {
     return SlotsBuffer::CELL_TARGET_SLOT;
   } else if (RelocInfo::IsEmbeddedObject(rmode)) {
     return SlotsBuffer::EMBEDDED_OBJECT_SLOT;
   } else if (RelocInfo::IsDebugBreakSlot(rmode)) {
     return SlotsBuffer::DEBUG_TARGET_SLOT;
   }
@@ skipping 141 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