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

Reland "[heap] Provide ObjectMarking with marking transitions"

Browse Source 
BUG=chromium:651354

Review-Url: https://codereview.chromium.org/2637403011
Cr-Commit-Position: refs/heads/master@{#42555}
This commit is contained in:
mlippautz 2017-01-20 05:18:43 -08:00 committed by Commit bot
parent d02ca3625f
commit 0659898b3e
11 changed files with 194 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -19,8 +19,7 @@ void LocalArrayBufferTracker::Free() {
for (TrackingData::iterator it = array_buffers_.begin();
it != array_buffers_.end();) {
JSArrayBuffer* buffer = reinterpret_cast<JSArrayBuffer*>(it->first);
if ((free_mode == kFreeAll) ||
Marking::IsWhite(ObjectMarking::MarkBitFrom(buffer))) {
if ((free_mode == kFreeAll) || ObjectMarking::IsWhite(buffer)) {
const size_t len = it->second;
heap_->isolate()->array_buffer_allocator()->Free(buffer->backing_store(),
len);

37
src/heap/heap.cc
View File

@ -3183,7 +3183,7 @@ void Heap::AdjustLiveBytes(HeapObject* object, int by) {
lo_space()->AdjustLiveBytes(by);
} else if (!in_heap_iterator() &&
!mark_compact_collector()->sweeping_in_progress() &&
Marking::IsBlack(ObjectMarking::MarkBitFrom(object))) {
ObjectMarking::IsBlack(object)) {
DCHECK(MemoryChunk::FromAddress(object->address())->SweepingDone());
MemoryChunk::IncrementLiveBytes(object, by);
}
@ -3193,6 +3193,7 @@ void Heap::AdjustLiveBytes(HeapObject* object, int by) {
FixedArrayBase* Heap::LeftTrimFixedArray(FixedArrayBase* object,
int elements_to_trim) {
CHECK_NOT_NULL(object);
DCHECK(CanMoveObjectStart(object));
DCHECK(!object->IsFixedTypedArrayBase());
DCHECK(!object->IsByteArray());
const int element_size = object->IsFixedArray() ? kPointerSize : kDoubleSize;
@ -3243,7 +3244,6 @@ FixedArrayBase* Heap::LeftTrimFixedArray(FixedArrayBase* object,
// Initialize header of the trimmed array. Since left trimming is only
// performed on pages which are not concurrently swept creating a filler
// object does not require synchronization.
DCHECK(CanMoveObjectStart(object));
Object** former_start = HeapObject::RawField(object, 0);
int new_start_index = elements_to_trim * (element_size / kPointerSize);
former_start[new_start_index] = map;
@ -3314,7 +3314,7 @@ void Heap::RightTrimFixedArray(FixedArrayBase* object, int elements_to_trim) {
// Clear the mark bits of the black area that belongs now to the filler.
// This is an optimization. The sweeper will release black fillers anyway.
if (incremental_marking()->black_allocation() &&
Marking::IsBlackOrGrey(ObjectMarking::MarkBitFrom(filler))) {
ObjectMarking::IsBlackOrGrey(filler)) {
Page* page = Page::FromAddress(new_end);
page->markbits()->ClearRange(
page->AddressToMarkbitIndex(new_end),
@ -4305,28 +4305,21 @@ void Heap::RegisterReservationsForBlackAllocation(Reservation* reservations) {
// for marking. We just have to execute the special visiting side effect
// code that adds objects to global data structures, e.g. for array buffers.
// Code space, map space, and large object space do not use black pages.
// Hence we have to color all objects of the reservation first black to avoid
// unnecessary marking deque load.
if (incremental_marking()->black_allocation()) {
// Iterate black objects in old space, code space, map space, and large
// object space for side effects.
for (int i = OLD_SPACE; i < Serializer::kNumberOfSpaces; i++) {
const Heap::Reservation& res = reservations[i];
for (auto& chunk : res) {
Address addr = chunk.start;
while (addr < chunk.end) {
HeapObject* obj = HeapObject::FromAddress(addr);
Marking::MarkBlack(ObjectMarking::MarkBitFrom(obj));
addr += obj->Size();
}
}
}
for (int i = OLD_SPACE; i < Serializer::kNumberOfSpaces; i++) {
const Heap::Reservation& res = reservations[i];
for (auto& chunk : res) {
Address addr = chunk.start;
while (addr < chunk.end) {
HeapObject* obj = HeapObject::FromAddress(addr);
incremental_marking()->IterateBlackObject(obj);
// There might be grey objects due to black to grey transitions in
// incremental marking. E.g. see VisitNativeContextIncremental.
DCHECK(ObjectMarking::IsBlackOrGrey(obj));
if (ObjectMarking::IsBlack(obj)) {
incremental_marking()->IterateBlackObject(obj);
}
addr += obj->Size();
}
}
@ -4898,8 +4891,7 @@ void Heap::IterateAndScavengePromotedObject(HeapObject* target, int size,
// it would be a violation of the invariant to record it's slots.
bool record_slots = false;
if (incremental_marking()->IsCompacting()) {
MarkBit mark_bit = ObjectMarking::MarkBitFrom(target);
record_slots = Marking::IsBlack(mark_bit);
record_slots = ObjectMarking::IsBlack(target);
}
IterateAndScavengePromotedObjectsVisitor visitor(this, target, record_slots);
@ -6137,8 +6129,7 @@ class UnreachableObjectsFilter : public HeapObjectsFilter {
bool SkipObject(HeapObject* object) {
if (object->IsFiller()) return true;
MarkBit mark_bit = ObjectMarking::MarkBitFrom(object);
return Marking::IsWhite(mark_bit);
return ObjectMarking::IsWhite(object);
}
private:
@ -6150,6 +6141,8 @@ class UnreachableObjectsFilter : public HeapObjectsFilter {
for (Object** p = start; p < end; p++) {
if (!(*p)->IsHeapObject()) continue;
HeapObject* obj = HeapObject::cast(*p);
// Use Marking instead of ObjectMarking to avoid adjusting live bytes
// counter.
MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj);
if (Marking::IsWhite(mark_bit)) {
Marking::WhiteToBlack(mark_bit);

93
src/heap/incremental-marking.cc
View File

@ -39,15 +39,12 @@ IncrementalMarking::IncrementalMarking(Heap* heap)
bool IncrementalMarking::BaseRecordWrite(HeapObject* obj, Object* value) {
HeapObject* value_heap_obj = HeapObject::cast(value);
MarkBit value_bit = ObjectMarking::MarkBitFrom(value_heap_obj);
DCHECK(!Marking::IsImpossible(value_bit));
DCHECK(!ObjectMarking::IsImpossible(value_heap_obj));
DCHECK(!ObjectMarking::IsImpossible(obj));
const bool is_black = ObjectMarking::IsBlack(obj);
MarkBit obj_bit = ObjectMarking::MarkBitFrom(obj);
DCHECK(!Marking::IsImpossible(obj_bit));
bool is_black = Marking::IsBlack(obj_bit);
if (is_black && Marking::IsWhite(value_bit)) {
WhiteToGreyAndPush(value_heap_obj, value_bit);
if (is_black && ObjectMarking::IsWhite(value_heap_obj)) {
WhiteToGreyAndPush(value_heap_obj);
RestartIfNotMarking();
}
return is_compacting_ && is_black;
@ -118,9 +115,8 @@ void IncrementalMarking::RecordWriteIntoCodeSlow(Code* host, RelocInfo* rinfo,
}
}
void IncrementalMarking::WhiteToGreyAndPush(HeapObject* obj, MarkBit mark_bit) {
Marking::WhiteToGrey(mark_bit);
void IncrementalMarking::WhiteToGreyAndPush(HeapObject* obj) {
ObjectMarking::WhiteToGrey(obj);
heap_->mark_compact_collector()->marking_deque()->Push(obj);
}
@ -128,16 +124,13 @@ void IncrementalMarking::WhiteToGreyAndPush(HeapObject* obj, MarkBit mark_bit) {
static void MarkObjectGreyDoNotEnqueue(Object* obj) {
if (obj->IsHeapObject()) {
HeapObject* heap_obj = HeapObject::cast(obj);
MarkBit mark_bit = ObjectMarking::MarkBitFrom(HeapObject::cast(obj));
if (Marking::IsBlack(mark_bit)) {
MemoryChunk::IncrementLiveBytes(heap_obj, -heap_obj->Size());
}
Marking::AnyToGrey(mark_bit);
ObjectMarking::AnyToGrey(heap_obj);
}
}
void IncrementalMarking::TransferMark(Heap* heap, HeapObject* from,
HeapObject* to) {
DCHECK(MemoryChunk::FromAddress(from->address())->SweepingDone());
// This is only used when resizing an object.
DCHECK(MemoryChunk::FromAddress(from->address()) ==
MemoryChunk::FromAddress(to->address()));
@ -158,11 +151,12 @@ void IncrementalMarking::TransferMark(Heap* heap, HeapObject* from,
if (Marking::IsBlack(old_mark_bit)) {
Marking::BlackToWhite(old_mark_bit);
Marking::MarkBlack(new_mark_bit);
Marking::WhiteToBlack(new_mark_bit);
return;
} else if (Marking::IsGrey(old_mark_bit)) {
Marking::GreyToWhite(old_mark_bit);
heap->incremental_marking()->WhiteToGreyAndPush(to, new_mark_bit);
Marking::WhiteToGrey(new_mark_bit);
heap->mark_compact_collector()->marking_deque()->Push(to);
heap->incremental_marking()->RestartIfNotMarking();
}
@ -210,10 +204,10 @@ class IncrementalMarkingMarkingVisitor
} while (scan_until_end && start_offset < object_size);
chunk->set_progress_bar(start_offset);
if (start_offset < object_size) {
if (Marking::IsGrey(ObjectMarking::MarkBitFrom(object))) {
if (ObjectMarking::IsGrey(object)) {
heap->mark_compact_collector()->marking_deque()->Unshift(object);
} else {
DCHECK(Marking::IsBlack(ObjectMarking::MarkBitFrom(object)));
DCHECK(ObjectMarking::IsBlack(object));
heap->mark_compact_collector()->UnshiftBlack(object);
}
heap->incremental_marking()->NotifyIncompleteScanOfObject(
@ -265,10 +259,8 @@ class IncrementalMarkingMarkingVisitor
// Returns true if object needed marking and false otherwise.
INLINE(static bool MarkObjectWithoutPush(Heap* heap, Object* obj)) {
HeapObject* heap_object = HeapObject::cast(obj);
MarkBit mark_bit = ObjectMarking::MarkBitFrom(heap_object);
if (Marking::IsWhite(mark_bit)) {
Marking::MarkBlack(mark_bit);
MemoryChunk::IncrementLiveBytes(heap_object, heap_object->Size());
if (ObjectMarking::IsWhite(heap_object)) {
ObjectMarking::WhiteToBlack(heap_object);
return true;
}
return false;
@ -276,7 +268,7 @@ class IncrementalMarkingMarkingVisitor
};
void IncrementalMarking::IterateBlackObject(HeapObject* object) {
if (IsMarking() && Marking::IsBlack(ObjectMarking::MarkBitFrom(object))) {
if (IsMarking() && ObjectMarking::IsBlack(object)) {
Page* page = Page::FromAddress(object->address());
if ((page->owner() != nullptr) && (page->owner()->identity() == LO_SPACE)) {
// IterateBlackObject requires us to visit the whole object.
@ -661,8 +653,7 @@ bool ShouldRetainMap(Map* map, int age) {
}
Object* constructor = map->GetConstructor();
if (!constructor->IsHeapObject() ||
Marking::IsWhite(
ObjectMarking::MarkBitFrom(HeapObject::cast(constructor)))) {
ObjectMarking::IsWhite(HeapObject::cast(constructor))) {
// The constructor is dead, no new objects with this map can
// be created. Do not retain this map.
return false;
@ -691,16 +682,14 @@ void IncrementalMarking::RetainMaps() {
int age = Smi::cast(retained_maps->Get(i + 1))->value();
int new_age;
Map* map = Map::cast(cell->value());
MarkBit map_mark = ObjectMarking::MarkBitFrom(map);
if (i >= number_of_disposed_maps && !map_retaining_is_disabled &&
Marking::IsWhite(map_mark)) {
ObjectMarking::IsWhite(map)) {
if (ShouldRetainMap(map, age)) {
MarkGrey(heap(), map);
}
Object* prototype = map->prototype();
if (age > 0 && prototype->IsHeapObject() &&
Marking::IsWhite(
ObjectMarking::MarkBitFrom(HeapObject::cast(prototype)))) {
ObjectMarking::IsWhite(HeapObject::cast(prototype))) {
// The prototype is not marked, age the map.
new_age = age - 1;
} else {
@ -807,15 +796,12 @@ void IncrementalMarking::UpdateMarkingDequeAfterScavenge() {
// them.
if (map_word.IsForwardingAddress()) {
HeapObject* dest = map_word.ToForwardingAddress();
if (Marking::IsBlack(ObjectMarking::MarkBitFrom(dest))) continue;
if (ObjectMarking::IsBlack(dest)) continue;
array[new_top] = dest;
new_top = ((new_top + 1) & mask);
DCHECK(new_top != marking_deque->bottom());
#ifdef DEBUG
MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj);
DCHECK(Marking::IsGrey(mark_bit) ||
(obj->IsFiller() && Marking::IsWhite(mark_bit)));
#endif
DCHECK(ObjectMarking::IsGrey(obj) ||
(obj->IsFiller() && ObjectMarking::IsWhite(obj)));
}
} else if (obj->map() != filler_map) {
// Skip one word filler objects that appear on the
@ -823,14 +809,11 @@ void IncrementalMarking::UpdateMarkingDequeAfterScavenge() {
array[new_top] = obj;
new_top = ((new_top + 1) & mask);
DCHECK(new_top != marking_deque->bottom());
#ifdef DEBUG
MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj);
MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
DCHECK(Marking::IsGrey(mark_bit) ||
(obj->IsFiller() && Marking::IsWhite(mark_bit)) ||
(chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
Marking::IsBlack(mark_bit)));
#endif
DCHECK(ObjectMarking::IsGrey(obj) ||
(obj->IsFiller() && ObjectMarking::IsWhite(obj)) ||
(MemoryChunk::FromAddress(obj->address())
->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
ObjectMarking::IsBlack(obj)));
}
}
marking_deque->set_top(new_top);
@ -854,17 +837,14 @@ void IncrementalMarking::VisitObject(Map* map, HeapObject* obj, int size) {
}
void IncrementalMarking::MarkGrey(Heap* heap, HeapObject* object) {
MarkBit mark_bit = ObjectMarking::MarkBitFrom(object);
if (Marking::IsWhite(mark_bit)) {
heap->incremental_marking()->WhiteToGreyAndPush(object, mark_bit);
if (ObjectMarking::IsWhite(object)) {
heap->incremental_marking()->WhiteToGreyAndPush(object);
}
}
void IncrementalMarking::MarkBlack(HeapObject* obj, int size) {
MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj);
if (Marking::IsBlack(mark_bit)) return;
Marking::GreyToBlack(mark_bit);
MemoryChunk::IncrementLiveBytes(obj, size);
if (ObjectMarking::IsBlack(obj)) return;
ObjectMarking::GreyToBlack(obj);
}
intptr_t IncrementalMarking::ProcessMarkingDeque(
@ -879,8 +859,7 @@ intptr_t IncrementalMarking::ProcessMarkingDeque(
// Left trimming may result in white filler objects on the marking deque.
// Ignore these objects.
if (obj->IsFiller()) {
DCHECK(Marking::IsImpossible(ObjectMarking::MarkBitFrom(obj)) ||
Marking::IsWhite(ObjectMarking::MarkBitFrom(obj)));
DCHECK(ObjectMarking::IsImpossible(obj) || ObjectMarking::IsWhite(obj));
continue;
}
@ -935,10 +914,8 @@ void IncrementalMarking::Hurry() {
HeapObject* cache = HeapObject::cast(
Context::cast(context)->get(Context::NORMALIZED_MAP_CACHE_INDEX));
if (!cache->IsUndefined(heap_->isolate())) {
MarkBit mark_bit = ObjectMarking::MarkBitFrom(cache);
if (Marking::IsGrey(mark_bit)) {
Marking::GreyToBlack(mark_bit);
MemoryChunk::IncrementLiveBytes(cache, cache->Size());
if (ObjectMarking::IsGrey(cache)) {
ObjectMarking::GreyToBlack(cache);
}
}
context = Context::cast(context)->next_context_link();

2
src/heap/incremental-marking.h
View File

@ -158,7 +158,7 @@ class IncrementalMarking {
void RecordCodeTargetPatch(Code* host, Address pc, HeapObject* value);
void RecordCodeTargetPatch(Address pc, HeapObject* value);
void WhiteToGreyAndPush(HeapObject* obj, MarkBit mark_bit);
void WhiteToGreyAndPush(HeapObject* obj);
inline void SetOldSpacePageFlags(MemoryChunk* chunk) {
SetOldSpacePageFlags(chunk, IsMarking(), IsCompacting());

34
src/heap/mark-compact-inl.h
View File

@ -13,48 +13,38 @@ namespace v8 {
namespace internal {
void MarkCompactCollector::PushBlack(HeapObject* obj) {
DCHECK(Marking::IsBlack(ObjectMarking::MarkBitFrom(obj)));
if (marking_deque()->Push(obj)) {
MemoryChunk::IncrementLiveBytes(obj, obj->Size());
} else {
MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj);
Marking::BlackToGrey(mark_bit);
DCHECK(ObjectMarking::IsBlack(obj));
if (!marking_deque()->Push(obj)) {
ObjectMarking::BlackToGrey(obj);
}
}
void MarkCompactCollector::UnshiftBlack(HeapObject* obj) {
DCHECK(Marking::IsBlack(ObjectMarking::MarkBitFrom(obj)));
DCHECK(ObjectMarking::IsBlack(obj));
if (!marking_deque()->Unshift(obj)) {
MemoryChunk::IncrementLiveBytes(obj, -obj->Size());
MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj);
Marking::BlackToGrey(mark_bit);
ObjectMarking::BlackToGrey(obj);
}
}
void MarkCompactCollector::MarkObject(HeapObject* obj, MarkBit mark_bit) {
DCHECK(ObjectMarking::MarkBitFrom(obj) == mark_bit);
if (Marking::IsWhite(mark_bit)) {
Marking::WhiteToBlack(mark_bit);
DCHECK(obj->GetIsolate()->heap()->Contains(obj));
if (ObjectMarking::IsWhite(obj)) {
ObjectMarking::WhiteToBlack(obj);
PushBlack(obj);
}
}
void MarkCompactCollector::SetMark(HeapObject* obj, MarkBit mark_bit) {
DCHECK(Marking::IsWhite(mark_bit));
DCHECK(ObjectMarking::MarkBitFrom(obj) == mark_bit);
Marking::WhiteToBlack(mark_bit);
MemoryChunk::IncrementLiveBytes(obj, obj->Size());
void MarkCompactCollector::SetMark(HeapObject* obj) {
DCHECK(ObjectMarking::IsWhite(obj));
ObjectMarking::WhiteToBlack(obj);
}
bool MarkCompactCollector::IsMarked(Object* obj) {
DCHECK(obj->IsHeapObject());
HeapObject* heap_object = HeapObject::cast(obj);
return Marking::IsBlackOrGrey(ObjectMarking::MarkBitFrom(heap_object));
return ObjectMarking::IsBlackOrGrey(HeapObject::cast(obj));
}
@ -64,7 +54,7 @@ void MarkCompactCollector::RecordSlot(HeapObject* object, Object** slot,
Page* source_page = Page::FromAddress(reinterpret_cast<Address>(object));
if (target_page->IsEvacuationCandidate() &&
!ShouldSkipEvacuationSlotRecording(object)) {
DCHECK(Marking::IsBlackOrGrey(ObjectMarking::MarkBitFrom(object)));
DCHECK(IsMarked(object));
RememberedSet<OLD_TO_OLD>::Insert(source_page,
reinterpret_cast<Address>(slot));
}

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

@ -107,7 +107,7 @@ static void VerifyMarking(Heap* heap, Address bottom, Address top) {
// One word fillers at the end of a black area can be grey.
if (MarkCompactCollector::IsMarked(object) &&
object->map() != heap->one_pointer_filler_map()) {
CHECK(Marking::IsBlack(ObjectMarking::MarkBitFrom(object)));
CHECK(ObjectMarking::IsBlack(object));
CHECK(current >= next_object_must_be_here_or_later);
object->Iterate(&visitor);
next_object_must_be_here_or_later = current + object->Size();
@ -348,8 +348,7 @@ void MarkCompactCollector::VerifyMarkbitsAreClean() {
LargeObjectIterator it(heap_->lo_space());
for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
MarkBit mark_bit = ObjectMarking::MarkBitFrom(obj);
CHECK(Marking::IsWhite(mark_bit));
CHECK(ObjectMarking::IsWhite(obj));
CHECK_EQ(0, Page::FromAddress(obj->address())->LiveBytes());
}
}
@ -398,7 +397,7 @@ void MarkCompactCollector::ClearMarkbits() {
LargeObjectIterator it(heap_->lo_space());
for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
Marking::MarkWhite(ObjectMarking::MarkBitFrom(obj));
ObjectMarking::ClearMarkBit(obj);
MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
chunk->ResetProgressBar();
chunk->ResetLiveBytes();
@ -909,8 +908,7 @@ void CodeFlusher::ProcessJSFunctionCandidates() {
SharedFunctionInfo* shared = candidate->shared();
Code* code = shared->code();
MarkBit code_mark = ObjectMarking::MarkBitFrom(code);
if (Marking::IsWhite(code_mark)) {
if (ObjectMarking::IsWhite(code)) {
if (FLAG_trace_code_flushing && shared->is_compiled()) {
PrintF("[code-flushing clears: ");
shared->ShortPrint();
@ -928,7 +926,7 @@ void CodeFlusher::ProcessJSFunctionCandidates() {
candidate->set_code(lazy_compile);
}
} else {
DCHECK(Marking::IsBlack(code_mark));
DCHECK(ObjectMarking::IsBlack(code));
candidate->set_code(code);
}
@ -962,8 +960,7 @@ void CodeFlusher::ProcessSharedFunctionInfoCandidates() {
ClearNextCandidate(candidate);
Code* code = candidate->code();
MarkBit code_mark = ObjectMarking::MarkBitFrom(code);
if (Marking::IsWhite(code_mark)) {
if (ObjectMarking::IsWhite(code)) {
if (FLAG_trace_code_flushing && candidate->is_compiled()) {
PrintF("[code-flushing clears: ");
candidate->ShortPrint();
@ -1103,9 +1100,8 @@ class StaticYoungGenerationMarkingVisitor
StackLimitCheck check(heap->isolate());
if (check.HasOverflowed()) return false;
MarkBit mark = ObjectMarking::MarkBitFrom(object);
if (Marking::IsBlackOrGrey(mark)) return true;
heap->mark_compact_collector()->SetMark(object, mark);
if (ObjectMarking::IsBlackOrGrey(object)) return true;
heap->mark_compact_collector()->SetMark(object);
IterateBody(object->map(), object);
return true;
}
@ -1143,9 +1139,8 @@ class MarkCompactMarkingVisitor
// Marks the object black without pushing it on the marking stack.
// Returns true if object needed marking and false otherwise.
INLINE(static bool MarkObjectWithoutPush(Heap* heap, HeapObject* object)) {
MarkBit mark_bit = ObjectMarking::MarkBitFrom(object);
if (Marking::IsWhite(mark_bit)) {
heap->mark_compact_collector()->SetMark(object, mark_bit);
if (ObjectMarking::IsWhite(object)) {
heap->mark_compact_collector()->SetMark(object);
return true;
}
return false;
@ -1171,8 +1166,7 @@ class MarkCompactMarkingVisitor
#endif
Map* map = obj->map();
Heap* heap = obj->GetHeap();
MarkBit mark = ObjectMarking::MarkBitFrom(obj);
heap->mark_compact_collector()->SetMark(obj, mark);
heap->mark_compact_collector()->SetMark(obj);
// Mark the map pointer and the body.
MarkBit map_mark = ObjectMarking::MarkBitFrom(map);
heap->mark_compact_collector()->MarkObject(map, map_mark);
@ -1194,8 +1188,7 @@ class MarkCompactMarkingVisitor
if (!o->IsHeapObject()) continue;
collector->RecordSlot(object, p, o);
HeapObject* obj = HeapObject::cast(o);
MarkBit mark = ObjectMarking::MarkBitFrom(obj);
if (Marking::IsBlackOrGrey(mark)) continue;
if (ObjectMarking::IsBlackOrGrey(obj)) continue;
VisitUnmarkedObject(collector, obj);
}
return true;
@ -1228,7 +1221,7 @@ class MarkCompactMarkingVisitor
// was marked through the compilation cache before marker reached JSRegExp
// object.
FixedArray* data = FixedArray::cast(re->data());
if (Marking::IsBlackOrGrey(ObjectMarking::MarkBitFrom(data))) {
if (ObjectMarking::IsBlackOrGrey(data)) {
Object** slot =
data->data_start() + JSRegExp::saved_code_index(is_one_byte);
heap->mark_compact_collector()->RecordSlot(data, slot, code);
@ -1394,12 +1387,11 @@ class RootMarkingVisitor : public ObjectVisitor {
!collector_->heap()->InNewSpace(object))
return;
MarkBit mark_bit = ObjectMarking::MarkBitFrom(object);
if (Marking::IsBlackOrGrey(mark_bit)) return;
if (ObjectMarking::IsBlackOrGrey(object)) return;
Map* map = object->map();
// Mark the object.
collector_->SetMark(object, mark_bit);
collector_->SetMark(object);
switch (mode) {
case MarkCompactMode::FULL: {
@ -1437,7 +1429,7 @@ class StringTableCleaner : public ObjectVisitor {
for (Object** p = start; p < end; p++) {
Object* o = *p;
if (o->IsHeapObject()) {
if (Marking::IsWhite(ObjectMarking::MarkBitFrom(HeapObject::cast(o)))) {
if (ObjectMarking::IsWhite(HeapObject::cast(o))) {
if (finalize_external_strings) {
if (o->IsExternalString()) {
heap_->FinalizeExternalString(String::cast(*p));
@ -1478,9 +1470,8 @@ typedef StringTableCleaner<true, false> ExternalStringTableCleaner;
class MarkCompactWeakObjectRetainer : public WeakObjectRetainer {
public:
virtual Object* RetainAs(Object* object) {
MarkBit mark_bit = ObjectMarking::MarkBitFrom(HeapObject::cast(object));
DCHECK(!Marking::IsGrey(mark_bit));
if (Marking::IsBlack(mark_bit)) {
DCHECK(!ObjectMarking::IsGrey(HeapObject::cast(object)));
if (ObjectMarking::IsBlack(HeapObject::cast(object))) {
return object;
} else if (object->IsAllocationSite() &&
!(AllocationSite::cast(object)->IsZombie())) {
@ -1508,9 +1499,8 @@ void MarkCompactCollector::DiscoverGreyObjectsWithIterator(T* it) {
Map* filler_map = heap()->one_pointer_filler_map();
for (HeapObject* object = it->Next(); object != NULL; object = it->Next()) {
MarkBit markbit = ObjectMarking::MarkBitFrom(object);
if ((object->map() != filler_map) && Marking::IsGrey(markbit)) {
Marking::GreyToBlack(markbit);
if ((object->map() != filler_map) && ObjectMarking::IsGrey(object)) {
ObjectMarking::GreyToBlack(object);
PushBlack(object);
if (marking_deque()->IsFull()) return;
}
@ -1522,9 +1512,8 @@ void MarkCompactCollector::DiscoverGreyObjectsOnPage(MemoryChunk* p) {
LiveObjectIterator<kGreyObjects> it(p);
HeapObject* object = NULL;
while ((object = it.Next()) != NULL) {
MarkBit markbit = ObjectMarking::MarkBitFrom(object);
DCHECK(Marking::IsGrey(markbit));
Marking::GreyToBlack(markbit);
DCHECK(ObjectMarking::IsGrey(object));
ObjectMarking::GreyToBlack(object);
PushBlack(object);
if (marking_deque()->IsFull()) return;
}
@ -1974,9 +1963,7 @@ void MarkCompactCollector::DiscoverGreyObjectsInNewSpace() {
bool MarkCompactCollector::IsUnmarkedHeapObject(Object** p) {
Object* o = *p;
if (!o->IsHeapObject()) return false;
HeapObject* heap_object = HeapObject::cast(o);
MarkBit mark = ObjectMarking::MarkBitFrom(heap_object);
return Marking::IsWhite(mark);
return ObjectMarking::IsWhite(HeapObject::cast(o));
}
@ -1984,19 +1971,16 @@ bool MarkCompactCollector::IsUnmarkedHeapObjectWithHeap(Heap* heap,
Object** p) {
Object* o = *p;
DCHECK(o->IsHeapObject());
HeapObject* heap_object = HeapObject::cast(o);
MarkBit mark = ObjectMarking::MarkBitFrom(heap_object);
return Marking::IsWhite(mark);
return ObjectMarking::IsWhite(HeapObject::cast(o));
}
void MarkCompactCollector::MarkStringTable(
RootMarkingVisitor<MarkCompactMode::FULL>* visitor) {
StringTable* string_table = heap()->string_table();
// Mark the string table itself.
MarkBit string_table_mark = ObjectMarking::MarkBitFrom(string_table);
if (Marking::IsWhite(string_table_mark)) {
if (ObjectMarking::IsWhite(string_table)) {
// String table could have already been marked by visiting the handles list.
SetMark(string_table, string_table_mark);
SetMark(string_table);
}
// Explicitly mark the prefix.
string_table->IteratePrefix(visitor);
@ -2005,8 +1989,7 @@ void MarkCompactCollector::MarkStringTable(
void MarkCompactCollector::MarkAllocationSite(AllocationSite* site) {
MarkBit mark_bit = ObjectMarking::MarkBitFrom(site);
SetMark(site, mark_bit);
SetMark(site);
}
void MarkCompactCollector::MarkRoots(
@ -2069,7 +2052,7 @@ void MarkCompactCollector::EmptyMarkingDeque() {
DCHECK(!object->IsFiller());
DCHECK(object->IsHeapObject());
DCHECK(heap()->Contains(object));
DCHECK(!Marking::IsWhite(ObjectMarking::MarkBitFrom(object)));
DCHECK(!ObjectMarking::IsWhite(object));
Map* map = object->map();
switch (mode) {
@ -2079,7 +2062,7 @@ void MarkCompactCollector::EmptyMarkingDeque() {
MarkCompactMarkingVisitor::IterateBody(map, object);
} break;
case MarkCompactMode::YOUNG_GENERATION: {
DCHECK(Marking::IsBlack(ObjectMarking::MarkBitFrom(object)));
DCHECK(ObjectMarking::IsBlack(object));
StaticYoungGenerationMarkingVisitor::IterateBody(map, object);
} break;
}
@ -2280,10 +2263,10 @@ class MarkCompactCollector::ObjectStatsVisitor
}
bool Visit(HeapObject* obj) override {
if (Marking::IsBlack(ObjectMarking::MarkBitFrom(obj))) {
if (ObjectMarking::IsBlack(obj)) {
live_collector_.CollectStatistics(obj);
} else {
DCHECK(!Marking::IsGrey(ObjectMarking::MarkBitFrom(obj)));
DCHECK(!ObjectMarking::IsGrey(obj));
dead_collector_.CollectStatistics(obj);
}
return true;
@ -2339,11 +2322,10 @@ SlotCallbackResult MarkCompactCollector::CheckAndMarkObject(
// has to be in ToSpace.
DCHECK(heap->InToSpace(object));
HeapObject* heap_object = reinterpret_cast<HeapObject*>(object);
MarkBit mark_bit = ObjectMarking::MarkBitFrom(heap_object);
if (Marking::IsBlackOrGrey(mark_bit)) {
if (ObjectMarking::IsBlackOrGrey(heap_object)) {
return KEEP_SLOT;
}
heap->mark_compact_collector()->SetMark(heap_object, mark_bit);
heap->mark_compact_collector()->SetMark(heap_object);
StaticYoungGenerationMarkingVisitor::IterateBody(heap_object->map(),
heap_object);
return KEEP_SLOT;
@ -2353,8 +2335,7 @@ SlotCallbackResult MarkCompactCollector::CheckAndMarkObject(
static bool IsUnmarkedObject(Heap* heap, Object** p) {
DCHECK_IMPLIES(heap->InNewSpace(*p), heap->InToSpace(*p));
return heap->InNewSpace(*p) &&
!Marking::IsBlack(ObjectMarking::MarkBitFrom(HeapObject::cast(*p)));
return heap->InNewSpace(*p) && !ObjectMarking::IsBlack(HeapObject::cast(*p));
}
void MarkCompactCollector::MarkLiveObjectsInYoungGeneration() {
@ -2636,11 +2617,11 @@ void MarkCompactCollector::ClearSimpleMapTransitions(
while (weak_cell_obj != Smi::kZero) {
WeakCell* weak_cell = WeakCell::cast(weak_cell_obj);
Map* map = Map::cast(weak_cell->value());
DCHECK(Marking::IsWhite(ObjectMarking::MarkBitFrom(map)));
DCHECK(ObjectMarking::IsWhite(map));
Object* potential_parent = map->constructor_or_backpointer();
if (potential_parent->IsMap()) {
Map* parent = Map::cast(potential_parent);
if (Marking::IsBlackOrGrey(ObjectMarking::MarkBitFrom(parent)) &&
if (ObjectMarking::IsBlackOrGrey(parent) &&
parent->raw_transitions() == weak_cell) {
ClearSimpleMapTransition(parent, map);
}
@ -2679,8 +2660,7 @@ void MarkCompactCollector::ClearFullMapTransitions() {
if (num_transitions > 0) {
Map* map = array->GetTarget(0);
Map* parent = Map::cast(map->constructor_or_backpointer());
bool parent_is_alive =
Marking::IsBlackOrGrey(ObjectMarking::MarkBitFrom(parent));
bool parent_is_alive = ObjectMarking::IsBlackOrGrey(parent);
DescriptorArray* descriptors =
parent_is_alive ? parent->instance_descriptors() : nullptr;
bool descriptors_owner_died =
@ -2705,7 +2685,7 @@ bool MarkCompactCollector::CompactTransitionArray(
for (int i = 0; i < num_transitions; ++i) {
Map* target = transitions->GetTarget(i);
DCHECK_EQ(target->constructor_or_backpointer(), map);
if (Marking::IsWhite(ObjectMarking::MarkBitFrom(target))) {
if (ObjectMarking::IsWhite(target)) {
if (descriptors != nullptr &&
target->instance_descriptors() == descriptors) {
descriptors_owner_died = true;
@ -2880,8 +2860,7 @@ void MarkCompactCollector::ClearWeakCells(Object** non_live_map_list,
if (cell_value->IsHeapObject() &&
MarkCompactCollector::IsMarked(HeapObject::cast(cell_value))) {
// Resurrect the cell.
MarkBit mark = ObjectMarking::MarkBitFrom(value);
SetMark(value, mark);
SetMark(value);
Object** slot = HeapObject::RawField(value, Cell::kValueOffset);
RecordSlot(value, slot, *slot);
slot = HeapObject::RawField(weak_cell, WeakCell::kValueOffset);
@ -3423,7 +3402,7 @@ int MarkCompactCollector::Sweeper::RawSweep(
HeapObject* object = NULL;
while ((object = it.Next()) != NULL) {
DCHECK(Marking::IsBlack(ObjectMarking::MarkBitFrom(object)));
DCHECK(ObjectMarking::IsBlack(object));
Address free_end = object->address();
if (free_end != free_start) {
CHECK_GT(free_end, free_start);
@ -3513,8 +3492,7 @@ void MarkCompactCollector::InvalidateCode(Code* code) {
DCHECK(compacting_);
// If the object is white than no slots were recorded on it yet.
MarkBit mark_bit = ObjectMarking::MarkBitFrom(code);
if (Marking::IsWhite(mark_bit)) return;
if (ObjectMarking::IsWhite(code)) return;
// Ignore all slots that might have been recorded in the body of the
// deoptimized code object. Assumption: no slots will be recorded for
@ -3535,7 +3513,7 @@ static void VerifyAllBlackObjects(MemoryChunk* page) {
LiveObjectIterator<kAllLiveObjects> it(page);
HeapObject* object = NULL;
while ((object = it.Next()) != NULL) {
CHECK(Marking::IsBlack(ObjectMarking::MarkBitFrom(object)));
CHECK(ObjectMarking::IsBlack(object));
}
}
#endif // VERIFY_HEAP
@ -3550,7 +3528,7 @@ bool MarkCompactCollector::VisitLiveObjects(MemoryChunk* page, Visitor* visitor,
LiveObjectIterator<kBlackObjects> it(page);
HeapObject* object = nullptr;
while ((object = it.Next()) != nullptr) {
DCHECK(Marking::IsBlack(ObjectMarking::MarkBitFrom(object)));
DCHECK(ObjectMarking::IsBlack(object));
if (!visitor->Visit(object)) {
if (mode == kClearMarkbits) {
page->markbits()->ClearRange(
@ -3747,8 +3725,7 @@ class PointerUpdateJobTraits {
// slot has been recorded multiple times in the remembered set. Since
// there is no forwarding information present we need to check the
// markbits to determine liveness.
if (Marking::IsBlack(ObjectMarking::MarkBitFrom(
reinterpret_cast<HeapObject*>(slot_reference))))
if (ObjectMarking::IsBlack(reinterpret_cast<HeapObject*>(slot_reference)))
return KEEP_SLOT;
} else {
DCHECK(!heap->InNewSpace(slot_reference));
@ -4082,8 +4059,7 @@ void MarkCompactCollector::RecordCodeTargetPatch(Address pc, Code* target) {
Code* host =
isolate()->inner_pointer_to_code_cache()->GcSafeFindCodeForInnerPointer(
pc);
MarkBit mark_bit = ObjectMarking::MarkBitFrom(host);
if (Marking::IsBlack(mark_bit)) {
if (ObjectMarking::IsBlack(host)) {
RelocInfo rinfo(isolate(), pc, RelocInfo::CODE_TARGET, 0, host);
// The target is always in old space, we don't have to record the slot in
// the old-to-new remembered set.

72
src/heap/mark-compact.h
View File

@ -46,6 +46,76 @@ class ObjectMarking : public AllStatic {
return Marking::Color(ObjectMarking::MarkBitFrom(obj));
}
V8_INLINE static bool IsImpossible(HeapObject* obj) {
return Marking::IsImpossible(MarkBitFrom(obj));
}
V8_INLINE static bool IsBlack(HeapObject* obj) {
return Marking::IsBlack(MarkBitFrom(obj));
}
V8_INLINE static bool IsWhite(HeapObject* obj) {
return Marking::IsWhite(MarkBitFrom(obj));
}
V8_INLINE static bool IsGrey(HeapObject* obj) {
return Marking::IsGrey(MarkBitFrom(obj));
}
V8_INLINE static bool IsBlackOrGrey(HeapObject* obj) {
return Marking::IsBlackOrGrey(MarkBitFrom(obj));
}
V8_INLINE static void ClearMarkBit(HeapObject* obj) {
Marking::MarkWhite(MarkBitFrom(obj));
}
V8_INLINE static void BlackToWhite(HeapObject* obj) {
DCHECK(IsBlack(obj));
MarkBit markbit = MarkBitFrom(obj);
Marking::BlackToWhite(markbit);
MemoryChunk::IncrementLiveBytes(obj, -obj->Size());
}
V8_INLINE static void GreyToWhite(HeapObject* obj) {
DCHECK(IsGrey(obj));
Marking::GreyToWhite(MarkBitFrom(obj));
}
V8_INLINE static void BlackToGrey(HeapObject* obj) {
DCHECK(IsBlack(obj));
MarkBit markbit = MarkBitFrom(obj);
Marking::BlackToGrey(markbit);
MemoryChunk::IncrementLiveBytes(obj, -obj->Size());
}
V8_INLINE static void WhiteToGrey(HeapObject* obj) {
DCHECK(IsWhite(obj));
Marking::WhiteToGrey(MarkBitFrom(obj));
}
V8_INLINE static void WhiteToBlack(HeapObject* obj) {
DCHECK(IsWhite(obj));
MarkBit markbit = MarkBitFrom(obj);
Marking::WhiteToBlack(markbit);
MemoryChunk::IncrementLiveBytes(obj, obj->Size());
}
V8_INLINE static void GreyToBlack(HeapObject* obj) {
DCHECK(IsGrey(obj));
MarkBit markbit = MarkBitFrom(obj);
Marking::GreyToBlack(markbit);
MemoryChunk::IncrementLiveBytes(obj, obj->Size());
}
V8_INLINE static void AnyToGrey(HeapObject* obj) {
MarkBit markbit = MarkBitFrom(obj);
if (Marking::IsBlack(markbit)) {
MemoryChunk::IncrementLiveBytes(obj, -obj->Size());
}
Marking::AnyToGrey(markbit);
}
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(ObjectMarking);
};
@ -595,7 +665,7 @@ class MarkCompactCollector {
// Marks the object black assuming that it is not yet marked.
// This is for non-incremental marking only.
INLINE(void SetMark(HeapObject* obj, MarkBit mark_bit));
INLINE(void SetMark(HeapObject* obj));
// Mark the heap roots and all objects reachable from them.
void MarkRoots(RootMarkingVisitor<MarkCompactMode::FULL>* visitor);

6
src/heap/objects-visiting-inl.h
View File

@ -534,8 +534,7 @@ bool StaticMarkingVisitor<StaticVisitor>::IsFlushable(Heap* heap,
// Code is either on stack, in compilation cache or referenced
// by optimized version of function.
MarkBit code_mark = ObjectMarking::MarkBitFrom(function->code());
if (Marking::IsBlackOrGrey(code_mark)) {
if (ObjectMarking::IsBlackOrGrey(function->code())) {
return false;
}
@ -558,8 +557,7 @@ bool StaticMarkingVisitor<StaticVisitor>::IsFlushable(
Heap* heap, SharedFunctionInfo* shared_info) {
// Code is either on stack, in compilation cache or referenced
// by optimized version of function.
MarkBit code_mark = ObjectMarking::MarkBitFrom(shared_info->code());
if (Marking::IsBlackOrGrey(code_mark)) {
if (ObjectMarking::IsBlackOrGrey(shared_info->code())) {
return false;
}

8
src/heap/scavenger.cc
View File

@ -200,9 +200,8 @@ class ScavengingVisitor : public StaticVisitorBase {
reinterpret_cast<base::AtomicWord>(target));
if (object_contents == POINTER_OBJECT) {
heap->promotion_queue()->insert(
target, object_size,
Marking::IsBlack(ObjectMarking::MarkBitFrom(object)));
heap->promotion_queue()->insert(target, object_size,
ObjectMarking::IsBlack(object));
}
heap->IncrementPromotedObjectsSize(object_size);
return true;
@ -246,8 +245,7 @@ class ScavengingVisitor : public StaticVisitorBase {
DCHECK(map_word.IsForwardingAddress());
HeapObject* target = map_word.ToForwardingAddress();
MarkBit mark_bit = ObjectMarking::MarkBitFrom(target);
if (Marking::IsBlack(mark_bit)) {
if (ObjectMarking::IsBlack(target)) {
// This object is black and it might not be rescanned by marker.
// We should explicitly record code entry slot for compaction because
// promotion queue processing (IteratePromotedObjectPointers) will

17
src/heap/spaces.cc
View File

@ -1459,7 +1459,7 @@ void PagedSpace::Verify(ObjectVisitor* visitor) {
// All the interior pointers should be contained in the heap.
int size = object->Size();
object->IterateBody(map->instance_type(), size, visitor);
if (Marking::IsBlack(ObjectMarking::MarkBitFrom(object))) {
if (ObjectMarking::IsBlack(object)) {
black_size += size;
}
@ -2990,7 +2990,8 @@ AllocationResult LargeObjectSpace::AllocateRaw(int object_size,
AllocationStep(object->address(), object_size);
if (heap()->incremental_marking()->black_allocation()) {
Marking::MarkBlack(ObjectMarking::MarkBitFrom(object));
// We cannot use ObjectMarking here as the object still lacks a size.
Marking::WhiteToBlack(ObjectMarking::MarkBitFrom(object));
MemoryChunk::IncrementLiveBytes(object, object_size);
}
return object;
@ -3039,9 +3040,8 @@ void LargeObjectSpace::ClearMarkingStateOfLiveObjects() {
LargePage* current = first_page_;
while (current != NULL) {
HeapObject* object = current->GetObject();
MarkBit mark_bit = ObjectMarking::MarkBitFrom(object);
DCHECK(Marking::IsBlack(mark_bit));
Marking::BlackToWhite(mark_bit);
DCHECK(ObjectMarking::IsBlack(object));
ObjectMarking::BlackToWhite(object);
Page::FromAddress(object->address())->ResetProgressBar();
Page::FromAddress(object->address())->ResetLiveBytes();
current = current->next_page();
@ -3086,9 +3086,8 @@ void LargeObjectSpace::FreeUnmarkedObjects() {
LargePage* current = first_page_;
while (current != NULL) {
HeapObject* object = current->GetObject();
MarkBit mark_bit = ObjectMarking::MarkBitFrom(object);
DCHECK(!Marking::IsGrey(mark_bit));
if (Marking::IsBlack(mark_bit)) {
DCHECK(!ObjectMarking::IsGrey(object));
if (ObjectMarking::IsBlack(object)) {
Address free_start;
if ((free_start = current->GetAddressToShrink()) != 0) {
// TODO(hpayer): Perform partial free concurrently.
@ -3223,7 +3222,7 @@ void Page::Print() {
unsigned mark_size = 0;
for (HeapObject* object = objects.Next(); object != NULL;
object = objects.Next()) {
bool is_marked = Marking::IsBlackOrGrey(ObjectMarking::MarkBitFrom(object));
bool is_marked = ObjectMarking::IsBlackOrGrey(object);
PrintF(" %c ", (is_marked ? '!' : ' ')); // Indent a little.
if (is_marked) {
mark_size += object->Size();

2
src/objects-inl.h
View File

@ -2122,7 +2122,7 @@ void WeakCell::initialize(HeapObject* val) {
// We just have to execute the generational barrier here because we never
// mark through a weak cell and collect evacuation candidates when we process
// all weak cells.
WriteBarrierMode mode = Marking::IsBlack(ObjectMarking::MarkBitFrom(this))
WriteBarrierMode mode = ObjectMarking::IsBlack(this)
? UPDATE_WRITE_BARRIER
: UPDATE_WEAK_WRITE_BARRIER;
CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kValueOffset, val, mode);