Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(384)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/heap/mark-compact.cc

Issue 2644523002: [heap] Provide ObjectMarking with marking transitions (Closed)
Patch Set: Rebase Created 3 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/heap/mark-compact.h ('k') | src/heap/mark-compact-inl.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/heap/mark-compact.cc
diff --git a/src/heap/mark-compact.cc b/src/heap/mark-compact.cc
index f83eef2be9da3cdbe30a617ae8f416cab875e88b..9b986ce2f3b5d167ad80719937461a0dc4bdc0de 100644
--- a/src/heap/mark-compact.cc
+++ b/src/heap/mark-compact.cc
@@ -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.
« no previous file with comments | « src/heap/mark-compact.h ('k') | src/heap/mark-compact-inl.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698