[heap] Fine-grained JSArrayBuffer tracking

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/base/sys-info.h"
 #include "src/code-stubs.h"
@@ skipping 1657 matching lines @@
     heap_->UpdateAllocationSite<Heap::kCached>(object,
                                                local_pretenuring_feedback_);
     int size = object->Size();
     HeapObject* target_object = nullptr;
     if (heap_->ShouldBePromoted(object->address(), size) &&
         TryEvacuateObject(compaction_spaces_->Get(OLD_SPACE), object,
                           &target_object)) {
       // If we end up needing more special cases, we should factor this out.
       if (V8_UNLIKELY(target_object->IsJSArrayBuffer())) {
         heap_->array_buffer_tracker()->Promote(
-            JSArrayBuffer::cast(target_object));
+            JSArrayBuffer::cast(target_object),
+            reinterpret_cast<JSArrayBuffer*>(object));
       }
       promoted_size_ += size;
       return true;
     }
     HeapObject* target = nullptr;
     AllocationSpace space = AllocateTargetObject(object, &target);
     MigrateObject(HeapObject::cast(target), object, size, space);
     if (V8_UNLIKELY(target->IsJSArrayBuffer())) {
-      heap_->array_buffer_tracker()->MarkLive(JSArrayBuffer::cast(target));
+      heap_->array_buffer_tracker()->SemiSpaceCopy(
+          JSArrayBuffer::cast(target),
+          reinterpret_cast<JSArrayBuffer*>(object));
     }
     semispace_copied_size_ += size;
     return true;
   }
 
   intptr_t promoted_size() { return promoted_size_; }
   intptr_t semispace_copied_size() { return semispace_copied_size_; }
 
  private:
   enum NewSpaceAllocationMode {
@@ skipping 106 matching lines @@
   static void TryMoveToOldSpace(Page* page, PagedSpace* owner) {
     if (page->heap()->new_space()->ReplaceWithEmptyPage(page)) {
       Page* new_page = Page::ConvertNewToOld(page, owner);
       new_page->SetFlag(Page::PAGE_NEW_OLD_PROMOTION);
     }
   }
 
   inline bool Visit(HeapObject* object) {
     if (V8_UNLIKELY(object->IsJSArrayBuffer())) {
       object->GetHeap()->array_buffer_tracker()->Promote(
-          JSArrayBuffer::cast(object));
+          JSArrayBuffer::cast(object), JSArrayBuffer::cast(object));
     }
     RecordMigratedSlotVisitor visitor;
     object->IterateBodyFast(&visitor);
     promoted_size_ += object->Size();
     return true;
   }
 
   intptr_t promoted_size() { return promoted_size_; }
 
  private:
   intptr_t promoted_size_;
 };
 
 class MarkCompactCollector::EvacuateOldSpaceVisitor final
     : public MarkCompactCollector::EvacuateVisitorBase {
  public:
   EvacuateOldSpaceVisitor(Heap* heap,
                           CompactionSpaceCollection* compaction_spaces)
       : EvacuateVisitorBase(heap, compaction_spaces) {}
 
   inline bool Visit(HeapObject* object) override {
     CompactionSpace* target_space = compaction_spaces_->Get(
         Page::FromAddress(object->address())->owner()->identity());
     HeapObject* target_object = nullptr;
     if (TryEvacuateObject(target_space, object, &target_object)) {
       DCHECK(object->map_word().IsForwardingAddress());
+      if (V8_UNLIKELY(target_object->IsJSArrayBuffer())) {
+        heap_->array_buffer_tracker()->Compact(
+            JSArrayBuffer::cast(target_object),
+            reinterpret_cast<JSArrayBuffer*>(object));
+      }
       return true;
     }
+    if (V8_UNLIKELY(object->IsJSArrayBuffer())) {
+      heap_->array_buffer_tracker()->MarkLive(JSArrayBuffer::cast(object));

[Hannes Payer (out of office), 2016/05/11 11:12:34]

Why do you need to mark it as live in the evacuation visitor? This should have
been marked live by the marker.

[Michael Lippautz, 2016/05/11 18:43:26]

You are right, done.

+    }
     return false;
   }
 };
 
 class MarkCompactCollector::EvacuateRecordOnlyVisitor final
     : public MarkCompactCollector::HeapObjectVisitor {
  public:
-  explicit EvacuateRecordOnlyVisitor(AllocationSpace space) : space_(space) {}
+  explicit EvacuateRecordOnlyVisitor(Heap* heap, AllocationSpace space)
+      : heap_(heap), space_(space) {}
 
   inline bool Visit(HeapObject* object) {
     if (space_ == OLD_SPACE) {
       RecordMigratedSlotVisitor visitor;
       object->IterateBody(&visitor);
+      if (V8_UNLIKELY(object->IsJSArrayBuffer())) {
+        heap_->array_buffer_tracker()->MarkLive(JSArrayBuffer::cast(object));
+      }
     } else {
       DCHECK_EQ(space_, CODE_SPACE);
       // Add a typed slot for the whole code object.
       RememberedSet<OLD_TO_OLD>::InsertTyped(
           Page::FromAddress(object->address()), RELOCATED_CODE_OBJECT,
           object->address());
     }
     return true;
   }
 
  private:
+  Heap* heap_;
   AllocationSpace space_;
 };
 
 void MarkCompactCollector::DiscoverGreyObjectsInSpace(PagedSpace* space) {
   PageIterator it(space);
   while (it.has_next()) {
     Page* p = it.next();
     if (!p->IsFlagSet(Page::BLACK_PAGE)) {
       DiscoverGreyObjectsOnPage(p);
     }
@@ skipping 1288 matching lines @@
     case kPageNewToOld:
       result = EvacuateSinglePage<kKeepMarking>(page, &new_space_page_visitor);
       DCHECK(result);
       USE(result);
       break;
     case kObjectsOldToOld:
       result = EvacuateSinglePage<kClearMarkbits>(page, &old_space_visitor_);
       if (!result) {
         // Aborted compaction page. We can record slots here to have them
         // processed in parallel later on.
-        EvacuateRecordOnlyVisitor record_visitor(page->owner()->identity());
+        EvacuateRecordOnlyVisitor record_visitor(page->heap(),
+                                                 page->owner()->identity());
         result = EvacuateSinglePage<kKeepMarking>(page, &record_visitor);
         DCHECK(result);
         USE(result);
         // We need to return failure here to indicate that we want this page
         // added to the sweeper.
         return false;
       }
       break;
     default:
       UNREACHABLE();
@@ skipping 222 matching lines @@
   Bitmap::Clear(p);
 
   if (free_start != p->area_end()) {
     int size = static_cast<int>(p->area_end() - free_start);
     if (free_space_mode == ZAP_FREE_SPACE) {
       memset(free_start, 0xcc, size);
     }
     freed_bytes = space->UnaccountedFree(free_start, size);
     max_freed_bytes = Max(freed_bytes, max_freed_bytes);
   }
+  p->FreeDeadArraybuffersAndResetTracker();
   p->concurrent_sweeping_state().SetValue(Page::kSweepingDone);
   return FreeList::GuaranteedAllocatable(static_cast<int>(max_freed_bytes));
 }
 
 void MarkCompactCollector::InvalidateCode(Code* code) {
   if (heap_->incremental_marking()->IsCompacting() &&
       !ShouldSkipEvacuationSlotRecording(code)) {
     DCHECK(compacting_);
 
     // If the object is white than no slots were recorded on it yet.
@@ skipping 122 matching lines @@
       // 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();
       if (list != NULL) list->Clear();
       if (p->IsFlagSet(Page::COMPACTION_WAS_ABORTED)) {
         sweeper().AddLatePage(p->owner()->identity(), p);
         p->ClearFlag(Page::COMPACTION_WAS_ABORTED);
       }
     }
 
-    // EvacuateNewSpaceAndCandidates iterates over new space objects and for
-    // ArrayBuffers either re-registers them as live or promotes them. This is
-    // needed to properly free them.
-    heap()->array_buffer_tracker()->FreeDead(false);
+    // Free up backing stores for arrays buffers that died in new space in this
+    // cycle.
+    heap()->array_buffer_tracker()->FreeDeadInNewSpace();

[Hannes Payer (out of office), 2016/05/11 11:12:34]

Aborted once will be swept after compaction and
FreeDeadArraybuffersAndResetTracker will be called there again.

Why don't we move it to the compaction tasks? They can do the freeing in
parallel if evacuation succeeded. Otherwise the sweeper will take care of that.

[Michael Lippautz, 2016/05/11 18:43:26]

1) This call is about new space pages
2) "FreeDeadArraybuffersAndResetTracker" does 2 things:
  a) it frees dead backings stores
  b) it resets the sets for the next round

