74565bf390
When inlined allocations are disabled, the space->limit() does not point to the
end of the current page. Instead, it points to the current allocation pointer so
is the same as space->top().
See how the limit is computed, if heap()->inline_allocation_disabled(), then the
limit will be the same as the requested allocation area:
```
Address SpaceWithLinearArea::ComputeLimit(Address start, Address end,
size_t min_size) {
DCHECK_GE(end - start, min_size);
if (heap()->inline_allocation_disabled()) {
// Fit the requested area exactly.
return start + min_size;
} else if (SupportsInlineAllocation() && AllocationObserversActive()) {
// ...
} else {
// The entire node can be used as the linear allocation area.
return end;
}
}
```
If we want to simulate filling up a whole page in the new space, we can instead
look at the ToSpace's page_high() which will be the end of the current page in
which we're allocating.
Bug: v8:9906
Change-Id: I81113d151bc083cd22d17ea1a4fbae7fef9dff6d
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1886914
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Commit-Queue: Pierre Langlois <pierre.langlois@arm.com>
Cr-Commit-Position: refs/heads/master@{#64612}
85 lines
2.5 KiB
C++
85 lines
2.5 KiB
C++
// Copyright 2016 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.
|
|
|
|
#ifndef HEAP_HEAP_UTILS_H_
|
|
#define HEAP_HEAP_UTILS_H_
|
|
|
|
#include "src/api/api-inl.h"
|
|
#include "src/heap/heap.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
namespace heap {
|
|
|
|
class TemporaryEmbedderHeapTracerScope {
|
|
public:
|
|
TemporaryEmbedderHeapTracerScope(v8::Isolate* isolate,
|
|
v8::EmbedderHeapTracer* tracer)
|
|
: isolate_(isolate) {
|
|
isolate_->SetEmbedderHeapTracer(tracer);
|
|
}
|
|
|
|
~TemporaryEmbedderHeapTracerScope() {
|
|
isolate_->SetEmbedderHeapTracer(nullptr);
|
|
}
|
|
|
|
private:
|
|
v8::Isolate* const isolate_;
|
|
};
|
|
|
|
void SealCurrentObjects(Heap* heap);
|
|
|
|
int FixedArrayLenFromSize(int size);
|
|
|
|
// Fill a page with fixed arrays leaving remainder behind. The function does
|
|
// not create additional fillers and assumes that the space has just been
|
|
// sealed.
|
|
std::vector<Handle<FixedArray>> FillOldSpacePageWithFixedArrays(Heap* heap,
|
|
int remainder);
|
|
|
|
std::vector<Handle<FixedArray>> CreatePadding(
|
|
Heap* heap, int padding_size, AllocationType allocation,
|
|
int object_size = kMaxRegularHeapObjectSize);
|
|
|
|
bool FillCurrentPage(v8::internal::NewSpace* space,
|
|
std::vector<Handle<FixedArray>>* out_handles = nullptr);
|
|
|
|
bool FillCurrentPageButNBytes(
|
|
v8::internal::NewSpace* space, int extra_bytes,
|
|
std::vector<Handle<FixedArray>>* out_handles = nullptr);
|
|
|
|
// Helper function that simulates a full new-space in the heap.
|
|
void SimulateFullSpace(v8::internal::NewSpace* space,
|
|
std::vector<Handle<FixedArray>>* out_handles = nullptr);
|
|
|
|
// Helper function that simulates many incremental marking steps until
|
|
// marking is completed.
|
|
void SimulateIncrementalMarking(i::Heap* heap, bool force_completion = true);
|
|
|
|
// Helper function that simulates a full old-space in the heap.
|
|
void SimulateFullSpace(v8::internal::PagedSpace* space);
|
|
|
|
void AbandonCurrentlyFreeMemory(PagedSpace* space);
|
|
|
|
void GcAndSweep(Heap* heap, AllocationSpace space);
|
|
|
|
void ForceEvacuationCandidate(Page* page);
|
|
|
|
void InvokeScavenge();
|
|
|
|
void InvokeMarkSweep();
|
|
|
|
template <typename GlobalOrPersistent>
|
|
bool InYoungGeneration(v8::Isolate* isolate, const GlobalOrPersistent& global) {
|
|
v8::HandleScope scope(isolate);
|
|
auto tmp = global.Get(isolate);
|
|
return i::Heap::InYoungGeneration(*v8::Utils::OpenHandle(*tmp));
|
|
}
|
|
|
|
} // namespace heap
|
|
} // namespace internal
|
|
} // namespace v8
|
|
|
|
#endif // HEAP_HEAP_UTILS_H_
|