SelectScavengingVisitorsTable();
- PrepareArrayBufferDiscoveryInNewSpace();
-
// Flip the semispaces. After flipping, to space is empty, from space has
// live objects.
new_space_.Flip();
new_space_.LowerInlineAllocationLimit(
new_space_.inline_allocation_limit_step());
- FreeDeadArrayBuffers(true);
-
// Update how much has survived scavenge.
IncrementYoungSurvivorsCounter(static_cast<int>(
(PromotedSpaceSizeOfObjects() - survived_watermark) + new_space_.Size()));
}
-void Heap::RegisterNewArrayBufferHelper(std::map<void*, size_t>& live_buffers,
- void* data, size_t length) {
- live_buffers[data] = length;
-}
-
-
-void Heap::UnregisterArrayBufferHelper(
- std::map<void*, size_t>& live_buffers,
- std::map<void*, size_t>& not_yet_discovered_buffers, void* data) {
- DCHECK(live_buffers.count(data) > 0);
- live_buffers.erase(data);
- not_yet_discovered_buffers.erase(data);
-}
-
-
-void Heap::RegisterLiveArrayBufferHelper(
- std::map<void*, size_t>& not_yet_discovered_buffers, void* data) {
- not_yet_discovered_buffers.erase(data);
-}
-
-
-size_t Heap::FreeDeadArrayBuffersHelper(
- Isolate* isolate, std::map<void*, size_t>& live_buffers,
- std::map<void*, size_t>& not_yet_discovered_buffers) {
- size_t freed_memory = 0;
- for (auto buffer = not_yet_discovered_buffers.begin();
- buffer != not_yet_discovered_buffers.end(); ++buffer) {
- isolate->array_buffer_allocator()->Free(buffer->first, buffer->second);
- freed_memory += buffer->second;
- live_buffers.erase(buffer->first);
- }
- not_yet_discovered_buffers = live_buffers;
- return freed_memory;
-}
-
-
-void Heap::TearDownArrayBuffersHelper(
- Isolate* isolate, std::map<void*, size_t>& live_buffers,
- std::map<void*, size_t>& not_yet_discovered_buffers) {
- for (auto buffer = live_buffers.begin(); buffer != live_buffers.end();
- ++buffer) {
- isolate->array_buffer_allocator()->Free(buffer->first, buffer->second);
- }
- live_buffers.clear();
- not_yet_discovered_buffers.clear();
-}
-
-
-void Heap::RegisterNewArrayBuffer(bool in_new_space, void* data,
- size_t length) {
+void Heap::RegisterNewArrayBuffer(void* data, size_t length) {
if (!data) return;
- RegisterNewArrayBufferHelper(
- in_new_space ? live_new_array_buffers_ : live_array_buffers_, data,
- length);
+ live_array_buffers_[data] = length;
reinterpret_cast<v8::Isolate*>(isolate_)
->AdjustAmountOfExternalAllocatedMemory(length);
}
-void Heap::UnregisterArrayBuffer(bool in_new_space, void* data) {
+void Heap::UnregisterArrayBuffer(void* data) {
if (!data) return;
- UnregisterArrayBufferHelper(
- in_new_space ? live_new_array_buffers_ : live_array_buffers_,
- in_new_space ? not_yet_discovered_new_array_buffers_
- : not_yet_discovered_array_buffers_,
- data);
+ DCHECK(live_array_buffers_.count(data) > 0);
+ live_array_buffers_.erase(data);
+ not_yet_discovered_array_buffers_.erase(data);
}
-void Heap::RegisterLiveArrayBuffer(bool in_new_space, void* data) {
- RegisterLiveArrayBufferHelper(in_new_space
- ? not_yet_discovered_new_array_buffers_
- : not_yet_discovered_array_buffers_,
- data);
+void Heap::RegisterLiveArrayBuffer(void* data) {
+ not_yet_discovered_array_buffers_.erase(data);
}
-void Heap::FreeDeadArrayBuffers(bool in_new_space) {
- size_t freed_memory = FreeDeadArrayBuffersHelper(
- isolate_, in_new_space ? live_new_array_buffers_ : live_array_buffers_,
- in_new_space ? not_yet_discovered_new_array_buffers_
- : not_yet_discovered_array_buffers_);
- if (freed_memory) {
- reinterpret_cast<v8::Isolate*>(isolate_)
- ->AdjustAmountOfExternalAllocatedMemory(
- -static_cast<int64_t>(freed_memory));
+void Heap::FreeDeadArrayBuffers() {
+ for (auto buffer = not_yet_discovered_array_buffers_.begin();
+ buffer != not_yet_discovered_array_buffers_.end(); ++buffer) {
+ isolate_->array_buffer_allocator()->Free(buffer->first, buffer->second);
+ // Don't use the API method here since this could trigger another GC.
+ amount_of_external_allocated_memory_ -= buffer->second;
+ live_array_buffers_.erase(buffer->first);
}
+ not_yet_discovered_array_buffers_ = live_array_buffers_;
}
void Heap::TearDownArrayBuffers() {
- TearDownArrayBuffersHelper(isolate_, live_array_buffers_,
- not_yet_discovered_array_buffers_);
- TearDownArrayBuffersHelper(isolate_, live_new_array_buffers_,
- not_yet_discovered_new_array_buffers_);
-}
-
-
-void Heap::PrepareArrayBufferDiscoveryInNewSpace() {
- not_yet_discovered_new_array_buffers_ = live_new_array_buffers_;
-}
-
-
-void Heap::PromoteArrayBuffer(Object* obj) {
- JSArrayBuffer* buffer = JSArrayBuffer::cast(obj);
- if (buffer->is_external()) return;
- void* data = buffer->backing_store();
- if (!data) return;
- DCHECK(live_new_array_buffers_.count(data) > 0);
- live_array_buffers_[data] = live_new_array_buffers_[data];
- live_new_array_buffers_.erase(data);
- not_yet_discovered_new_array_buffers_.erase(data);
+ for (auto buffer = live_array_buffers_.begin();
+ buffer != live_array_buffers_.end(); ++buffer) {
+ isolate_->array_buffer_allocator()->Free(buffer->first, buffer->second);
+ }
+ live_array_buffers_.clear();
+ not_yet_discovered_array_buffers_.clear();
}
table_.Register(kVisitFixedDoubleArray, &EvacuateFixedDoubleArray);
table_.Register(kVisitFixedTypedArray, &EvacuateFixedTypedArray);
table_.Register(kVisitFixedFloat64Array, &EvacuateFixedFloat64Array);
- table_.Register(kVisitJSArrayBuffer, &EvacuateJSArrayBuffer);
table_.Register(
kVisitNativeContext,
table_.Register(kVisitJSWeakCollection,
&ObjectEvacuationStrategy<POINTER_OBJECT>::Visit);
+ table_.Register(kVisitJSArrayBuffer,
+ &ObjectEvacuationStrategy<POINTER_OBJECT>::Visit);
+
table_.Register(kVisitJSTypedArray,
&ObjectEvacuationStrategy<POINTER_OBJECT>::Visit);
}
- static inline void EvacuateJSArrayBuffer(Map* map, HeapObject** slot,
- HeapObject* object) {
- ObjectEvacuationStrategy<POINTER_OBJECT>::Visit(map, slot, object);
-
- Heap* heap = map->GetHeap();
- MapWord map_word = object->map_word();
- DCHECK(map_word.IsForwardingAddress());
- HeapObject* target = map_word.ToForwardingAddress();
- if (!heap->InNewSpace(target)) heap->PromoteArrayBuffer(target);
- }
-
-
static inline void EvacuateByteArray(Map* map, HeapObject** slot,
HeapObject* object) {
int object_size = reinterpret_cast<ByteArray*>(object)->ByteArraySize();
bool deserialization_complete() const { return deserialization_complete_; }
- // The following methods are used to track raw C++ pointers to externally
- // allocated memory used as backing store in live array buffers.
-
- // A new ArrayBuffer was created with |data| as backing store.
- void RegisterNewArrayBuffer(bool in_new_space, void* data, size_t length);
-
- // The backing store |data| is no longer owned by V8.
- void UnregisterArrayBuffer(bool in_new_space, void* data);
-
- // A live ArrayBuffer was discovered during marking/scavenge.
- void RegisterLiveArrayBuffer(bool in_new_space, void* data);
-
- // Frees all backing store pointers that weren't discovered in the previous
- // marking or scavenge phase.
- void FreeDeadArrayBuffers(bool in_new_space);
-
- // Prepare for a new scavenge phase. A new marking phase is implicitly
- // prepared by finishing the previous one.
- void PrepareArrayBufferDiscoveryInNewSpace();
-
- // An ArrayBuffer moved from new space to old space.
- void PromoteArrayBuffer(Object* buffer);
+ void RegisterNewArrayBuffer(void* data, size_t length);
+ void UnregisterArrayBuffer(void* data);
+ void RegisterLiveArrayBuffer(void* data);
+ void FreeDeadArrayBuffers();
protected:
// Methods made available to tests.
// the old space.
void EvaluateOldSpaceLocalPretenuring(uint64_t size_of_objects_before_gc);
- // Called on heap tear-down. Frees all remaining ArrayBuffer backing stores.
+ // Called on heap tear-down.
void TearDownArrayBuffers();
- // These correspond to the non-Helper versions.
- void RegisterNewArrayBufferHelper(std::map<void*, size_t>& live_buffers,
- void* data, size_t length);
- void UnregisterArrayBufferHelper(
- std::map<void*, size_t>& live_buffers,
- std::map<void*, size_t>& not_yet_discovered_buffers, void* data);
- void RegisterLiveArrayBufferHelper(
- std::map<void*, size_t>& not_yet_discovered_buffers, void* data);
- size_t FreeDeadArrayBuffersHelper(
- Isolate* isolate, std::map<void*, size_t>& live_buffers,
- std::map<void*, size_t>& not_yet_discovered_buffers);
- void TearDownArrayBuffersHelper(
- Isolate* isolate, std::map<void*, size_t>& live_buffers,
- std::map<void*, size_t>& not_yet_discovered_buffers);
-
// Record statistics before and after garbage collection.
void ReportStatisticsBeforeGC();
void ReportStatisticsAfterGC();
bool concurrent_sweeping_enabled_;
std::map<void*, size_t> live_array_buffers_;
- std::map<void*, size_t> live_new_array_buffers_;
std::map<void*, size_t> not_yet_discovered_array_buffers_;
- std::map<void*, size_t> not_yet_discovered_new_array_buffers_;
struct StrongRootsList;
StrongRootsList* strong_roots_list_;
projects / platform / upstream / v8.git / commitdiff