We have to be careful to not call  FreeDeadArraybuffersAndResetTracker twice
without marking inbetween. That's the reason this calls are spread out in a way
that we call it only 1x for each page.

 
     // Deallocate evacuated candidate pages.
     ReleaseEvacuationCandidates();
   }
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap && !sweeper().sweeping_in_progress()) {
     VerifyEvacuation(heap());
   }
 #endif
@@ skipping 249 matching lines @@
   PageIterator it(space);
 
   int will_be_swept = 0;
   bool unused_page_present = false;
 
   while (it.has_next()) {
     Page* p = it.next();
     DCHECK(p->SweepingDone());
 
     if (p->IsEvacuationCandidate()) {
+      p->FreeDeadArraybuffersAndResetTracker();
       // Will be processed in EvacuateNewSpaceAndCandidates.
       DCHECK(evacuation_candidates_.length() > 0);
       continue;
     }
 
     // We can not sweep black pages, since all mark bits are set for these
     // pages.
     if (p->IsFlagSet(Page::BLACK_PAGE)) {
+      p->FreeDeadArraybuffersAndResetTracker();

[Hannes Payer (out of office), 2016/05/11 11:12:34]

There will be no dead array buffers on a black page.

[Michael Lippautz, 2016/05/11 18:43:26]

True, but we need the "*AndResetTracker" part of the function. Otherwise we
would lag 1 GC behind with black pages, increasing floating garbage.

       Bitmap::Clear(p);
       p->concurrent_sweeping_state().SetValue(Page::kSweepingDone);
       p->ClearFlag(Page::BLACK_PAGE);
       // TODO(hpayer): Free unused memory of last black page.
       continue;
     }
 
     if (p->IsFlagSet(Page::NEVER_ALLOCATE_ON_PAGE)) {
       // We need to sweep the page to get it into an iterable state again. Note
       // that this adds unusable memory into the free list that is later on
@@ skipping 96 matching lines @@
     MarkBit mark_bit = Marking::MarkBitFrom(host);
     if (Marking::IsBlack(mark_bit)) {
       RelocInfo rinfo(isolate(), pc, RelocInfo::CODE_TARGET, 0, host);
       RecordRelocSlot(host, &rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8