Skip to content
This repository has been archived by the owner on Apr 3, 2020. It is now read-only.

Commit

Permalink
Revert of [heap] Fine-grained JSArrayBuffer tracking (patchset #19 id…
Browse files Browse the repository at this point in the history 
…:770001 of https://codereview.chromium.org/1964023002/ )

Reason for revert:
Revert it.

Original issue's description:
> [heap] Fine-grained JSArrayBuffer tracking
>
> Track based on JSArrayBuffer addresses instead of the attached backing store.
> This way we can later on iterate buffers on a single page. The reland also
> switches to a page-based implementation where a page contains the set of its
> contained (live and dead) buffers.
>
> Details of tracking:
> - Scavenge: New space pages are processes in bulk on the main thread
> - MC: Unswept pages are processed in bulk in parallel. All other pages
>   are processed by the sweeper concurrently.
>
> BUG=chromium:611688
> LOG=N
> CQ_EXTRA_TRYBOTS=tryserver.v8:v8_linux_arm64_gc_stress_dbg,v8_linux_gc_stress_dbg,v8_mac_gc_stress_dbg,v8_linux64_tsan_rel,v8_mac64_asan_rel
>
> Committed: https://crrev.com/b2d8bfc7931eef49d527605ba485950dea41cde3
> Cr-Commit-Position: refs/heads/master@{#36437}

[email protected]
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=chromium:611688

Review-Url: https://codereview.chromium.org/2006183003
Cr-Commit-Position: refs/heads/master@{#36461}
  • Loading branch information
@mlippautz
mlippautz authored and Commit bot committed May 24, 2016
1 parent b01b9f4 commit d2dff03
Show file tree
Hide file tree
Showing 18 changed files with 164 additions and 509 deletions.
1 change: 0 additions & 1 deletion BUILD.gn
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1170,7 +1170,6 @@ v8_source_set("v8_base") {
"src/handles.h",
"src/hashmap.h",
"src/heap-symbols.h",
"src/heap/array-buffer-tracker-inl.h",
"src/heap/array-buffer-tracker.cc",
"src/heap/array-buffer-tracker.h",
"src/heap/gc-idle-time-handler.cc",
Expand Down
2 changes: 1 addition & 1 deletion include/v8.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7392,7 +7392,7 @@ class Internals {
kAmountOfExternalAllocatedMemoryOffset + kApiInt64Size;
static const int kIsolateRootsOffset =
kAmountOfExternalAllocatedMemoryAtLastGlobalGCOffset + kApiInt64Size +
kApiPointerSize + kApiPointerSize;
kApiPointerSize;
static const int kUndefinedValueRootIndex = 4;
static const int kTheHoleValueRootIndex = 5;
static const int kNullValueRootIndex = 6;
Expand Down
74 changes: 0 additions & 74 deletions src/heap/array-buffer-tracker-inl.h
View file

This file was deleted.

190 changes: 90 additions & 100 deletions src/heap/array-buffer-tracker.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,98 +3,53 @@
// 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-inl.h"
#include "src/objects.h"
#include "src/objects-inl.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;
}
if (freed_memory > 0) {
heap_->update_amount_of_external_allocated_freed_memory(
static_cast<intptr_t>(freed_memory));
for (auto& buffer : live_array_buffers_for_scavenge_) {
isolate->array_buffer_allocator()->Free(buffer.first, buffer.second);
freed_memory += buffer.second;
}
live_.clear();
not_yet_discovered_.clear();
}

void LocalArrayBufferTracker::Add(Key key, const Value& value) {
live_[key] = value;
not_yet_discovered_[key] = value;
}
live_array_buffers_.clear();
live_array_buffers_for_scavenge_.clear();
not_yet_discovered_array_buffers_.clear();
not_yet_discovered_array_buffers_for_scavenge_.clear();

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();
}

ArrayBufferTracker::~ArrayBufferTracker() {}

void ArrayBufferTracker::RegisterNew(JSArrayBuffer* buffer, bool track_live) {
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());
if (track_live) {
page->local_tracker()->AddLive(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 {
page->local_tracker()->Add(buffer, std::make_pair(data, length));
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);
}

Expand All @@ -103,49 +58,84 @@ void ArrayBufferTracker::Unregister(JSArrayBuffer* buffer) {
void* data = buffer->backing_store();
if (!data) return;

size_t length = Page::FromAddress(buffer->address())
->local_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 ? &not_yet_discovered_array_buffers_for_scavenge_
: &not_yet_discovered_array_buffers_;

void ArrayBufferTracker::FreeDeadInNewSpace() {
NewSpacePageIterator from_it(heap_->new_space()->FromSpaceStart(),
heap_->new_space()->FromSpaceEnd());
while (from_it.has_next()) {
Page* p = from_it.next();
p->ScanAndFreeDeadArrayBuffers<
LocalArrayBufferTracker::kForwardingPointer>();
}
heap_->account_amount_of_external_allocated_freed_memory();
}
DCHECK(live_buffers->count(data) > 0);

size_t length = (*live_buffers)[data];
live_buffers->erase(data);
not_yet_discovered_buffers->erase(data);

void ArrayBufferTracker::ResetTrackersInOldSpace() {
heap_->old_space()->ForAllPages([](Page* p) { p->ResetTracker(); });
heap()->update_amount_of_external_allocated_memory(
-static_cast<int64_t>(length));
}

#define UPDATE_GUARD(buffer, data) \
if (buffer->is_external()) return; \
data = buffer->backing_store(); \
if (data == nullptr) return; \
if (data == heap_->undefined_value()) return;

void ArrayBufferTracker::MarkLive(JSArrayBuffer* buffer) {
void* data = nullptr;
UPDATE_GUARD(buffer, data);
base::LockGuard<base::Mutex> guard(&mutex_);
void* data = buffer->backing_store();

LocalArrayBufferTracker* tracker =
Page::FromAddress(buffer->address())->local_tracker();
if (tracker->IsTracked(buffer)) {
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 {
heap_->RegisterNewArrayBuffer(buffer);
not_yet_discovered_array_buffers_.erase(data);
}
}

#undef UPDATE_GUARD

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));
}


void ArrayBufferTracker::PrepareDiscoveryInNewSpace() {
not_yet_discovered_array_buffers_for_scavenge_ =
live_array_buffers_for_scavenge_;
}


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
Loading

0 comments on commit d2dff03

Please sign in to comment.