AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Reland "[heap] Attempt to incorporate backing store counters into heap sizing and GC trigger stragery."

Browse Source 
This is a reland of ba735dde20

Original change's description:
> [heap] Attempt to incorporate backing store counters into heap sizing and GC trigger stragery.
> 
> Bug: chromium:845409
> Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng
> Change-Id: Ic62a4339110e3dd2a6b1961a246e2bee0c07c03b
> Reviewed-on: https://chromium-review.googlesource.com/1160162
> Commit-Queue: Rodrigo Bruno <rfbpb@google.com>
> Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
> Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#55128}

Bug: chromium:845409
Change-Id: Iaff177f7bebbc073460fab0ae4e5cd9e632e1921
Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng
Reviewed-on: https://chromium-review.googlesource.com/1177301
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Commit-Queue: Rodrigo Bruno <rfbpb@google.com>
Cr-Commit-Position: refs/heads/master@{#55454}
This commit is contained in:
Rodrigo Bruno 2018-08-28 13:50:56 +02:00 committed by Commit Bot
parent dd732b4fb0
commit eb164dbd00
17 changed files with 272 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/v8.h
View File

@ -9381,7 +9381,7 @@ class Internals {
kExternalMemoryLimitOffset + kApiInt64Size;
static const int kIsolateRootsOffset = kExternalMemoryLimitOffset +
kApiInt64Size + kApiInt64Size +
kApiPointerSize + kApiPointerSize;
kApiInt64Size + kApiPointerSize;
static const int kUndefinedValueRootIndex = 4;
static const int kTheHoleValueRootIndex = 5;
static const int kNullValueRootIndex = 6;

3
src/api.cc
View File

@ -8359,7 +8359,8 @@ void Isolate::GetHeapStatistics(HeapStatistics* heap_statistics) {
heap_statistics->malloced_memory_ =
isolate->allocator()->GetCurrentMemoryUsage() +
isolate->wasm_engine()->allocator()->GetCurrentMemoryUsage();
heap_statistics->external_memory_ = isolate->heap()->external_memory();
heap_statistics->external_memory_ = isolate->heap()->external_memory() +
isolate->heap()->backing_story_bytes();
heap_statistics->peak_malloced_memory_ =
isolate->allocator()->GetMaxMemoryUsage() +
isolate->wasm_engine()->allocator()->GetMaxMemoryUsage();

43
src/d8.cc
View File

@ -135,6 +135,7 @@ class ShellArrayBufferAllocator : public ArrayBufferAllocatorBase {
// ArrayBuffer allocator that never allocates over 10MB.
class MockArrayBufferAllocator : public ArrayBufferAllocatorBase {
protected:
void* Allocate(size_t length) override {
return ArrayBufferAllocatorBase::Allocate(Adjust(length));
}
@ -154,6 +155,37 @@ class MockArrayBufferAllocator : public ArrayBufferAllocatorBase {
}
};
class MockArrayBufferAllocatiorWithLimit : public MockArrayBufferAllocator {
public:
explicit MockArrayBufferAllocatiorWithLimit(size_t allocation_limit)
: space_left_(allocation_limit) {}
protected:
void* Allocate(size_t length) override {
if (length > space_left_) {
return nullptr;
}
space_left_ -= length;
return MockArrayBufferAllocator::Allocate(length);
}
void* AllocateUninitialized(size_t length) override {
if (length > space_left_) {
return nullptr;
}
space_left_ -= length;
return MockArrayBufferAllocator::AllocateUninitialized(length);
}
void Free(void* data, size_t length) override {
space_left_ += length;
return MockArrayBufferAllocator::Free(data, length);
}
private:
std::atomic<size_t> space_left_;
};
// Predictable v8::Platform implementation. Worker threads are disabled, idle
// tasks are disallowed, and the time reported by {MonotonicallyIncreasingTime}
// is deterministic.
@ -2789,6 +2821,11 @@ bool Shell::SetOptions(int argc, char* argv[]) {
strcmp(argv[i], "--no-stress-background-compile") == 0) {
options.stress_background_compile = false;
argv[i] = nullptr;
} else if (strncmp(argv[i], "--mock-arraybuffer-allocator-limit=", 35) ==
0) {
options.mock_arraybuffer_allocator = true;
options.mock_arraybuffer_allocator_limit = atoi(argv[i] + 35);
argv[i] = nullptr;
} else if (strcmp(argv[i], "--noalways-opt") == 0 ||
strcmp(argv[i], "--no-always-opt") == 0) {
// No support for stressing if we can't use --always-opt.
@ -3362,7 +3399,11 @@ int Shell::Main(int argc, char* argv[]) {
Isolate::CreateParams create_params;
ShellArrayBufferAllocator shell_array_buffer_allocator;
MockArrayBufferAllocator mock_arraybuffer_allocator;
if (options.mock_arraybuffer_allocator) {
MockArrayBufferAllocatiorWithLimit mock_arraybuffer_allocator_limit(
options.mock_arraybuffer_allocator_limit);
if (options.mock_arraybuffer_allocator_limit > 0) {
Shell::array_buffer_allocator = &mock_arraybuffer_allocator_limit;
} else if (options.mock_arraybuffer_allocator) {
Shell::array_buffer_allocator = &mock_arraybuffer_allocator;
} else {
Shell::array_buffer_allocator = &shell_array_buffer_allocator;

1
src/d8.h
View File

@ -369,6 +369,7 @@ class ShellOptions {
bool test_shell;
bool expected_to_throw;
bool mock_arraybuffer_allocator;
int mock_arraybuffer_allocator_limit = 0;
bool enable_inspector;
int num_isolates;
v8::ScriptCompiler::CompileOptions compile_options;

2
src/heap/array-buffer-collector.cc
View File

@ -48,8 +48,6 @@ class ArrayBufferCollector::FreeingTask final : public CancelableTask {
};
void ArrayBufferCollector::FreeAllocationsOnBackgroundThread() {
// TODO(wez): Remove backing-store from external memory accounting.
heap_->account_external_memory_concurrently_freed();
if (!heap_->IsTearingDown() && FLAG_concurrent_array_buffer_freeing) {
V8::GetCurrentPlatform()->CallOnWorkerThread(
base::make_unique<FreeingTask>(heap_));

15
src/heap/array-buffer-tracker-inl.h
View File

@ -30,12 +30,6 @@ void ArrayBufferTracker::RegisterNew(Heap* heap, JSArrayBuffer* buffer) {
DCHECK_NOT_NULL(tracker);
tracker->Add(buffer, length);
}
// TODO(wez): Remove backing-store from external memory accounting.
// 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())
->AdjustAmountOfExternalAllocatedMemory(length);
}
void ArrayBufferTracker::Unregister(Heap* heap, JSArrayBuffer* buffer) {
@ -49,9 +43,6 @@ void ArrayBufferTracker::Unregister(Heap* heap, JSArrayBuffer* buffer) {
DCHECK_NOT_NULL(tracker);
tracker->Remove(buffer, length);
}
// TODO(wez): Remove backing-store from external memory accounting.
heap->update_external_memory(-static_cast<intptr_t>(length));
}
Space* LocalArrayBufferTracker::space() { return page_->owner(); }
@ -76,10 +67,6 @@ void LocalArrayBufferTracker::Free(Callback should_free) {
if (freed_memory > 0) {
page_->DecrementExternalBackingStoreBytes(
ExternalBackingStoreType::kArrayBuffer, freed_memory);
// TODO(wez): Remove backing-store from external memory accounting.
page_->heap()->update_external_memory_concurrently_freed(
static_cast<intptr_t>(freed_memory));
}
}
@ -99,7 +86,6 @@ void ArrayBufferTracker::FreeDead(Page* page, MarkingState* marking_state) {
void LocalArrayBufferTracker::Add(JSArrayBuffer* buffer, size_t length) {
page_->IncrementExternalBackingStoreBytes(
ExternalBackingStoreType::kArrayBuffer, length);
auto ret = array_buffers_.insert(
{buffer,
{buffer->backing_store(), length, buffer->backing_store(),
@ -113,7 +99,6 @@ void LocalArrayBufferTracker::Add(JSArrayBuffer* buffer, size_t length) {
void LocalArrayBufferTracker::Remove(JSArrayBuffer* buffer, size_t length) {
page_->DecrementExternalBackingStoreBytes(
ExternalBackingStoreType::kArrayBuffer, length);
TrackingData::iterator it = array_buffers_.find(buffer);
// Check that we indeed find a key to remove.
DCHECK(it != array_buffers_.end());

6
src/heap/array-buffer-tracker.cc
View File

@ -54,7 +54,6 @@ void LocalArrayBufferTracker::Process(Callback callback) {
tracker->Add(new_buffer, length);
}
moved_memory += it->second.length;
} else if (result == kRemoveEntry) {
const size_t length = it->second.length;
freed_memory += length;
@ -68,11 +67,6 @@ void LocalArrayBufferTracker::Process(Callback callback) {
UNREACHABLE();
}
}
if (moved_memory || freed_memory) {
// TODO(wez): Remove backing-store from external memory accounting.
page_->heap()->update_external_memory_concurrently_freed(
static_cast<intptr_t>(freed_memory));
}
array_buffers_.swap(kept_array_buffers);

58
src/heap/heap-controller.cc
View File

@ -66,35 +66,10 @@ double MemoryController::GrowingFactor(double gc_speed, double mutator_speed,
return factor;
}
double MemoryController::MaxGrowingFactor(size_t curr_max_size) {
const double min_small_factor = 1.3;
const double max_small_factor = 2.0;
const double high_factor = 4.0;
size_t max_size_in_mb = curr_max_size / MB;
max_size_in_mb = Max(max_size_in_mb, kMinSize);
// If we are on a device with lots of memory, we allow a high heap
// growing factor.
if (max_size_in_mb >= kMaxSize) {
return high_factor;
}
DCHECK_GE(max_size_in_mb, kMinSize);
DCHECK_LT(max_size_in_mb, kMaxSize);
// On smaller devices we linearly scale the factor: (X-A)/(B-A)*(D-C)+C
double factor = (max_size_in_mb - kMinSize) *
(max_small_factor - min_small_factor) /
(kMaxSize - kMinSize) +
min_small_factor;
return factor;
}
size_t MemoryController::CalculateAllocationLimit(
size_t curr_size, size_t max_size, double gc_speed, double mutator_speed,
size_t new_space_capacity, Heap::HeapGrowingMode growing_mode) {
double max_factor = MaxGrowingFactor(max_size);
size_t curr_size, size_t max_size, double max_factor, double gc_speed,
double mutator_speed, size_t new_space_capacity,
Heap::HeapGrowingMode growing_mode) {
double factor = GrowingFactor(gc_speed, mutator_speed, max_factor);
if (FLAG_trace_gc_verbose) {
@ -125,7 +100,7 @@ size_t MemoryController::CalculateAllocationLimit(
MinimumAllocationLimitGrowingStep(growing_mode));
limit += new_space_capacity;
uint64_t halfway_to_the_max =
(static_cast<uint64_t>(curr_size) + max_size) / 2;
(static_cast<uint64_t>(curr_size) + static_cast<uint64_t>(max_size)) / 2;
size_t result = static_cast<size_t>(Min(limit, halfway_to_the_max));
if (FLAG_trace_gc_verbose) {
@ -147,5 +122,30 @@ size_t MemoryController::MinimumAllocationLimitGrowingStep(
: kRegularAllocationLimitGrowingStep);
}
double HeapController::MaxGrowingFactor(size_t curr_max_size) {
const double min_small_factor = 1.3;
const double max_small_factor = 2.0;
const double high_factor = 4.0;
size_t max_size_in_mb = curr_max_size / MB;
max_size_in_mb = Max(max_size_in_mb, kMinSize);
// If we are on a device with lots of memory, we allow a high heap
// growing factor.
if (max_size_in_mb >= kMaxSize) {
return high_factor;
}
DCHECK_GE(max_size_in_mb, kMinSize);
DCHECK_LT(max_size_in_mb, kMaxSize);
// On smaller devices we linearly scale the factor: (X-A)/(B-A)*(D-C)+C
double factor = (max_size_in_mb - kMinSize) *
(max_small_factor - min_small_factor) /
(kMaxSize - kMinSize) +
min_small_factor;
return factor;
}
} // namespace internal
} // namespace v8

55
src/heap/heap-controller.h
View File

@ -13,35 +13,51 @@
namespace v8 {
namespace internal {
enum AvailableAllocationSpace {
kAboveAllocationLimit,
kCloseToAllocationLimit,
kBelowAllocationLimit,
};
class V8_EXPORT_PRIVATE MemoryController {
public:
MemoryController(Heap* heap, double min_growing_factor,
double max_growing_factor,
double conservative_growing_factor,
double target_mutator_utilization, size_t min_size,
size_t max_size)
double target_mutator_utilization,
double close_to_allocation_limit_factor)
: heap_(heap),
kMinGrowingFactor(min_growing_factor),
kMaxGrowingFactor(max_growing_factor),
kConservativeGrowingFactor(conservative_growing_factor),
kTargetMutatorUtilization(target_mutator_utilization),
kMinSize(min_size),
kMaxSize(max_size) {}
kCloseToAllocationLimitFactor(close_to_allocation_limit_factor) {}
virtual ~MemoryController() {}
// Computes the allocation limit to trigger the next garbage collection.
size_t CalculateAllocationLimit(size_t curr_size, size_t max_size,
double gc_speed, double mutator_speed,
double max_factor, double gc_speed,
double mutator_speed,
size_t new_space_capacity,
Heap::HeapGrowingMode growing_mode);
// Computes the growing step when the limit increases.
size_t MinimumAllocationLimitGrowingStep(Heap::HeapGrowingMode growing_mode);
AvailableAllocationSpace CheckAllocationLimit(size_t used_memory,
size_t allocation_limit) {
if (used_memory > allocation_limit) {
return AvailableAllocationSpace::kAboveAllocationLimit;
} else if (used_memory >
(kCloseToAllocationLimitFactor * allocation_limit)) {
return AvailableAllocationSpace::kCloseToAllocationLimit;
}
return AvailableAllocationSpace::kBelowAllocationLimit;
}
protected:
double GrowingFactor(double gc_speed, double mutator_speed,
double max_factor);
double MaxGrowingFactor(size_t curr_max_size);
virtual const char* ControllerName() = 0;
Heap* const heap_;
@ -50,9 +66,7 @@ class V8_EXPORT_PRIVATE MemoryController {
const double kMaxGrowingFactor;
const double kConservativeGrowingFactor;
const double kTargetMutatorUtilization;
// Sizes are in MB.
const size_t kMinSize;
const size_t kMaxSize;
const double kCloseToAllocationLimitFactor;
FRIEND_TEST(HeapControllerTest, HeapGrowingFactor);
FRIEND_TEST(HeapControllerTest, MaxHeapGrowingFactor);
@ -60,20 +74,29 @@ class V8_EXPORT_PRIVATE MemoryController {
FRIEND_TEST(HeapControllerTest, OldGenerationAllocationLimit);
};
class HeapController : public MemoryController {
class V8_EXPORT_PRIVATE HeapController : public MemoryController {
public:
explicit HeapController(Heap* heap)
: MemoryController(heap, 1.1, 4.0, 1.3, 0.97, kMinHeapSize,
kMaxHeapSize) {}
// Sizes are in MB.
static const size_t kMinHeapSize = 128 * Heap::kPointerMultiplier;
static const size_t kMaxHeapSize = 1024 * Heap::kPointerMultiplier;
static const size_t kMinSize = 128 * Heap::kPointerMultiplier;
static const size_t kMaxSize = 1024 * Heap::kPointerMultiplier;
explicit HeapController(Heap* heap)
: MemoryController(heap, 1.1, 4.0, 1.3, 0.97, 0.75) {}
double MaxGrowingFactor(size_t curr_max_size);
protected:
const char* ControllerName() { return "HeapController"; }
};
class GlobalMemoryController : public MemoryController {
public:
explicit GlobalMemoryController(Heap* heap)
: MemoryController(heap, 1.1, 4.0, 1.3, 0.97, 0.75) {}
protected:
const char* ControllerName() { return "GlobalMemoryController"; }
};
} // namespace internal
} // namespace v8

108
src/heap/heap.cc
View File

@ -138,7 +138,7 @@ Heap::Heap()
: external_memory_(0),
external_memory_limit_(kExternalAllocationSoftLimit),
external_memory_at_last_mark_compact_(0),
external_memory_concurrently_freed_(0),
backing_store_bytes_(0),
isolate_(nullptr),
code_range_size_(0),
// semispace_size_ should be a power of 2 and old_generation_size_ should
@ -146,6 +146,9 @@ Heap::Heap()
max_semi_space_size_(8 * (kPointerSize / 4) * MB),
initial_semispace_size_(kMinSemiSpaceSizeInKB * KB),
max_old_generation_size_(700ul * (kPointerSize / 4) * MB),
max_global_memory_size_(
Min(static_cast<uint64_t>(std::numeric_limits<size_t>::max()),
static_cast<uint64_t>(16) * GB)),
initial_max_old_generation_size_(max_old_generation_size_),
initial_old_generation_size_(max_old_generation_size_ /
kInitalOldGenerationLimitFactor),
@ -184,6 +187,7 @@ Heap::Heap()
mmap_region_base_(0),
remembered_unmapped_pages_index_(0),
old_generation_allocation_limit_(initial_old_generation_size_),
global_memory_allocation_limit_(initial_old_generation_size_),
inline_allocation_disabled_(false),
tracer_(nullptr),
promoted_objects_size_(0),
@ -259,8 +263,8 @@ size_t Heap::ComputeMaxOldGenerationSize(uint64_t physical_memory) {
size_t computed_size = static_cast<size_t>(physical_memory / i::MB /
old_space_physical_memory_factor *
kPointerMultiplier);
return Max(Min(computed_size, HeapController::kMaxHeapSize),
HeapController::kMinHeapSize);
return Max(Min(computed_size, HeapController::kMaxSize),
HeapController::kMinSize);
}
size_t Heap::Capacity() {
@ -477,6 +481,8 @@ void Heap::PrintShortHeapStatistics() {
CommittedMemoryOfHeapAndUnmapper() / KB);
PrintIsolate(isolate_, "External memory reported: %6" PRId64 " KB\n",
external_memory_ / KB);
PrintIsolate(isolate_, "Backing store memory reported: %6" PRId64 " KB\n",
backing_store_bytes_ / KB);
PrintIsolate(isolate_, "External memory global %zu KB\n",
external_memory_callback_() / KB);
PrintIsolate(isolate_, "Total time spent in GC : %.1f ms\n",
@ -1076,6 +1082,12 @@ void Heap::HandleGCRequest() {
incremental_marking()->reset_request_type();
FinalizeIncrementalMarkingIncrementally(
GarbageCollectionReason::kFinalizeMarkingViaStackGuard);
} else if (global_controller_->CheckAllocationLimit(
GlobalSizeOfObjects(), global_memory_allocation_limit_) ==
AvailableAllocationSpace::kAboveAllocationLimit) {
CollectAllGarbage(current_gc_flags_,
GarbageCollectionReason::kGlobalAllocationLimit,
GCCallbackFlags::kGCCallbackFlagCollectAllExternalMemory);
}
}
@ -1463,9 +1475,12 @@ void Heap::StartIncrementalMarkingIfAllocationLimitIsReached(
if (reached_limit == IncrementalMarkingLimit::kSoftLimit) {
incremental_marking()->incremental_marking_job()->ScheduleTask(this);
} else if (reached_limit == IncrementalMarkingLimit::kHardLimit) {
StartIncrementalMarking(gc_flags,
GarbageCollectionReason::kAllocationLimit,
gc_callback_flags);
StartIncrementalMarking(
gc_flags,
OldGenerationSpaceAvailable() <= new_space_->Capacity()
? GarbageCollectionReason::kAllocationLimit
: GarbageCollectionReason::kGlobalAllocationLimit,
gc_callback_flags);
}
}
}
@ -1746,7 +1761,7 @@ bool Heap::PerformGarbageCollection(
}
UpdateSurvivalStatistics(static_cast<int>(start_new_space_size));
ConfigureInitialOldGenerationSize();
ConfigureInitialAllocationLimits();
if (collector != MARK_COMPACTOR) {
// Objects that died in the new space might have been accounted
@ -1779,27 +1794,31 @@ bool Heap::PerformGarbageCollection(
double gc_speed = tracer()->CombinedMarkCompactSpeedInBytesPerMillisecond();
double mutator_speed =
tracer()->CurrentOldGenerationAllocationThroughputInBytesPerMillisecond();
double max_factor =
heap_controller()->MaxGrowingFactor(max_old_generation_size_);
size_t old_gen_size = OldGenerationSizeOfObjects();
size_t new_old_limit = heap_controller()->CalculateAllocationLimit(
old_gen_size, max_old_generation_size_, max_factor, gc_speed,
mutator_speed, new_space()->Capacity(), CurrentHeapGrowingMode());
size_t new_global_limit = global_controller()->CalculateAllocationLimit(
GlobalSizeOfObjects(), max_global_memory_size_, max_factor, gc_speed,
mutator_speed, new_space()->Capacity(), CurrentHeapGrowingMode());
if (collector == MARK_COMPACTOR) {
// Register the amount of external allocated memory.
external_memory_at_last_mark_compact_ = external_memory_;
external_memory_limit_ = external_memory_ + kExternalAllocationSoftLimit;
size_t new_limit = heap_controller()->CalculateAllocationLimit(
old_gen_size, max_old_generation_size_, gc_speed, mutator_speed,
new_space()->Capacity(), CurrentHeapGrowingMode());
old_generation_allocation_limit_ = new_limit;
set_allocation_limits(new_old_limit, new_global_limit);
CheckIneffectiveMarkCompact(
old_gen_size, tracer()->AverageMarkCompactMutatorUtilization());
} else if (HasLowYoungGenerationAllocationRate() &&
old_generation_size_configured_) {
size_t new_limit = heap_controller()->CalculateAllocationLimit(
old_gen_size, max_old_generation_size_, gc_speed, mutator_speed,
new_space()->Capacity(), CurrentHeapGrowingMode());
if (new_limit < old_generation_allocation_limit_) {
old_generation_allocation_limit_ = new_limit;
}
set_allocation_limits(
Min(old_generation_allocation_limit_, new_old_limit),
Min(global_memory_allocation_limit_, new_global_limit));
}
{
@ -2285,6 +2304,23 @@ bool Heap::ExternalStringTable::Contains(HeapObject* obj) {
return false;
}
void Heap::update_backing_store_bytes(int64_t amount) {
backing_store_bytes_ += amount;
if (amount <= 0 || gc_state_ != NOT_IN_GC) return;
AvailableAllocationSpace available = global_controller_->CheckAllocationLimit(
GlobalSizeOfObjects(), global_memory_allocation_limit_);
if (available == AvailableAllocationSpace::kAboveAllocationLimit) {
isolate()->stack_guard()->RequestGC();
} else if (available == AvailableAllocationSpace::kCloseToAllocationLimit &&
incremental_marking_->IsStopped() && FLAG_incremental_marking) {
StartIncrementalMarking(
GCFlagsForIncrementalMarking(),
GarbageCollectionReason::kGlobalAllocationLimit,
GCCallbackFlags::kGCCallbackFlagCollectAllExternalMemory);
}
}
void Heap::ProcessMovedExternalString(Page* old_page, Page* new_page,
ExternalString* string) {
size_t size = string->ExternalPayloadSize();
@ -2637,14 +2673,20 @@ void Heap::UnregisterArrayBuffer(JSArrayBuffer* buffer) {
ArrayBufferTracker::Unregister(this, buffer);
}
void Heap::ConfigureInitialOldGenerationSize() {
size_t Heap::ConfigureInitialControllerSize(MemoryController* controller,
size_t curr_limit) {
return Max(
controller->MinimumAllocationLimitGrowingStep(CurrentHeapGrowingMode()),
static_cast<size_t>(static_cast<double>(curr_limit) *
(tracer()->AverageSurvivalRatio() / 100)));
}
void Heap::ConfigureInitialAllocationLimits() {
if (!old_generation_size_configured_ && tracer()->SurvivalEventsRecorded()) {
old_generation_allocation_limit_ =
Max(heap_controller()->MinimumAllocationLimitGrowingStep(
CurrentHeapGrowingMode()),
static_cast<size_t>(
static_cast<double>(old_generation_allocation_limit_) *
(tracer()->AverageSurvivalRatio() / 100)));
size_t new_old_limit = ConfigureInitialControllerSize(
heap_controller_, old_generation_allocation_limit_);
size_t new_global_limit = ConfigureInitialControllerSize(
global_controller_, global_memory_allocation_limit_);
set_allocation_limits(new_old_limit, new_global_limit);
}
}
@ -3581,8 +3623,8 @@ void Heap::CollectGarbageOnMemoryPressure() {
double end = MonotonicallyIncreasingTimeInMs();
// Estimate how much memory we can free.
int64_t potential_garbage =
(CommittedMemory() - SizeOfObjects()) + external_memory_;
int64_t potential_garbage = (CommittedMemory() - SizeOfObjects()) +
external_memory_ + backing_store_bytes_;
// If we can potentially free large amount of memory, then start GC right
// away instead of waiting for memory reducer.
if (potential_garbage >= kGarbageThresholdInBytes &&
@ -3741,6 +3783,8 @@ const char* Heap::GarbageCollectionReasonToString(
return "testing";
case GarbageCollectionReason::kExternalFinalize:
return "external finalize";
case GarbageCollectionReason::kGlobalAllocationLimit:
return "global allocation limit";
case GarbageCollectionReason::kUnknown:
return "unknown";
}
@ -4537,8 +4581,12 @@ Heap::IncrementalMarkingLimit Heap::IncrementalMarkingLimitReached() {
}
size_t old_generation_space_available = OldGenerationSpaceAvailable();
AvailableAllocationSpace global_available =
global_controller_->CheckAllocationLimit(GlobalSizeOfObjects(),
global_memory_allocation_limit_);
if (old_generation_space_available > new_space_->Capacity()) {
if (old_generation_space_available > new_space_->Capacity() &&
global_available == AvailableAllocationSpace::kBelowAllocationLimit) {
return IncrementalMarkingLimit::kNoLimit;
}
if (ShouldOptimizeForMemoryUsage()) {
@ -4704,6 +4752,7 @@ void Heap::SetUp() {
store_buffer_ = new StoreBuffer(this);
heap_controller_ = new HeapController(this);
global_controller_ = new GlobalMemoryController(this);
mark_compact_collector_ = new MarkCompactCollector(this);
incremental_marking_ =
@ -4947,6 +4996,11 @@ void Heap::TearDown() {
heap_controller_ = nullptr;
}
if (global_controller_ != nullptr) {
delete global_controller_;
global_controller_ = nullptr;
}
if (mark_compact_collector_ != nullptr) {
mark_compact_collector_->TearDown();
delete mark_compact_collector_;

45
src/heap/heap.h
View File

@ -172,6 +172,7 @@ class GCIdleTimeAction;
class GCIdleTimeHandler;
class GCIdleTimeHeapState;
class GCTracer;
class GlobalMemoryController;
class HeapController;
class HeapObjectAllocationTracker;
class HeapObjectsFilter;
@ -180,6 +181,7 @@ class HistogramTimer;
class Isolate;
class LocalEmbedderHeapTracer;
class MemoryAllocator;
class MemoryController;
class MemoryReducer;
class MinorMarkCompactCollector;
class ObjectIterator;
@ -235,7 +237,8 @@ enum class GarbageCollectionReason {
kSamplingProfiler = 19,
kSnapshotCreator = 20,
kTesting = 21,
kExternalFinalize = 22
kExternalFinalize = 22,
kGlobalAllocationLimit = 23
// If you add new items here, then update the incremental_marking_reason,
// mark_compact_reason, and scavenge_reason counters in counters.h.
// Also update src/tools/metrics/histograms/histograms.xml in chromium.
@ -677,16 +680,9 @@ class Heap {
int64_t external_memory_hard_limit() { return MaxOldGenerationSize() / 2; }
int64_t external_memory() { return external_memory_; }
void update_external_memory(int64_t delta) { external_memory_ += delta; }
int64_t backing_story_bytes() const { return backing_store_bytes_; }
void update_external_memory_concurrently_freed(intptr_t freed) {
external_memory_concurrently_freed_ += freed;
}
void account_external_memory_concurrently_freed() {
external_memory_ -= external_memory_concurrently_freed_;
external_memory_concurrently_freed_ = 0;
}
void update_backing_store_bytes(int64_t amount);
void ProcessMovedExternalString(Page* old_page, Page* new_page,
ExternalString* string);
@ -1329,6 +1325,14 @@ class Heap {
// Excludes external memory held by those objects.
size_t OldGenerationSizeOfObjects();
// Returns the size of JS and external objects
size_t GlobalSizeOfObjects() {
size_t global_size = OldGenerationSizeOfObjects() +
static_cast<size_t>(backing_store_bytes_);
CHECK_GE(global_size, static_cast<size_t>(backing_store_bytes_));
return global_size;
}
// ===========================================================================
// Prologue/epilogue callback methods.========================================
// ===========================================================================
@ -1697,7 +1701,9 @@ class Heap {
// Flush the number to string cache.
void FlushNumberStringCache();
void ConfigureInitialOldGenerationSize();
size_t ConfigureInitialControllerSize(MemoryController* controller,
size_t curr_limit);
void ConfigureInitialAllocationLimits();
bool HasLowYoungGenerationAllocationRate();
bool HasLowOldGenerationAllocationRate();
@ -1846,6 +1852,7 @@ class Heap {
// ===========================================================================
HeapController* heap_controller() { return heap_controller_; }
GlobalMemoryController* global_controller() { return global_controller_; }
MemoryReducer* memory_reducer() { return memory_reducer_; }
// For some webpages RAIL mode does not switch from PERFORMANCE_LOAD.
@ -1856,6 +1863,12 @@ class Heap {
bool ShouldOptimizeForLoadTime();
void set_allocation_limits(size_t old_generation_allocation_limit,
size_t global_memory_allocation_limit) {
old_generation_allocation_limit_ = old_generation_allocation_limit;
global_memory_allocation_limit_ = global_memory_allocation_limit;
}
size_t old_generation_allocation_limit() const {
return old_generation_allocation_limit_;
}
@ -1970,8 +1983,8 @@ class Heap {
// Caches the amount of external memory registered at the last MC.
int64_t external_memory_at_last_mark_compact_;
// The amount of memory that has been freed concurrently.
std::atomic<intptr_t> external_memory_concurrently_freed_;
// Backing store bytes (array buffers and external strings).
std::atomic<int64_t> backing_store_bytes_;
// This can be calculated directly from a pointer to the heap; however, it is
// more expedient to get at the isolate directly from within Heap methods.
@ -2004,6 +2017,7 @@ class Heap {
size_t max_semi_space_size_;
size_t initial_semispace_size_;
size_t max_old_generation_size_;
size_t max_global_memory_size_;
size_t initial_max_old_generation_size_;
size_t initial_old_generation_size_;
bool old_generation_size_configured_;
@ -2104,6 +2118,10 @@ class Heap {
// generation and on every allocation in large object space.
size_t old_generation_allocation_limit_;
// The limit when to trigger memory pressure. This limit accounts for JS
// memory and external memory (array buffers and external strings).
size_t global_memory_allocation_limit_;
// Indicates that inline bump-pointer allocation has been globally disabled
// for all spaces. This is used to disable allocations in generated code.
bool inline_allocation_disabled_;
@ -2157,6 +2175,7 @@ class Heap {
StoreBuffer* store_buffer_;
HeapController* heap_controller_;
GlobalMemoryController* global_controller_;
IncrementalMarking* incremental_marking_;
ConcurrentMarking* concurrent_marking_;

3
src/heap/mark-compact.cc
View File

@ -803,7 +803,6 @@ void MarkCompactCollector::Prepare() {
space = spaces.next()) {
space->PrepareForMarkCompact();
}
heap()->account_external_memory_concurrently_freed();
#ifdef VERIFY_HEAP
if (!was_marked_incrementally_ && FLAG_verify_heap) {
@ -3848,8 +3847,6 @@ void MinorMarkCompactCollector::CollectGarbage() {
RememberedSet<OLD_TO_NEW>::PreFreeEmptyBuckets(chunk);
}
});
heap()->account_external_memory_concurrently_freed();
}
void MinorMarkCompactCollector::MakeIterable(

2
src/heap/spaces.h
View File

@ -1018,11 +1018,13 @@ class Space : public Malloced {
void IncrementExternalBackingStoreBytes(ExternalBackingStoreType type,
size_t amount) {
external_backing_store_bytes_[type] += amount;
heap()->update_backing_store_bytes(static_cast<int64_t>(amount));
}
void DecrementExternalBackingStoreBytes(ExternalBackingStoreType type,
size_t amount) {
DCHECK_GE(external_backing_store_bytes_[type], amount);
external_backing_store_bytes_[type] -= amount;
heap()->update_backing_store_bytes(-static_cast<int64_t>(amount));
}
V8_EXPORT_PRIVATE void* GetRandomMmapAddr();

1
test/cctest/heap/test-heap.cc
View File

@ -1588,6 +1588,7 @@ HEAP_TEST(TestSizeOfObjects) {
Isolate* isolate = CcTest::i_isolate();
Heap* heap = CcTest::heap();
MarkCompactCollector* collector = heap->mark_compact_collector();
ManualGCScope manual_gc_scope;
// Get initial heap size after several full GCs, which will stabilize
// the heap size and return with sweeping finished completely.

9
test/mjsunit/external-backing-store-gc.js Normal file
View File

@ -0,0 +1,9 @@
// Copyright 2018 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.
// Flags: --mock-arraybuffer-allocator-limit=800000000
for (var i = 0; i < 1024; i++) {
let garbage = new ArrayBuffer(1024*1024);
}

55
test/unittests/heap/heap-controller-unittest.cc
View File

@ -51,15 +51,14 @@ TEST_F(HeapControllerTest, HeapGrowingFactor) {
TEST_F(HeapControllerTest, MaxHeapGrowingFactor) {
HeapController heap_controller(i_isolate()->heap());
CheckEqualRounded(
1.3, heap_controller.MaxGrowingFactor(heap_controller.kMinSize * MB));
1.3, heap_controller.MaxGrowingFactor(HeapController::kMinSize * MB));
CheckEqualRounded(1.600, heap_controller.MaxGrowingFactor(
heap_controller.kMaxSize / 2 * MB));
HeapController::kMaxSize / 2 * MB));
CheckEqualRounded(
1.999, heap_controller.MaxGrowingFactor(
(heap_controller.kMaxSize - Heap::kPointerMultiplier) * MB));
CheckEqualRounded(4.0,
heap_controller.MaxGrowingFactor(
static_cast<size_t>(heap_controller.kMaxSize) * MB));
(HeapController::kMaxSize - Heap::kPointerMultiplier) * MB));
CheckEqualRounded(
4.0, heap_controller.MaxGrowingFactor(HeapController::kMaxSize * MB));
}
TEST_F(HeapControllerTest, OldGenerationAllocationLimit) {
@ -75,39 +74,43 @@ TEST_F(HeapControllerTest, OldGenerationAllocationLimit) {
double factor =
heap_controller.GrowingFactor(gc_speed, mutator_speed, max_factor);
EXPECT_EQ(static_cast<size_t>(old_gen_size * factor + new_space_capacity),
heap->heap_controller()->CalculateAllocationLimit(
old_gen_size, max_old_generation_size, gc_speed, mutator_speed,
new_space_capacity, Heap::HeapGrowingMode::kDefault));
EXPECT_EQ(
static_cast<size_t>(old_gen_size * factor + new_space_capacity),
heap->heap_controller()->CalculateAllocationLimit(
old_gen_size, max_old_generation_size, max_factor, gc_speed,
mutator_speed, new_space_capacity, Heap::HeapGrowingMode::kDefault));
factor = Min(factor, heap_controller.kConservativeGrowingFactor);
EXPECT_EQ(
static_cast<size_t>(old_gen_size * factor + new_space_capacity),
heap->heap_controller()->CalculateAllocationLimit(
old_gen_size, max_old_generation_size, max_factor, gc_speed,
mutator_speed, new_space_capacity, Heap::HeapGrowingMode::kSlow));
factor = Min(factor, heap_controller.kConservativeGrowingFactor);
EXPECT_EQ(static_cast<size_t>(old_gen_size * factor + new_space_capacity),
heap->heap_controller()->CalculateAllocationLimit(
old_gen_size, max_old_generation_size, gc_speed, mutator_speed,
new_space_capacity, Heap::HeapGrowingMode::kSlow));
factor = Min(factor, heap_controller.kConservativeGrowingFactor);
EXPECT_EQ(static_cast<size_t>(old_gen_size * factor + new_space_capacity),
heap->heap_controller()->CalculateAllocationLimit(
old_gen_size, max_old_generation_size, gc_speed, mutator_speed,
new_space_capacity, Heap::HeapGrowingMode::kConservative));
old_gen_size, max_old_generation_size, max_factor, gc_speed,
mutator_speed, new_space_capacity,
Heap::HeapGrowingMode::kConservative));
factor = heap_controller.kMinGrowingFactor;
EXPECT_EQ(static_cast<size_t>(old_gen_size * factor + new_space_capacity),
heap->heap_controller()->CalculateAllocationLimit(
old_gen_size, max_old_generation_size, gc_speed, mutator_speed,
new_space_capacity, Heap::HeapGrowingMode::kMinimal));
EXPECT_EQ(
static_cast<size_t>(old_gen_size * factor + new_space_capacity),
heap->heap_controller()->CalculateAllocationLimit(
old_gen_size, max_old_generation_size, max_factor, gc_speed,
mutator_speed, new_space_capacity, Heap::HeapGrowingMode::kMinimal));
}
TEST_F(HeapControllerTest, MaxOldGenerationSize) {
HeapController heap_controller(i_isolate()->heap());
uint64_t configurations[][2] = {
{0, heap_controller.kMinSize},
{512, heap_controller.kMinSize},
{0, HeapController::kMinSize},
{512, HeapController::kMinSize},
{1 * GB, 256 * Heap::kPointerMultiplier},
{2 * static_cast<uint64_t>(GB), 512 * Heap::kPointerMultiplier},
{4 * static_cast<uint64_t>(GB), heap_controller.kMaxSize},
{8 * static_cast<uint64_t>(GB), heap_controller.kMaxSize}};
{4 * static_cast<uint64_t>(GB), HeapController::kMaxSize},
{8 * static_cast<uint64_t>(GB), HeapController::kMaxSize}};
for (auto configuration : configurations) {
ASSERT_EQ(configuration[1],

5
tools/gcmole/gcmole.lua
View File

@ -294,7 +294,10 @@ local WHITELIST = {
"StateTag",
-- Ignore printing of elements transition.
"PrintElementsTransition"
"PrintElementsTransition",
-- Ignore GC reason method that returns a string (not GC trigger).
"GarbageCollectionReasonToString"
};
local function AddCause(name, cause)