summaryrefslogtreecommitdiff
path: root/deps/v8/test/cctest/heap
diff options
context:
space:
mode:
Diffstat (limited to 'deps/v8/test/cctest/heap')
-rw-r--r--deps/v8/test/cctest/heap/heap-utils.cc7
-rw-r--r--deps/v8/test/cctest/heap/test-alloc.cc76
-rw-r--r--deps/v8/test/cctest/heap/test-array-buffer-tracker.cc6
-rw-r--r--deps/v8/test/cctest/heap/test-concurrent-marking.cc15
-rw-r--r--deps/v8/test/cctest/heap/test-external-string-tracker.cc6
-rw-r--r--deps/v8/test/cctest/heap/test-heap.cc89
-rw-r--r--deps/v8/test/cctest/heap/test-incremental-marking.cc51
-rw-r--r--deps/v8/test/cctest/heap/test-lab.cc2
-rw-r--r--deps/v8/test/cctest/heap/test-spaces.cc100
-rw-r--r--deps/v8/test/cctest/heap/test-unmapper.cc2
-rw-r--r--deps/v8/test/cctest/heap/test-weak-references.cc90
11 files changed, 194 insertions, 250 deletions
diff --git a/deps/v8/test/cctest/heap/heap-utils.cc b/deps/v8/test/cctest/heap/heap-utils.cc
index 5beed7f4cb..8f70847c9a 100644
--- a/deps/v8/test/cctest/heap/heap-utils.cc
+++ b/deps/v8/test/cctest/heap/heap-utils.cc
@@ -9,16 +9,15 @@
#include "src/heap/incremental-marking.h"
#include "src/heap/mark-compact.h"
#include "src/isolate.h"
+#include "test/cctest/cctest.h"
namespace v8 {
namespace internal {
namespace heap {
void SealCurrentObjects(Heap* heap) {
- heap->CollectAllGarbage(Heap::kFinalizeIncrementalMarkingMask,
- GarbageCollectionReason::kTesting);
- heap->CollectAllGarbage(Heap::kFinalizeIncrementalMarkingMask,
- GarbageCollectionReason::kTesting);
+ CcTest::CollectAllGarbage();
+ CcTest::CollectAllGarbage();
heap->mark_compact_collector()->EnsureSweepingCompleted();
heap->old_space()->FreeLinearAllocationArea();
for (Page* page : *heap->old_space()) {
diff --git a/deps/v8/test/cctest/heap/test-alloc.cc b/deps/v8/test/cctest/heap/test-alloc.cc
index 5a19f806bc..a669233b3a 100644
--- a/deps/v8/test/cctest/heap/test-alloc.cc
+++ b/deps/v8/test/cctest/heap/test-alloc.cc
@@ -168,84 +168,10 @@ TEST(StressJS) {
.ToLocalChecked()
->Run(env)
.ToLocalChecked();
- CHECK_EQ(true, result->BooleanValue(env).FromJust());
+ CHECK_EQ(true, result->BooleanValue(CcTest::isolate()));
env->Exit();
}
-
-// CodeRange test.
-// Tests memory management in a CodeRange by allocating and freeing blocks,
-// using a pseudorandom generator to choose block sizes geometrically
-// distributed between 2 * Page::kPageSize and 2^5 + 1 * Page::kPageSize.
-// Ensure that the freed chunks are collected and reused by allocating (in
-// total) more than the size of the CodeRange.
-
-// This pseudorandom generator does not need to be particularly good.
-// Use the lower half of the V8::Random() generator.
-unsigned int Pseudorandom() {
- static uint32_t lo = 2345;
- lo = 18273 * (lo & 0xFFFF) + (lo >> 16); // Provably not 0.
- return lo & 0xFFFF;
-}
-
-namespace {
-
-// Plain old data class. Represents a block of allocated memory.
-class Block {
- public:
- Block(Address base_arg, int size_arg)
- : base(base_arg), size(size_arg) {}
-
- Address base;
- int size;
-};
-
-} // namespace
-
-TEST(CodeRange) {
- const size_t code_range_size = 32*MB;
- CcTest::InitializeVM();
- CodeRange code_range(reinterpret_cast<Isolate*>(CcTest::isolate()),
- code_range_size);
- size_t current_allocated = 0;
- size_t total_allocated = 0;
- std::vector<Block> blocks;
- blocks.reserve(1000);
-
- while (total_allocated < 5 * code_range_size) {
- if (current_allocated < code_range_size / 10) {
- // Allocate a block.
- // Geometrically distributed sizes, greater than
- // kMaxRegularHeapObjectSize (which is greater than code page area).
- // TODO(gc): instead of using 3 use some contant based on code_range_size
- // kMaxRegularHeapObjectSize.
- size_t requested = (kMaxRegularHeapObjectSize << (Pseudorandom() % 3)) +
- Pseudorandom() % 5000 + 1;
- requested = RoundUp(requested, MemoryAllocator::GetCommitPageSize());
- size_t allocated = 0;
-
- // The request size has to be at least 2 code guard pages larger than the
- // actual commit size.
- Address base = code_range.AllocateRawMemory(
- requested, requested - (2 * MemoryAllocator::CodePageGuardSize()),
- &allocated);
- CHECK_NE(base, kNullAddress);
- blocks.emplace_back(base, static_cast<int>(allocated));
- current_allocated += static_cast<int>(allocated);
- total_allocated += static_cast<int>(allocated);
- } else {
- // Free a block.
- size_t index = Pseudorandom() % blocks.size();
- code_range.FreeRawMemory(blocks[index].base, blocks[index].size);
- current_allocated -= blocks[index].size;
- if (index < blocks.size() - 1) {
- blocks[index] = blocks.back();
- }
- blocks.pop_back();
- }
- }
-}
-
} // namespace heap
} // namespace internal
} // namespace v8
diff --git a/deps/v8/test/cctest/heap/test-array-buffer-tracker.cc b/deps/v8/test/cctest/heap/test-array-buffer-tracker.cc
index cb35a73126..272c8831fd 100644
--- a/deps/v8/test/cctest/heap/test-array-buffer-tracker.cc
+++ b/deps/v8/test/cctest/heap/test-array-buffer-tracker.cc
@@ -323,10 +323,8 @@ UNINITIALIZED_TEST(ArrayBuffer_SemiSpaceCopyMultipleTasks) {
Heap* heap = i_isolate->heap();
// Ensure heap is in a clean state.
- heap->CollectAllGarbage(Heap::kFinalizeIncrementalMarkingMask,
- GarbageCollectionReason::kTesting);
- heap->CollectAllGarbage(Heap::kFinalizeIncrementalMarkingMask,
- GarbageCollectionReason::kTesting);
+ CcTest::CollectAllGarbage(i_isolate);
+ CcTest::CollectAllGarbage(i_isolate);
Local<v8::ArrayBuffer> ab1 = v8::ArrayBuffer::New(isolate, 100);
Handle<JSArrayBuffer> buf1 = v8::Utils::OpenHandle(*ab1);
diff --git a/deps/v8/test/cctest/heap/test-concurrent-marking.cc b/deps/v8/test/cctest/heap/test-concurrent-marking.cc
index 0f10b1b9bd..d49ccf6213 100644
--- a/deps/v8/test/cctest/heap/test-concurrent-marking.cc
+++ b/deps/v8/test/cctest/heap/test-concurrent-marking.cc
@@ -39,9 +39,10 @@ TEST(ConcurrentMarking) {
}
ConcurrentMarking::MarkingWorklist shared, bailout, on_hold;
+ ConcurrentMarking::EmbedderTracingWorklist embedder_objects;
WeakObjects weak_objects;
- ConcurrentMarking* concurrent_marking =
- new ConcurrentMarking(heap, &shared, &bailout, &on_hold, &weak_objects);
+ ConcurrentMarking* concurrent_marking = new ConcurrentMarking(
+ heap, &shared, &bailout, &on_hold, &weak_objects, &embedder_objects);
PublishSegment(&shared, ReadOnlyRoots(heap).undefined_value());
concurrent_marking->ScheduleTasks();
concurrent_marking->Stop(
@@ -61,9 +62,10 @@ TEST(ConcurrentMarkingReschedule) {
}
ConcurrentMarking::MarkingWorklist shared, bailout, on_hold;
+ ConcurrentMarking::EmbedderTracingWorklist embedder_objects;
WeakObjects weak_objects;
- ConcurrentMarking* concurrent_marking =
- new ConcurrentMarking(heap, &shared, &bailout, &on_hold, &weak_objects);
+ ConcurrentMarking* concurrent_marking = new ConcurrentMarking(
+ heap, &shared, &bailout, &on_hold, &weak_objects, &embedder_objects);
PublishSegment(&shared, ReadOnlyRoots(heap).undefined_value());
concurrent_marking->ScheduleTasks();
concurrent_marking->Stop(
@@ -87,9 +89,10 @@ TEST(ConcurrentMarkingPreemptAndReschedule) {
}
ConcurrentMarking::MarkingWorklist shared, bailout, on_hold;
+ ConcurrentMarking::EmbedderTracingWorklist embedder_objects;
WeakObjects weak_objects;
- ConcurrentMarking* concurrent_marking =
- new ConcurrentMarking(heap, &shared, &bailout, &on_hold, &weak_objects);
+ ConcurrentMarking* concurrent_marking = new ConcurrentMarking(
+ heap, &shared, &bailout, &on_hold, &weak_objects, &embedder_objects);
for (int i = 0; i < 5000; i++)
PublishSegment(&shared, ReadOnlyRoots(heap).undefined_value());
concurrent_marking->ScheduleTasks();
diff --git a/deps/v8/test/cctest/heap/test-external-string-tracker.cc b/deps/v8/test/cctest/heap/test-external-string-tracker.cc
index 501825a296..cfade38da7 100644
--- a/deps/v8/test/cctest/heap/test-external-string-tracker.cc
+++ b/deps/v8/test/cctest/heap/test-external-string-tracker.cc
@@ -27,14 +27,14 @@ class TestOneByteResource : public v8::String::ExternalOneByteStringResource {
length_(strlen(data) - offset),
counter_(counter) {}
- ~TestOneByteResource() {
+ ~TestOneByteResource() override {
i::DeleteArray(orig_data_);
if (counter_ != nullptr) ++*counter_;
}
- const char* data() const { return data_; }
+ const char* data() const override { return data_; }
- size_t length() const { return length_; }
+ size_t length() const override { return length_; }
private:
const char* orig_data_;
diff --git a/deps/v8/test/cctest/heap/test-heap.cc b/deps/v8/test/cctest/heap/test-heap.cc
index f73f6f0195..8c6a3c446c 100644
--- a/deps/v8/test/cctest/heap/test-heap.cc
+++ b/deps/v8/test/cctest/heap/test-heap.cc
@@ -898,14 +898,14 @@ static const char* not_so_random_string_table[] = {
"volatile",
"while",
"with",
- 0
+ nullptr
};
-
static void CheckInternalizedStrings(const char** strings) {
Isolate* isolate = CcTest::i_isolate();
Factory* factory = isolate->factory();
- for (const char* string = *strings; *strings != 0; string = *strings++) {
+ for (const char* string = *strings; *strings != nullptr;
+ string = *strings++) {
HandleScope scope(isolate);
Handle<String> a =
isolate->factory()->InternalizeUtf8String(CStrVector(string));
@@ -2192,9 +2192,9 @@ HEAP_TEST(GCFlags) {
heap->set_current_gc_flags(Heap::kNoGCFlags);
CHECK_EQ(Heap::kNoGCFlags, heap->current_gc_flags_);
- // Set the flags to check whether we appropriately resets them after the GC.
- heap->set_current_gc_flags(Heap::kAbortIncrementalMarkingMask);
- CcTest::CollectAllGarbage(Heap::kReduceMemoryFootprintMask);
+ // Check whether we appropriately reset flags after GC.
+ CcTest::heap()->CollectAllGarbage(Heap::kReduceMemoryFootprintMask,
+ GarbageCollectionReason::kTesting);
CHECK_EQ(Heap::kNoGCFlags, heap->current_gc_flags_);
MarkCompactCollector* collector = heap->mark_compact_collector();
@@ -2212,7 +2212,7 @@ HEAP_TEST(GCFlags) {
// NewSpace scavenges should not overwrite the flags.
CHECK_NE(0, heap->current_gc_flags_ & Heap::kReduceMemoryFootprintMask);
- CcTest::CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
+ CcTest::CollectAllGarbage();
CHECK_EQ(Heap::kNoGCFlags, heap->current_gc_flags_);
}
@@ -3097,14 +3097,14 @@ TEST(IncrementalMarkingPreservesMonomorphicCallIC) {
CHECK_EQ(expected_slots, feedback_helper.slot_count());
int slot1 = 0;
int slot2 = 1;
- CHECK(feedback_vector->Get(feedback_helper.slot(slot1))->IsWeakHeapObject());
- CHECK(feedback_vector->Get(feedback_helper.slot(slot2))->IsWeakHeapObject());
+ CHECK(feedback_vector->Get(feedback_helper.slot(slot1))->IsWeak());
+ CHECK(feedback_vector->Get(feedback_helper.slot(slot2))->IsWeak());
heap::SimulateIncrementalMarking(CcTest::heap());
CcTest::CollectAllGarbage();
- feedback_vector->Get(feedback_helper.slot(slot1))->IsWeakHeapObject();
- feedback_vector->Get(feedback_helper.slot(slot2))->IsWeakHeapObject();
+ CHECK(feedback_vector->Get(feedback_helper.slot(slot1))->IsWeak());
+ CHECK(feedback_vector->Get(feedback_helper.slot(slot2))->IsWeak());
}
@@ -3134,12 +3134,12 @@ TEST(IncrementalMarkingPreservesMonomorphicConstructor) {
CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
Handle<FeedbackVector> vector(f->feedback_vector(), f->GetIsolate());
- CHECK(vector->Get(FeedbackSlot(0))->IsWeakOrClearedHeapObject());
+ CHECK(vector->Get(FeedbackSlot(0))->IsWeakOrCleared());
heap::SimulateIncrementalMarking(CcTest::heap());
CcTest::CollectAllGarbage();
- CHECK(vector->Get(FeedbackSlot(0))->IsWeakOrClearedHeapObject());
+ CHECK(vector->Get(FeedbackSlot(0))->IsWeakOrCleared());
}
TEST(IncrementalMarkingPreservesMonomorphicIC) {
@@ -3247,14 +3247,14 @@ class SourceResource : public v8::String::ExternalOneByteStringResource {
explicit SourceResource(const char* data)
: data_(data), length_(strlen(data)) { }
- virtual void Dispose() {
+ void Dispose() override {
i::DeleteArray(data_);
data_ = nullptr;
}
- const char* data() const { return data_; }
+ const char* data() const override { return data_; }
- size_t length() const { return length_; }
+ size_t length() const override { return length_; }
bool IsDisposed() { return data_ == nullptr; }
@@ -3636,9 +3636,9 @@ TEST(EnsureAllocationSiteDependentCodesProcessed) {
dependency->group() ==
DependentCode::kAllocationSiteTenuringChangedGroup);
CHECK_EQ(1, dependency->count());
- CHECK(dependency->object_at(0)->IsWeakHeapObject());
+ CHECK(dependency->object_at(0)->IsWeak());
Code* function_bar =
- Code::cast(dependency->object_at(0)->ToWeakHeapObject());
+ Code::cast(dependency->object_at(0)->GetHeapObjectAssumeWeak());
CHECK_EQ(bar_handle->code(), function_bar);
dependency = dependency->next_link();
dependency_group_count++;
@@ -3655,7 +3655,7 @@ TEST(EnsureAllocationSiteDependentCodesProcessed) {
// The site still exists because of our global handle, but the code is no
// longer referred to by dependent_code().
- CHECK(site->dependent_code()->object_at(0)->IsClearedWeakHeapObject());
+ CHECK(site->dependent_code()->object_at(0)->IsCleared());
}
void CheckNumberOfAllocations(Heap* heap, const char* source,
@@ -4133,18 +4133,18 @@ TEST(WeakFunctionInConstructor) {
Handle<FeedbackVector>(createObj->feedback_vector(), CcTest::i_isolate());
for (int i = 0; i < 20; i++) {
MaybeObject* slot_value = feedback_vector->Get(FeedbackSlot(0));
- CHECK(slot_value->IsWeakOrClearedHeapObject());
- if (slot_value->IsClearedWeakHeapObject()) break;
+ CHECK(slot_value->IsWeakOrCleared());
+ if (slot_value->IsCleared()) break;
CcTest::CollectAllGarbage();
}
MaybeObject* slot_value = feedback_vector->Get(FeedbackSlot(0));
- CHECK(slot_value->IsClearedWeakHeapObject());
+ CHECK(slot_value->IsCleared());
CompileRun(
"function coat() { this.x = 6; }"
"createObj(coat);");
slot_value = feedback_vector->Get(FeedbackSlot(0));
- CHECK(slot_value->IsWeakHeapObject());
+ CHECK(slot_value->IsWeak());
}
@@ -4511,8 +4511,7 @@ HEAP_TEST(Regress538257) {
heap::ForceEvacuationCandidate(Page::FromAddress(objects[i]->address()));
}
heap::SimulateFullSpace(old_space);
- heap->CollectAllGarbage(i::Heap::kFinalizeIncrementalMarkingMask,
- i::GarbageCollectionReason::kTesting);
+ CcTest::CollectAllGarbage();
// If we get this far, we've successfully aborted compaction. Any further
// allocations might trigger OOM.
}
@@ -4704,7 +4703,7 @@ TEST(Regress3877) {
v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(result));
weak_prototype_holder->Set(0, HeapObjectReference::Weak(*proto));
}
- CHECK(!weak_prototype_holder->Get(0)->IsClearedWeakHeapObject());
+ CHECK(!weak_prototype_holder->Get(0)->IsCleared());
CompileRun(
"var a = { };"
"a.x = new cls();"
@@ -4713,13 +4712,13 @@ TEST(Regress3877) {
CcTest::CollectAllGarbage();
}
// The map of a.x keeps prototype alive
- CHECK(!weak_prototype_holder->Get(0)->IsClearedWeakHeapObject());
+ CHECK(!weak_prototype_holder->Get(0)->IsCleared());
// Change the map of a.x and make the previous map garbage collectable.
CompileRun("a.x.__proto__ = {};");
for (int i = 0; i < 4; i++) {
CcTest::CollectAllGarbage();
}
- CHECK(weak_prototype_holder->Get(0)->IsClearedWeakHeapObject());
+ CHECK(weak_prototype_holder->Get(0)->IsCleared());
}
Handle<WeakFixedArray> AddRetainedMap(Isolate* isolate, Heap* heap) {
@@ -4742,15 +4741,15 @@ void CheckMapRetainingFor(int n) {
Isolate* isolate = CcTest::i_isolate();
Heap* heap = isolate->heap();
Handle<WeakFixedArray> array_with_map = AddRetainedMap(isolate, heap);
- CHECK(array_with_map->Get(0)->IsWeakHeapObject());
+ CHECK(array_with_map->Get(0)->IsWeak());
for (int i = 0; i < n; i++) {
heap::SimulateIncrementalMarking(heap);
CcTest::CollectGarbage(OLD_SPACE);
}
- CHECK(array_with_map->Get(0)->IsWeakHeapObject());
+ CHECK(array_with_map->Get(0)->IsWeak());
heap::SimulateIncrementalMarking(heap);
CcTest::CollectGarbage(OLD_SPACE);
- CHECK(array_with_map->Get(0)->IsClearedWeakHeapObject());
+ CHECK(array_with_map->Get(0)->IsCleared());
}
@@ -4766,8 +4765,8 @@ TEST(MapRetaining) {
}
TEST(WritableVsImmortalRoots) {
- for (int i = 0; i < Heap::kStrongRootListLength; ++i) {
- Heap::RootListIndex root_index = static_cast<Heap::RootListIndex>(i);
+ for (RootIndex root_index = RootIndex::kFirstRoot;
+ root_index <= RootIndex::kLastRoot; ++root_index) {
bool writable = Heap::RootCanBeWrittenAfterInitialization(root_index);
bool immortal = Heap::RootIsImmortalImmovable(root_index);
// A root value can be writable, immortal, or neither, but not both.
@@ -5427,11 +5426,11 @@ class StaticOneByteResource : public v8::String::ExternalOneByteStringResource {
public:
explicit StaticOneByteResource(const char* data) : data_(data) {}
- ~StaticOneByteResource() {}
+ ~StaticOneByteResource() override = default;
- const char* data() const { return data_; }
+ const char* data() const override { return data_; }
- size_t length() const { return strlen(data_); }
+ size_t length() const override { return strlen(data_); }
private:
const char* data_;
@@ -5676,6 +5675,7 @@ TEST(Regress618958) {
}
TEST(YoungGenerationLargeObjectAllocation) {
+ if (FLAG_minor_mc) return;
FLAG_young_generation_large_objects = true;
CcTest::InitializeVM();
v8::HandleScope scope(CcTest::isolate());
@@ -5684,13 +5684,26 @@ TEST(YoungGenerationLargeObjectAllocation) {
Handle<FixedArray> array = isolate->factory()->NewFixedArray(200000);
MemoryChunk* chunk = MemoryChunk::FromAddress(array->address());
- CHECK(chunk->owner()->identity() == LO_SPACE);
+ CHECK_EQ(LO_SPACE, chunk->owner()->identity());
CHECK(!chunk->IsFlagSet(MemoryChunk::IN_TO_SPACE));
Handle<FixedArray> array_small = isolate->factory()->NewFixedArray(20000);
chunk = MemoryChunk::FromAddress(array_small->address());
- CHECK(chunk->owner()->identity() == NEW_LO_SPACE);
+ CHECK_EQ(NEW_LO_SPACE, chunk->owner()->identity());
CHECK(chunk->IsFlagSet(MemoryChunk::IN_TO_SPACE));
+
+ Handle<Object> number = isolate->factory()->NewHeapNumber(123.456);
+ array_small->set(0, *number);
+
+ CcTest::CollectGarbage(NEW_SPACE);
+
+ // After the first young generation GC array_small will be in the old
+ // generation large object space.
+ chunk = MemoryChunk::FromAddress(array_small->address());
+ CHECK_EQ(LO_SPACE, chunk->owner()->identity());
+ CHECK(!chunk->IsFlagSet(MemoryChunk::IN_TO_SPACE));
+
+ CcTest::CollectAllAvailableGarbage();
}
TEST(UncommitUnusedLargeObjectMemory) {
diff --git a/deps/v8/test/cctest/heap/test-incremental-marking.cc b/deps/v8/test/cctest/heap/test-incremental-marking.cc
index bbf630f0ba..8213ea6080 100644
--- a/deps/v8/test/cctest/heap/test-incremental-marking.cc
+++ b/deps/v8/test/cctest/heap/test-incremental-marking.cc
@@ -33,12 +33,13 @@ namespace heap {
class MockPlatform : public TestPlatform {
public:
- MockPlatform() : task_(nullptr), old_platform_(i::V8::GetCurrentPlatform()) {
+ MockPlatform()
+ : taskrunner_(new MockTaskRunner()),
+ old_platform_(i::V8::GetCurrentPlatform()) {
// Now that it's completely constructed, make this the current platform.
i::V8::SetPlatformForTesting(this);
}
- virtual ~MockPlatform() {
- delete task_;
+ ~MockPlatform() override {
i::V8::SetPlatformForTesting(old_platform_);
for (auto& task : worker_tasks_) {
old_platform_->CallOnWorkerThread(std::move(task));
@@ -46,8 +47,9 @@ class MockPlatform : public TestPlatform {
worker_tasks_.clear();
}
- void CallOnForegroundThread(v8::Isolate* isolate, Task* task) override {
- task_ = task;
+ std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
+ v8::Isolate* isolate) override {
+ return taskrunner_;
}
void CallOnWorkerThread(std::unique_ptr<Task> task) override {
@@ -56,17 +58,40 @@ class MockPlatform : public TestPlatform {
bool IdleTasksEnabled(v8::Isolate* isolate) override { return false; }
- bool PendingTask() { return task_ != nullptr; }
+ bool PendingTask() { return taskrunner_->PendingTask(); }
- void PerformTask() {
- Task* task = task_;
- task_ = nullptr;
- task->Run();
- delete task;
- }
+ void PerformTask() { taskrunner_->PerformTask(); }
private:
- Task* task_;
+ class MockTaskRunner : public v8::TaskRunner {
+ public:
+ void PostTask(std::unique_ptr<v8::Task> task) override {
+ task_ = std::move(task);
+ }
+
+ void PostDelayedTask(std::unique_ptr<Task> task,
+ double delay_in_seconds) override {
+ UNREACHABLE();
+ };
+
+ void PostIdleTask(std::unique_ptr<IdleTask> task) override {
+ UNREACHABLE();
+ }
+
+ bool IdleTasksEnabled() override { return false; };
+
+ bool PendingTask() { return task_ != nullptr; }
+
+ void PerformTask() {
+ std::unique_ptr<Task> task = std::move(task_);
+ task->Run();
+ }
+
+ private:
+ std::unique_ptr<Task> task_;
+ };
+
+ std::shared_ptr<MockTaskRunner> taskrunner_;
std::vector<std::unique_ptr<Task>> worker_tasks_;
v8::Platform* old_platform_;
};
diff --git a/deps/v8/test/cctest/heap/test-lab.cc b/deps/v8/test/cctest/heap/test-lab.cc
index 42a3eec04c..ae0bfd969a 100644
--- a/deps/v8/test/cctest/heap/test-lab.cc
+++ b/deps/v8/test/cctest/heap/test-lab.cc
@@ -63,7 +63,7 @@ TEST(InvalidLab) {
TEST(UnusedLabImplicitClose) {
CcTest::InitializeVM();
Heap* heap = CcTest::heap();
- heap->root(Heap::kOnePointerFillerMapRootIndex);
+ heap->root(RootIndex::kOnePointerFillerMap);
const int kLabSize = 4 * KB;
Address base = AllocateLabBackingStore(heap, kLabSize);
Address limit = base + kLabSize;
diff --git a/deps/v8/test/cctest/heap/test-spaces.cc b/deps/v8/test/cctest/heap/test-spaces.cc
index b930361eb9..e03d8229b3 100644
--- a/deps/v8/test/cctest/heap/test-spaces.cc
+++ b/deps/v8/test/cctest/heap/test-spaces.cc
@@ -27,6 +27,7 @@
#include <stdlib.h>
+#include "src/base/bounded-page-allocator.h"
#include "src/base/platform/platform.h"
#include "src/heap/factory.h"
#include "src/heap/spaces-inl.h"
@@ -59,36 +60,43 @@ class TestMemoryAllocatorScope {
DISALLOW_COPY_AND_ASSIGN(TestMemoryAllocatorScope);
};
-
-// Temporarily sets a given code range in an isolate.
-class TestCodeRangeScope {
+// Temporarily sets a given code page allocator in an isolate.
+class TestCodePageAllocatorScope {
public:
- TestCodeRangeScope(Isolate* isolate, CodeRange* code_range)
+ TestCodePageAllocatorScope(Isolate* isolate,
+ v8::PageAllocator* code_page_allocator)
: isolate_(isolate),
- old_code_range_(isolate->heap()->memory_allocator()->code_range()) {
- isolate->heap()->memory_allocator()->code_range_ = code_range;
+ old_code_page_allocator_(
+ isolate->heap()->memory_allocator()->code_page_allocator()) {
+ isolate->heap()->memory_allocator()->code_page_allocator_ =
+ code_page_allocator;
}
- ~TestCodeRangeScope() {
- isolate_->heap()->memory_allocator()->code_range_ = old_code_range_;
+ ~TestCodePageAllocatorScope() {
+ isolate_->heap()->memory_allocator()->code_page_allocator_ =
+ old_code_page_allocator_;
}
private:
Isolate* isolate_;
- CodeRange* old_code_range_;
+ v8::PageAllocator* old_code_page_allocator_;
- DISALLOW_COPY_AND_ASSIGN(TestCodeRangeScope);
+ DISALLOW_COPY_AND_ASSIGN(TestCodePageAllocatorScope);
};
static void VerifyMemoryChunk(Isolate* isolate, Heap* heap,
- CodeRange* code_range, size_t reserve_area_size,
- size_t commit_area_size, Executability executable,
- Space* space) {
+ v8::PageAllocator* code_page_allocator,
+ size_t reserve_area_size, size_t commit_area_size,
+ Executability executable, Space* space) {
MemoryAllocator* memory_allocator =
new MemoryAllocator(isolate, heap->MaxReserved(), 0);
{
TestMemoryAllocatorScope test_allocator_scope(isolate, memory_allocator);
- TestCodeRangeScope test_code_range_scope(isolate, code_range);
+ TestCodePageAllocatorScope test_code_page_allocator_scope(
+ isolate, code_page_allocator);
+
+ v8::PageAllocator* page_allocator =
+ memory_allocator->page_allocator(executable);
size_t header_size = (executable == EXECUTABLE)
? MemoryAllocator::CodePageGuardStartOffset()
@@ -98,14 +106,12 @@ static void VerifyMemoryChunk(Isolate* isolate, Heap* heap,
MemoryChunk* memory_chunk = memory_allocator->AllocateChunk(
reserve_area_size, commit_area_size, executable, space);
- size_t alignment = code_range != nullptr && code_range->valid()
- ? MemoryChunk::kAlignment
- : CommitPageSize();
size_t reserved_size =
((executable == EXECUTABLE))
? RoundUp(header_size + guard_size + reserve_area_size + guard_size,
- alignment)
- : RoundUp(header_size + reserve_area_size, CommitPageSize());
+ page_allocator->CommitPageSize())
+ : RoundUp(header_size + reserve_area_size,
+ page_allocator->CommitPageSize());
CHECK(memory_chunk->size() == reserved_size);
CHECK(memory_chunk->area_start() <
memory_chunk->address() + memory_chunk->size());
@@ -119,38 +125,6 @@ static void VerifyMemoryChunk(Isolate* isolate, Heap* heap,
delete memory_allocator;
}
-TEST(Regress3540) {
- Isolate* isolate = CcTest::i_isolate();
- Heap* heap = isolate->heap();
- MemoryAllocator* memory_allocator =
- new MemoryAllocator(isolate, heap->MaxReserved(), 0);
- TestMemoryAllocatorScope test_allocator_scope(isolate, memory_allocator);
- size_t code_range_size =
- kMinimumCodeRangeSize > 0 ? kMinimumCodeRangeSize : 3 * Page::kPageSize;
- CodeRange* code_range = new CodeRange(isolate, code_range_size);
-
- Address address;
- size_t size;
- size_t request_size = code_range_size - Page::kPageSize;
- address = code_range->AllocateRawMemory(
- request_size, request_size - (2 * MemoryAllocator::CodePageGuardSize()),
- &size);
- CHECK_NE(address, kNullAddress);
-
- Address null_address;
- size_t null_size;
- request_size = code_range_size - Page::kPageSize;
- null_address = code_range->AllocateRawMemory(
- request_size, request_size - (2 * MemoryAllocator::CodePageGuardSize()),
- &null_size);
- CHECK_EQ(null_address, kNullAddress);
-
- code_range->FreeRawMemory(address, size);
- delete code_range;
- memory_allocator->TearDown();
- delete memory_allocator;
-}
-
static unsigned int PseudorandomAreaSize() {
static uint32_t lo = 2345;
lo = 18273 * (lo & 0xFFFFF) + (lo >> 16);
@@ -162,24 +136,31 @@ TEST(MemoryChunk) {
Isolate* isolate = CcTest::i_isolate();
Heap* heap = isolate->heap();
+ v8::PageAllocator* page_allocator = GetPlatformPageAllocator();
+
size_t reserve_area_size = 1 * MB;
size_t initial_commit_area_size;
for (int i = 0; i < 100; i++) {
initial_commit_area_size =
- RoundUp(PseudorandomAreaSize(), CommitPageSize());
+ RoundUp(PseudorandomAreaSize(), page_allocator->CommitPageSize());
// With CodeRange.
const size_t code_range_size = 32 * MB;
- CodeRange* code_range = new CodeRange(isolate, code_range_size);
+ VirtualMemory code_range_reservation(page_allocator, code_range_size,
+ nullptr, MemoryChunk::kAlignment);
+ CHECK(code_range_reservation.IsReserved());
+
+ base::BoundedPageAllocator code_page_allocator(
+ page_allocator, code_range_reservation.address(),
+ code_range_reservation.size(), MemoryChunk::kAlignment);
- VerifyMemoryChunk(isolate, heap, code_range, reserve_area_size,
+ VerifyMemoryChunk(isolate, heap, &code_page_allocator, reserve_area_size,
initial_commit_area_size, EXECUTABLE, heap->code_space());
- VerifyMemoryChunk(isolate, heap, code_range, reserve_area_size,
+ VerifyMemoryChunk(isolate, heap, &code_page_allocator, reserve_area_size,
initial_commit_area_size, NOT_EXECUTABLE,
heap->old_space());
- delete code_range;
}
}
@@ -240,7 +221,8 @@ TEST(NewSpace) {
new MemoryAllocator(isolate, heap->MaxReserved(), 0);
TestMemoryAllocatorScope test_scope(isolate, memory_allocator);
- NewSpace new_space(heap, CcTest::heap()->InitialSemiSpaceSize(),
+ NewSpace new_space(heap, memory_allocator->data_page_allocator(),
+ CcTest::heap()->InitialSemiSpaceSize(),
CcTest::heap()->InitialSemiSpaceSize());
CHECK(new_space.MaximumCapacity());
@@ -522,9 +504,7 @@ UNINITIALIZED_TEST(InlineAllocationObserverCadence) {
// Clear out any pre-existing garbage to make the test consistent
// across snapshot/no-snapshot builds.
- i_isolate->heap()->CollectAllGarbage(
- i::Heap::kFinalizeIncrementalMarkingMask,
- i::GarbageCollectionReason::kTesting);
+ CcTest::CollectAllGarbage(i_isolate);
NewSpace* new_space = i_isolate->heap()->new_space();
diff --git a/deps/v8/test/cctest/heap/test-unmapper.cc b/deps/v8/test/cctest/heap/test-unmapper.cc
index 880c54457c..1fbe5c1f5c 100644
--- a/deps/v8/test/cctest/heap/test-unmapper.cc
+++ b/deps/v8/test/cctest/heap/test-unmapper.cc
@@ -23,7 +23,7 @@ class MockPlatformForUnmapper : public TestPlatform {
// Now that it's completely constructed, make this the current platform.
i::V8::SetPlatformForTesting(this);
}
- virtual ~MockPlatformForUnmapper() {
+ ~MockPlatformForUnmapper() override {
delete task_;
i::V8::SetPlatformForTesting(old_platform_);
for (auto& task : worker_tasks_) {
diff --git a/deps/v8/test/cctest/heap/test-weak-references.cc b/deps/v8/test/cctest/heap/test-weak-references.cc
index a54b13afd2..bbe4776b93 100644
--- a/deps/v8/test/cctest/heap/test-weak-references.cc
+++ b/deps/v8/test/cctest/heap/test-weak-references.cc
@@ -62,19 +62,19 @@ TEST(WeakReferencesBasic) {
fv->set_optimized_code_weak_or_smi(HeapObjectReference::Weak(*code));
HeapObject* code_heap_object;
- CHECK(
- fv->optimized_code_weak_or_smi()->ToWeakHeapObject(&code_heap_object));
+ CHECK(fv->optimized_code_weak_or_smi()->GetHeapObjectIfWeak(
+ &code_heap_object));
CHECK_EQ(*code, code_heap_object);
CcTest::CollectAllGarbage();
- CHECK(
- fv->optimized_code_weak_or_smi()->ToWeakHeapObject(&code_heap_object));
+ CHECK(fv->optimized_code_weak_or_smi()->GetHeapObjectIfWeak(
+ &code_heap_object));
CHECK_EQ(*code, code_heap_object);
} // code will go out of scope.
CcTest::CollectAllGarbage();
- CHECK(fv->optimized_code_weak_or_smi()->IsClearedWeakHeapObject());
+ CHECK(fv->optimized_code_weak_or_smi()->IsCleared());
}
TEST(WeakReferencesOldToOld) {
@@ -103,7 +103,7 @@ TEST(WeakReferencesOldToOld) {
CHECK(heap->InOldSpace(*fixed_array));
HeapObject* heap_object;
- CHECK(fv->optimized_code_weak_or_smi()->ToWeakHeapObject(&heap_object));
+ CHECK(fv->optimized_code_weak_or_smi()->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(heap_object, *fixed_array);
}
@@ -128,7 +128,7 @@ TEST(WeakReferencesOldToNew) {
CcTest::CollectAllGarbage();
HeapObject* heap_object;
- CHECK(fv->optimized_code_weak_or_smi()->ToWeakHeapObject(&heap_object));
+ CHECK(fv->optimized_code_weak_or_smi()->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(heap_object, *fixed_array);
}
@@ -153,7 +153,7 @@ TEST(WeakReferencesOldToNewScavenged) {
CcTest::CollectGarbage(NEW_SPACE);
HeapObject* heap_object;
- CHECK(fv->optimized_code_weak_or_smi()->ToWeakHeapObject(&heap_object));
+ CHECK(fv->optimized_code_weak_or_smi()->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(heap_object, *fixed_array);
}
@@ -174,7 +174,7 @@ TEST(WeakReferencesOldToCleared) {
fv->set_optimized_code_weak_or_smi(HeapObjectReference::ClearedValue());
CcTest::CollectAllGarbage();
- CHECK(fv->optimized_code_weak_or_smi()->IsClearedWeakHeapObject());
+ CHECK(fv->optimized_code_weak_or_smi()->IsCleared());
}
TEST(ObjectMovesBeforeClearingWeakField) {
@@ -210,11 +210,11 @@ TEST(ObjectMovesBeforeClearingWeakField) {
CcTest::CollectGarbage(NEW_SPACE);
FeedbackVector* new_fv_location = *fv;
CHECK_NE(fv_location, new_fv_location);
- CHECK(fv->optimized_code_weak_or_smi()->IsWeakHeapObject());
+ CHECK(fv->optimized_code_weak_or_smi()->IsWeak());
// Now we try to clear *fv.
CcTest::CollectAllGarbage();
- CHECK(fv->optimized_code_weak_or_smi()->IsClearedWeakHeapObject());
+ CHECK(fv->optimized_code_weak_or_smi()->IsCleared());
}
TEST(ObjectWithWeakFieldDies) {
@@ -277,7 +277,7 @@ TEST(ObjectWithWeakReferencePromoted) {
CHECK(heap->InOldSpace(*fixed_array));
HeapObject* heap_object;
- CHECK(fv->optimized_code_weak_or_smi()->ToWeakHeapObject(&heap_object));
+ CHECK(fv->optimized_code_weak_or_smi()->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(heap_object, *fixed_array);
}
@@ -296,14 +296,14 @@ TEST(ObjectWithClearedWeakReferencePromoted) {
CcTest::CollectGarbage(NEW_SPACE);
CHECK(Heap::InNewSpace(*fv));
- CHECK(fv->optimized_code_weak_or_smi()->IsClearedWeakHeapObject());
+ CHECK(fv->optimized_code_weak_or_smi()->IsCleared());
CcTest::CollectGarbage(NEW_SPACE);
CHECK(heap->InOldSpace(*fv));
- CHECK(fv->optimized_code_weak_or_smi()->IsClearedWeakHeapObject());
+ CHECK(fv->optimized_code_weak_or_smi()->IsCleared());
CcTest::CollectAllGarbage();
- CHECK(fv->optimized_code_weak_or_smi()->IsClearedWeakHeapObject());
+ CHECK(fv->optimized_code_weak_or_smi()->IsCleared());
}
TEST(WeakReferenceWriteBarrier) {
@@ -343,7 +343,7 @@ TEST(WeakReferenceWriteBarrier) {
CcTest::CollectAllGarbage();
// Check that the write barrier treated the weak reference as strong.
- CHECK(fv->optimized_code_weak_or_smi()->IsWeakHeapObject());
+ CHECK(fv->optimized_code_weak_or_smi()->IsWeak());
}
TEST(EmptyWeakArray) {
@@ -375,7 +375,7 @@ TEST(WeakArraysBasic) {
for (int i = 0; i < length; ++i) {
HeapObject* heap_object;
- CHECK(array->Get(i)->ToStrongHeapObject(&heap_object));
+ CHECK(array->Get(i)->GetHeapObjectIfStrong(&heap_object));
CHECK_EQ(heap_object, ReadOnlyRoots(heap).undefined_value());
}
@@ -407,23 +407,23 @@ TEST(WeakArraysBasic) {
// space.
CcTest::CollectGarbage(NEW_SPACE);
HeapObject* heap_object;
- CHECK(array->Get(0)->ToWeakHeapObject(&heap_object));
+ CHECK(array->Get(0)->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(Smi::cast(FixedArray::cast(heap_object)->get(0))->value(), 2016);
- CHECK(array->Get(1)->ToWeakHeapObject(&heap_object));
+ CHECK(array->Get(1)->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(Smi::cast(FixedArray::cast(heap_object)->get(0))->value(), 2017);
- CHECK(array->Get(2)->ToStrongHeapObject(&heap_object));
+ CHECK(array->Get(2)->GetHeapObjectIfStrong(&heap_object));
CHECK_EQ(Smi::cast(FixedArray::cast(heap_object)->get(0))->value(), 2018);
- CHECK(array->Get(3)->ToWeakHeapObject(&heap_object));
+ CHECK(array->Get(3)->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(Smi::cast(FixedArray::cast(heap_object)->get(0))->value(), 2019);
CcTest::CollectAllGarbage();
CHECK(heap->InOldSpace(*array));
- CHECK(array->Get(0)->IsClearedWeakHeapObject());
- CHECK(array->Get(1)->ToWeakHeapObject(&heap_object));
+ CHECK(array->Get(0)->IsCleared());
+ CHECK(array->Get(1)->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(Smi::cast(FixedArray::cast(heap_object)->get(0))->value(), 2017);
- CHECK(array->Get(2)->ToStrongHeapObject(&heap_object));
+ CHECK(array->Get(2)->GetHeapObjectIfStrong(&heap_object));
CHECK_EQ(Smi::cast(FixedArray::cast(heap_object)->get(0))->value(), 2018);
- CHECK(array->Get(3)->IsClearedWeakHeapObject());
+ CHECK(array->Get(3)->IsCleared());
}
TEST(WeakArrayListBasic) {
@@ -481,13 +481,13 @@ TEST(WeakArrayListBasic) {
CHECK(Heap::InNewSpace(*array));
CHECK_EQ(array->Get(0), HeapObjectReference::Weak(*index0));
- CHECK_EQ(Smi::ToInt(array->Get(1)->ToSmi()), 1);
+ CHECK_EQ(Smi::ToInt(array->Get(1)->cast<Smi>()), 1);
CHECK_EQ(array->Get(2), HeapObjectReference::Weak(*index2));
- CHECK_EQ(Smi::ToInt(array->Get(3)->ToSmi()), 3);
+ CHECK_EQ(Smi::ToInt(array->Get(3)->cast<Smi>()), 3);
CHECK_EQ(array->Get(4), HeapObjectReference::Weak(*index4));
- CHECK_EQ(Smi::ToInt(array->Get(5)->ToSmi()), 5);
+ CHECK_EQ(Smi::ToInt(array->Get(5)->cast<Smi>()), 5);
CHECK_EQ(array->Get(6), HeapObjectReference::Weak(*index6));
array = inner_scope.CloseAndEscape(array);
@@ -502,37 +502,37 @@ TEST(WeakArrayListBasic) {
CcTest::CollectGarbage(NEW_SPACE);
HeapObject* heap_object;
CHECK_EQ(array->length(), 8);
- CHECK(array->Get(0)->ToWeakHeapObject(&heap_object));
+ CHECK(array->Get(0)->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(Smi::cast(FixedArray::cast(heap_object)->get(0))->value(), 2016);
- CHECK_EQ(Smi::ToInt(array->Get(1)->ToSmi()), 1);
+ CHECK_EQ(Smi::ToInt(array->Get(1)->cast<Smi>()), 1);
- CHECK(array->Get(2)->ToWeakHeapObject(&heap_object));
+ CHECK(array->Get(2)->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(Smi::cast(FixedArray::cast(heap_object)->get(0))->value(), 2017);
- CHECK_EQ(Smi::ToInt(array->Get(3)->ToSmi()), 3);
+ CHECK_EQ(Smi::ToInt(array->Get(3)->cast<Smi>()), 3);
- CHECK(array->Get(4)->ToWeakHeapObject(&heap_object));
+ CHECK(array->Get(4)->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(Smi::cast(FixedArray::cast(heap_object)->get(0))->value(), 2018);
- CHECK_EQ(Smi::ToInt(array->Get(5)->ToSmi()), 5);
+ CHECK_EQ(Smi::ToInt(array->Get(5)->cast<Smi>()), 5);
- CHECK(array->Get(6)->ToWeakHeapObject(&heap_object));
+ CHECK(array->Get(6)->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(Smi::cast(FixedArray::cast(heap_object)->get(0))->value(), 2019);
- CHECK_EQ(Smi::ToInt(array->Get(7)->ToSmi()), 7);
+ CHECK_EQ(Smi::ToInt(array->Get(7)->cast<Smi>()), 7);
CcTest::CollectAllGarbage();
CHECK(heap->InOldSpace(*array));
CHECK_EQ(array->length(), 8);
- CHECK(array->Get(0)->IsClearedWeakHeapObject());
- CHECK_EQ(Smi::ToInt(array->Get(1)->ToSmi()), 1);
+ CHECK(array->Get(0)->IsCleared());
+ CHECK_EQ(Smi::ToInt(array->Get(1)->cast<Smi>()), 1);
- CHECK(array->Get(2)->ToWeakHeapObject(&heap_object));
+ CHECK(array->Get(2)->GetHeapObjectIfWeak(&heap_object));
CHECK_EQ(Smi::cast(FixedArray::cast(heap_object)->get(0))->value(), 2017);
- CHECK_EQ(Smi::ToInt(array->Get(3)->ToSmi()), 3);
+ CHECK_EQ(Smi::ToInt(array->Get(3)->cast<Smi>()), 3);
- CHECK(array->Get(4)->IsClearedWeakHeapObject());
- CHECK_EQ(Smi::ToInt(array->Get(5)->ToSmi()), 5);
+ CHECK(array->Get(4)->IsCleared());
+ CHECK_EQ(Smi::ToInt(array->Get(5)->cast<Smi>()), 5);
- CHECK(array->Get(6)->IsClearedWeakHeapObject());
- CHECK_EQ(Smi::ToInt(array->Get(7)->ToSmi()), 7);
+ CHECK(array->Get(6)->IsCleared());
+ CHECK_EQ(Smi::ToInt(array->Get(7)->cast<Smi>()), 7);
}
TEST(WeakArrayListRemove) {
@@ -753,7 +753,7 @@ TEST(PrototypeUsersCompacted) {
PrototypeUsers::MarkSlotEmpty(*array, 1);
CcTest::CollectAllGarbage();
- CHECK(array->Get(3)->IsClearedWeakHeapObject());
+ CHECK(array->Get(3)->IsCleared());
CHECK_EQ(array->length(), 3 + PrototypeUsers::kFirstIndex);
WeakArrayList* new_array =
View Lorry Controller Status