}
-bool MarkCompactCollector::MustBeMarked(Object** p) {
- // Check whether *p is a HeapObject pointer.
- if (!(*p)->IsHeapObject()) return false;
- return !HeapObject::cast(*p)->IsMarked();
+bool MarkCompactCollector::IsUnmarkedHeapObject(Object** p) {
+ return (*p)->IsHeapObject() && !HeapObject::cast(*p)->IsMarked();
}
RootMarkingVisitor root_visitor;
MarkRoots(&root_visitor);
- // The objects reachable from the roots are marked black, unreachable
- // objects are white. Mark objects reachable from object groups with at
- // least one marked object, and continue until no new objects are
- // reachable from the object groups.
+ // The objects reachable from the roots are marked, yet unreachable
+ // objects are unmarked. Mark objects reachable from object groups
+ // containing at least one marked object, and continue until no new
+ // objects are reachable from the object groups.
ProcessObjectGroups(root_visitor.stack_visitor());
- // The objects reachable from the roots or object groups are marked black,
- // unreachable objects are white. Process objects reachable only from
- // weak global handles.
+ // The objects reachable from the roots or object groups are marked,
+ // yet unreachable objects are unmarked. Mark objects reachable
+ // only from weak global handles.
//
- // First we mark weak pointers not yet reachable.
- GlobalHandles::MarkWeakRoots(&MustBeMarked);
- // Then we process weak pointers and process the transitive closure.
+ // First we identify nonlive weak handles and mark them as pending
+ // destruction.
+ GlobalHandles::IdentifyWeakHandles(&IsUnmarkedHeapObject);
+ // Then we mark the objects and process the transitive closure.
GlobalHandles::IterateWeakRoots(&root_visitor);
while (marking_stack.overflowed()) {
RefillMarkingStack();
#ifdef DEBUG
-void MarkCompactCollector::UpdateLiveObjectCount(HeapObject* obj, int scale) {
- ASSERT(scale == -1 || scale == 1);
- live_bytes_ += obj->Size() * scale;
+void MarkCompactCollector::UpdateLiveObjectCount(HeapObject* obj) {
+ live_bytes_ += obj->Size();
if (Heap::new_space()->Contains(obj)) {
- live_young_objects_ += scale;
+ live_young_objects_++;
} else if (Heap::map_space()->Contains(obj)) {
ASSERT(obj->IsMap());
- live_map_objects_ += scale;
+ live_map_objects_ ++;
} else if (Heap::old_pointer_space()->Contains(obj)) {
- live_old_pointer_objects_ += scale;
+ live_old_pointer_objects_++;
} else if (Heap::old_data_space()->Contains(obj)) {
- live_old_data_objects_ += scale;
+ live_old_data_objects_++;
} else if (Heap::code_space()->Contains(obj)) {
- live_code_objects_ += scale;
+ live_code_objects_++;
} else if (Heap::lo_space()->Contains(obj)) {
- live_lo_objects_ +=scale;
+ live_lo_objects_++;
} else {
UNREACHABLE();
}
friend class RootMarkingVisitor;
friend class MarkingVisitor;
- friend class UnmarkingVisitor;
// Marking operations for objects reachable from roots.
static void MarkLiveObjects();
static inline void SetMark(HeapObject* obj) {
tracer_->increment_marked_count();
#ifdef DEBUG
- UpdateLiveObjectCount(obj, 1);
+ UpdateLiveObjectCount(obj);
#endif
obj->SetMark();
}
// flag on the marking stack.
static void RefillMarkingStack();
- // Callback function for telling whether the object *p must be marked.
- static bool MustBeMarked(Object** p);
+ // Callback function for telling whether the object *p is an unmarked
+ // heap object.
+ static bool IsUnmarkedHeapObject(Object** p);
#ifdef DEBUG
- // The scale argument is positive 1 if we are marking an object and
- // -1 if we are clearing the mark bit of an object that we didn't
- // actually want marked.
- static void UpdateLiveObjectCount(HeapObject* obj, int scale);
+ static void UpdateLiveObjectCount(HeapObject* obj);
#endif
// We sweep the large object space in the same way whether we are