Index: src/heap/array-buffer-tracker.cc |
diff --git a/src/heap/array-buffer-tracker.cc b/src/heap/array-buffer-tracker.cc |
index 456d9ceb2974e1cc66eabbc3910005c41bc865d4..6e389c1cbf6abe216c782bae30fedcba5b283443 100644 |
--- a/src/heap/array-buffer-tracker.cc |
+++ b/src/heap/array-buffer-tracker.cc |
@@ -3,185 +3,139 @@ |
// found in the LICENSE file. |
#include "src/heap/array-buffer-tracker.h" |
-#include "src/heap/array-buffer-tracker-inl.h" |
#include "src/heap/heap.h" |
#include "src/isolate.h" |
+#include "src/objects.h" |
#include "src/objects-inl.h" |
-#include "src/objects.h" |
#include "src/v8.h" |
namespace v8 { |
namespace internal { |
-LocalArrayBufferTracker::~LocalArrayBufferTracker() { |
+ArrayBufferTracker::~ArrayBufferTracker() { |
+ Isolate* isolate = heap()->isolate(); |
size_t freed_memory = 0; |
- for (auto& buffer : live_) { |
- heap_->isolate()->array_buffer_allocator()->Free(buffer.second.first, |
- buffer.second.second); |
- freed_memory += buffer.second.second; |
+ for (auto& buffer : live_array_buffers_) { |
+ isolate->array_buffer_allocator()->Free(buffer.first, buffer.second); |
+ freed_memory += buffer.second; |
} |
+ for (auto& buffer : live_array_buffers_for_scavenge_) { |
+ isolate->array_buffer_allocator()->Free(buffer.first, buffer.second); |
+ freed_memory += buffer.second; |
+ } |
+ live_array_buffers_.clear(); |
+ live_array_buffers_for_scavenge_.clear(); |
+ not_yet_discovered_array_buffers_.clear(); |
+ not_yet_discovered_array_buffers_for_scavenge_.clear(); |
+ |
if (freed_memory > 0) { |
- heap_->update_amount_of_external_allocated_freed_memory( |
- static_cast<intptr_t>(freed_memory)); |
- } |
- live_.clear(); |
- not_yet_discovered_.clear(); |
-} |
- |
-void LocalArrayBufferTracker::Add(Key key, const Value& value) { |
- live_[key] = value; |
- not_yet_discovered_[key] = value; |
-} |
- |
-void LocalArrayBufferTracker::AddLive(Key key, const Value& value) { |
- DCHECK_EQ(not_yet_discovered_.count(key), 0); |
- live_[key] = value; |
-} |
- |
-void LocalArrayBufferTracker::MarkLive(Key key) { |
- DCHECK_EQ(live_.count(key), 1); |
- not_yet_discovered_.erase(key); |
-} |
- |
-LocalArrayBufferTracker::Value LocalArrayBufferTracker::Remove(Key key) { |
- DCHECK_EQ(live_.count(key), 1); |
- Value value = live_[key]; |
- live_.erase(key); |
- not_yet_discovered_.erase(key); |
- return value; |
-} |
- |
-void LocalArrayBufferTracker::FreeDead() { |
- size_t freed_memory = 0; |
- for (TrackingMap::iterator it = not_yet_discovered_.begin(); |
- it != not_yet_discovered_.end();) { |
- heap_->isolate()->array_buffer_allocator()->Free(it->second.first, |
- it->second.second); |
- freed_memory += it->second.second; |
- live_.erase(it->first); |
- not_yet_discovered_.erase(it++); |
- } |
- if (freed_memory > 0) { |
- heap_->update_amount_of_external_allocated_freed_memory( |
- static_cast<intptr_t>(freed_memory)); |
- } |
- started_ = false; |
-} |
- |
-void LocalArrayBufferTracker::Reset() { |
- if (!started_) { |
- not_yet_discovered_ = live_; |
- started_ = true; |
+ heap()->update_amount_of_external_allocated_memory( |
+ -static_cast<int64_t>(freed_memory)); |
} |
} |
-bool LocalArrayBufferTracker::IsEmpty() { |
- return live_.empty() && not_yet_discovered_.empty(); |
-} |
-void ArrayBufferTracker::RegisterNew(Heap* heap, JSArrayBuffer* buffer) { |
+void ArrayBufferTracker::RegisterNew(JSArrayBuffer* buffer) { |
void* data = buffer->backing_store(); |
if (!data) return; |
- size_t length = NumberToSize(heap->isolate(), buffer->byte_length()); |
- Page* page = Page::FromAddress(buffer->address()); |
- LocalArrayBufferTracker* tracker = |
- page->local_tracker<Page::kCreateIfNotPresent>(); |
- DCHECK_NOT_NULL(tracker); |
- { |
- base::LockGuard<base::Mutex> guard(page->mutex()); |
- if (Marking::IsBlack(Marking::MarkBitFrom(buffer))) { |
- tracker->AddLive(buffer, std::make_pair(data, length)); |
- } else { |
- tracker->Add(buffer, std::make_pair(data, length)); |
- } |
+ bool in_new_space = heap()->InNewSpace(buffer); |
+ size_t length = NumberToSize(heap()->isolate(), buffer->byte_length()); |
+ if (in_new_space) { |
+ live_array_buffers_for_scavenge_[data] = length; |
+ } else { |
+ live_array_buffers_[data] = length; |
} |
+ |
// We may go over the limit of externally allocated memory here. We call the |
// api function to trigger a GC in this case. |
- reinterpret_cast<v8::Isolate*>(heap->isolate()) |
+ reinterpret_cast<v8::Isolate*>(heap()->isolate()) |
->AdjustAmountOfExternalAllocatedMemory(length); |
} |
-void ArrayBufferTracker::Unregister(Heap* heap, JSArrayBuffer* buffer) { |
+ |
+void ArrayBufferTracker::Unregister(JSArrayBuffer* buffer) { |
void* data = buffer->backing_store(); |
if (!data) return; |
- Page* page = Page::FromAddress(buffer->address()); |
- LocalArrayBufferTracker* tracker = page->local_tracker<Page::kDontCreate>(); |
- DCHECK_NOT_NULL(tracker); |
- size_t length = 0; |
- { |
- base::LockGuard<base::Mutex> guard(page->mutex()); |
- length = tracker->Remove(buffer).second; |
- } |
- heap->update_amount_of_external_allocated_memory( |
- -static_cast<intptr_t>(length)); |
+ bool in_new_space = heap()->InNewSpace(buffer); |
+ std::map<void*, size_t>* live_buffers = |
+ in_new_space ? &live_array_buffers_for_scavenge_ : &live_array_buffers_; |
+ std::map<void*, size_t>* not_yet_discovered_buffers = |
+ in_new_space ? ¬_yet_discovered_array_buffers_for_scavenge_ |
+ : ¬_yet_discovered_array_buffers_; |
+ |
+ DCHECK(live_buffers->count(data) > 0); |
+ |
+ size_t length = (*live_buffers)[data]; |
+ live_buffers->erase(data); |
+ not_yet_discovered_buffers->erase(data); |
+ |
+ heap()->update_amount_of_external_allocated_memory( |
+ -static_cast<int64_t>(length)); |
} |
-void ArrayBufferTracker::FreeDeadInNewSpace(Heap* heap) { |
- NewSpacePageIterator from_it(heap->new_space()->FromSpaceStart(), |
- heap->new_space()->FromSpaceEnd()); |
- while (from_it.has_next()) { |
- ScanAndFreeDeadArrayBuffers<LocalArrayBufferTracker::kForwardingPointer>( |
- from_it.next()); |
- } |
- heap->account_amount_of_external_allocated_freed_memory(); |
-} |
-void ArrayBufferTracker::ResetTrackersInOldSpace(Heap* heap) { |
- heap->old_space()->ForAllPages([](Page* p) { |
- LocalArrayBufferTracker* tracker = p->local_tracker<Page::kDontCreate>(); |
- if (tracker != nullptr) { |
- tracker->Reset(); |
- if (tracker->IsEmpty()) { |
- p->ReleaseLocalTracker(); |
- } |
- } |
- }); |
-} |
+void ArrayBufferTracker::MarkLive(JSArrayBuffer* buffer) { |
+ base::LockGuard<base::Mutex> guard(&mutex_); |
+ void* data = buffer->backing_store(); |
-void ArrayBufferTracker::MarkLive(Heap* heap, JSArrayBuffer* buffer) { |
- if (buffer->is_external()) return; |
- void* data = buffer->backing_store(); |
- if (data == nullptr) return; |
- if (data == heap->undefined_value()) return; |
- |
- Page* page = Page::FromAddress(buffer->address()); |
- LocalArrayBufferTracker* tracker = |
- page->local_tracker<Page::kCreateIfNotPresent>(); |
- DCHECK_NOT_NULL(tracker); |
- if (tracker->IsTracked(buffer)) { |
- base::LockGuard<base::Mutex> guard(page->mutex()); |
- tracker->MarkLive((buffer)); |
+ // ArrayBuffer might be in the middle of being constructed. |
+ if (data == heap()->undefined_value()) return; |
+ if (heap()->InNewSpace(buffer)) { |
+ not_yet_discovered_array_buffers_for_scavenge_.erase(data); |
} else { |
- RegisterNew(heap, buffer); |
+ not_yet_discovered_array_buffers_.erase(data); |
} |
} |
-void ArrayBufferTracker::FreeDead(Page* page) { |
- // Only called from the sweeper, which already holds the page lock. |
- LocalArrayBufferTracker* tracker = page->local_tracker<Page::kDontCreate>(); |
- if (tracker != nullptr) { |
- tracker->FreeDead(); |
+ |
+void ArrayBufferTracker::FreeDead(bool from_scavenge) { |
+ size_t freed_memory = 0; |
+ Isolate* isolate = heap()->isolate(); |
+ for (auto& buffer : not_yet_discovered_array_buffers_for_scavenge_) { |
+ isolate->array_buffer_allocator()->Free(buffer.first, buffer.second); |
+ freed_memory += buffer.second; |
+ live_array_buffers_for_scavenge_.erase(buffer.first); |
} |
+ |
+ if (!from_scavenge) { |
+ for (auto& buffer : not_yet_discovered_array_buffers_) { |
+ isolate->array_buffer_allocator()->Free(buffer.first, buffer.second); |
+ freed_memory += buffer.second; |
+ live_array_buffers_.erase(buffer.first); |
+ } |
+ } |
+ |
+ not_yet_discovered_array_buffers_for_scavenge_ = |
+ live_array_buffers_for_scavenge_; |
+ if (!from_scavenge) not_yet_discovered_array_buffers_ = live_array_buffers_; |
+ |
+ // Do not call through the api as this code is triggered while doing a GC. |
+ heap()->update_amount_of_external_allocated_memory( |
+ -static_cast<int64_t>(freed_memory)); |
} |
-template <LocalArrayBufferTracker::LivenessIndicator liveness_indicator> |
-void ArrayBufferTracker::ScanAndFreeDeadArrayBuffers(Page* page) { |
- LocalArrayBufferTracker* tracker = page->local_tracker<Page::kDontCreate>(); |
- if (tracker != nullptr) { |
- base::LockGuard<base::Mutex> guard(page->mutex()); |
- tracker->ScanAndFreeDead<liveness_indicator>(); |
- } |
+ |
+void ArrayBufferTracker::PrepareDiscoveryInNewSpace() { |
+ not_yet_discovered_array_buffers_for_scavenge_ = |
+ live_array_buffers_for_scavenge_; |
} |
-template void ArrayBufferTracker::ScanAndFreeDeadArrayBuffers< |
- LocalArrayBufferTracker::LivenessIndicator::kForwardingPointer>(Page* page); |
-template void ArrayBufferTracker::ScanAndFreeDeadArrayBuffers< |
- LocalArrayBufferTracker::LivenessIndicator::kMarkBit>(Page* page); |
-template void ArrayBufferTracker::ScanAndFreeDeadArrayBuffers< |
- LocalArrayBufferTracker::LivenessIndicator::kForwardingPointerOrMarkBit>( |
- Page* page); |
+ |
+void ArrayBufferTracker::Promote(JSArrayBuffer* buffer) { |
+ base::LockGuard<base::Mutex> guard(&mutex_); |
+ |
+ if (buffer->is_external()) return; |
+ void* data = buffer->backing_store(); |
+ if (!data) return; |
+ // ArrayBuffer might be in the middle of being constructed. |
+ if (data == heap()->undefined_value()) return; |
+ DCHECK(live_array_buffers_for_scavenge_.count(data) > 0); |
+ live_array_buffers_[data] = live_array_buffers_for_scavenge_[data]; |
+ live_array_buffers_for_scavenge_.erase(data); |
+ not_yet_discovered_array_buffers_for_scavenge_.erase(data); |
+} |
} // namespace internal |
} // namespace v8 |