[heap] introduce ArrayBufferTracker

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"
 #include "src/cpu-profiler.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
 #include "src/frames-inl.h"
 #include "src/gdb-jit.h"
 #include "src/global-handles.h"
+#include "src/heap/array-buffer-tracker.h"
 #include "src/heap/gc-tracer.h"
 #include "src/heap/incremental-marking.h"
 #include "src/heap/mark-compact-inl.h"
 #include "src/heap/object-stats.h"
 #include "src/heap/objects-visiting.h"
 #include "src/heap/objects-visiting-inl.h"
 #include "src/heap/spaces-inl.h"
 #include "src/heap-profiler.h"
 #include "src/ic/ic.h"
 #include "src/ic/stub-cache.h"
@@ skipping 1837 matching lines @@
           // always room.
           UNREACHABLE();
         }
         allocation = new_space->AllocateRaw(size, alignment);
         DCHECK(!allocation.IsRetry());
       }
       Object* target = allocation.ToObjectChecked();
 
       MigrateObject(HeapObject::cast(target), object, size, NEW_SPACE);
       if (V8_UNLIKELY(target->IsJSArrayBuffer())) {
-        heap()->RegisterLiveArrayBuffer(
-            true, JSArrayBuffer::cast(target)->backing_store());
+        heap()->array_buffer_tracker()->MarkLive(JSArrayBuffer::cast(target));
       }
       heap()->IncrementSemiSpaceCopiedObjectSize(size);
     }
     *cells = 0;
   }
   return survivors_size;
 }
 
 
 void MarkCompactCollector::DiscoverGreyObjectsInSpace(PagedSpace* space) {
@@ skipping 1205 matching lines @@
 
   OldSpace* old_space = heap()->old_space();
 
   HeapObject* target;
   AllocationAlignment alignment = object->RequiredAlignment();
   AllocationResult allocation = old_space->AllocateRaw(object_size, alignment);
   if (allocation.To(&target)) {
     MigrateObject(target, object, object_size, old_space->identity());
     // If we end up needing more special cases, we should factor this out.
     if (V8_UNLIKELY(target->IsJSArrayBuffer())) {
-      heap()->PromoteArrayBuffer(target);
+      heap()->array_buffer_tracker()->Promote(JSArrayBuffer::cast(target));
     }
     heap()->IncrementPromotedObjectsSize(object_size);
     return true;
   }
 
   return false;
 }
 
 
 bool MarkCompactCollector::IsSlotInBlackObject(Page* p, Address slot,
@@ skipping 1324 matching lines @@
 
   // Give pages that are queued to be freed back to the OS. Invalid store
   // buffer entries are already filter out. We can just release the memory.
   heap()->FreeQueuedChunks();
 
   EvacuateNewSpaceAndCandidates();
 
   // 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()->FreeDeadArrayBuffers(false);
+  heap()->array_buffer_tracker()->FreeDead(false);
 
   // Clear the marking state of live large objects.
   heap_->lo_space()->ClearMarkingStateOfLiveObjects();
 
   // Deallocate evacuated candidate pages.
   ReleaseEvacuationCandidates();
   CodeRange* code_range = heap()->isolate()->code_range();
   if (code_range != NULL && code_range->valid()) {
     code_range->ReserveEmergencyBlock();
   }
@@ skipping 359 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