[heap] Improve size profiling for ArrayBuffer 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 808 matching lines @@
   // marking cycle. We did not collect any slots.
   if (!FLAG_never_compact && !was_marked_incrementally_) {
     StartCompaction(NON_INCREMENTAL_COMPACTION);
   }
 
   PagedSpaces spaces(heap());
   for (PagedSpace* space = spaces.next(); space != NULL;
        space = spaces.next()) {
     space->PrepareForMarkCompact();
   }
-  heap()->account_external_memory_concurrently_freed();
+  heap()->array_buffer_tracker()->AccountForConcurrentlyFreedMemory();
 
 #ifdef VERIFY_HEAP
   if (!was_marked_incrementally_ && FLAG_verify_heap) {
     VerifyMarkbitsAreClean();
   }
 #endif
 }
 
 
 void MarkCompactCollector::Finish() {
@@ skipping 2278 matching lines @@
   int saved_live_bytes = page->LiveBytes();
   double evacuation_time = 0.0;
   Heap* heap = page->heap();
   {
     AlwaysAllocateScope always_allocate(heap->isolate());
     TimedScope timed_scope(&evacuation_time);
     switch (ComputeEvacuationMode(page)) {
       case kObjectsNewToOld:
         success = collector_->VisitLiveObjects(page, &new_space_visitor_,
                                                kClearMarkbits);
-        ArrayBufferTracker::ProcessBuffers(
+
+        heap->array_buffer_tracker()->ProcessBuffers(
             page, ArrayBufferTracker::kUpdateForwardedRemoveOthers);
         DCHECK(success);
         break;
       case kPageNewToOld:
         success = collector_->VisitLiveObjects(page, &new_space_page_visitor,
                                                kKeepMarking);
         // ArrayBufferTracker will be updated during sweeping.
         DCHECK(success);
         break;
       case kPageNewToNew:
         new_space_page_visitor.account_semispace_copied(page->LiveBytes());
         // ArrayBufferTracker will be updated during sweeping.
         success = true;
         break;
       case kObjectsOldToOld:
         success = collector_->VisitLiveObjects(page, &old_space_visitor_,
                                                kClearMarkbits);
         if (!success) {
           // Aborted compaction page. We have to record slots here, since we
           // might not have recorded them in first place.
           // Note: We mark the page as aborted here to be able to record slots
           // for code objects in |RecordMigratedSlotVisitor|.
           page->SetFlag(Page::COMPACTION_WAS_ABORTED);
           EvacuateRecordOnlyVisitor record_visitor(collector_->heap());
           success =
               collector_->VisitLiveObjects(page, &record_visitor, kKeepMarking);
-          ArrayBufferTracker::ProcessBuffers(
+          heap->array_buffer_tracker()->ProcessBuffers(
               page, ArrayBufferTracker::kUpdateForwardedKeepOthers);
           DCHECK(success);
           // We need to return failure here to indicate that we want this page
           // added to the sweeper.
           success = false;
         } else {
-          ArrayBufferTracker::ProcessBuffers(
+          heap->array_buffer_tracker()->ProcessBuffers(
               page, ArrayBufferTracker::kUpdateForwardedRemoveOthers);
         }
         break;
       default:
         UNREACHABLE();
     }
   }
   ReportCompactionProgress(evacuation_time, saved_live_bytes);
   if (FLAG_trace_evacuation) {
     PrintIsolate(heap->isolate(),
@@ skipping 183 matching lines @@
     Page* p, FreeListRebuildingMode free_list_mode,
     FreeSpaceTreatmentMode free_space_mode) {
   Space* space = p->owner();
   DCHECK_NOT_NULL(space);
   DCHECK(free_list_mode == IGNORE_FREE_LIST || space->identity() == OLD_SPACE ||
          space->identity() == CODE_SPACE || space->identity() == MAP_SPACE);
   DCHECK(!p->IsEvacuationCandidate() && !p->SweepingDone());
 
   // Before we sweep objects on the page, we free dead array buffers which
   // requires valid mark bits.
-  ArrayBufferTracker::FreeDead(p);
+  p->heap()->array_buffer_tracker()->FreeDead(p);
 
   Address free_start = p->area_start();
   DCHECK(reinterpret_cast<intptr_t>(free_start) % (32 * kPointerSize) == 0);
 
   // If we use the skip list for code space pages, we have to lock the skip
   // list because it could be accessed concurrently by the runtime or the
   // deoptimizer.
   const bool rebuild_skip_list =
       space->identity() == CODE_SPACE && p->skip_list() != nullptr;
   SkipList* skip_list = p->skip_list();
@@ skipping 563 matching lines @@
       continue;
     }
 
     // One unused page is kept, all further are released before sweeping them.
     if (p->LiveBytes() == 0) {
       if (unused_page_present) {
         if (FLAG_gc_verbose) {
           PrintIsolate(isolate(), "sweeping: released page: %p",
                        static_cast<void*>(p));
         }
-        ArrayBufferTracker::FreeAll(p);
+        heap()->array_buffer_tracker()->FreeAll(p);
         space->ReleasePage(p);
         continue;
       }
       unused_page_present = true;
     }
 
     sweeper().AddPage(space->identity(), p);
     will_be_swept++;
   }
 
@@ skipping 77 matching lines @@
       // The target is always in old space, we don't have to record the slot in
       // the old-to-new remembered set.
       DCHECK(!heap()->InNewSpace(target));
       RecordRelocSlot(host, &rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8