Estimate a (close) upper bound on the size of black-marked objects on each page.

src/mark-compact.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 267 matching lines @@
   VerifyMarkbitsAreClean(heap->map_space());
   VerifyMarkbitsAreClean(heap->new_space());
 }
 #endif
 
 
 static void ClearMarkbits(PagedSpace* space) {
   PageIterator it(space);
 
   while (it.has_next()) {
-    Page* p = it.next();
-    p->markbits()->Clear();
+    Bitmap::Clear(it.next());
   }
 }
 
 
 static void ClearMarkbits(NewSpace* space) {
   NewSpacePageIterator it(space->ToSpaceStart(), space->ToSpaceEnd());
 
   while (it.has_next()) {
-    NewSpacePage* p = it.next();
-    p->markbits()->Clear();
+    Bitmap::Clear(it.next());
   }
 }
 
 
 static void ClearMarkbits(Heap* heap) {
   // TODO(gc): Clean the mark bits while sweeping.
   ClearMarkbits(heap->code_space());
   ClearMarkbits(heap->map_space());
   ClearMarkbits(heap->old_pointer_space());
   ClearMarkbits(heap->old_data_space());
   ClearMarkbits(heap->cell_space());
   ClearMarkbits(heap->new_space());
 }
 
 
-void Marking::TransferMark(Address old_start, Address new_start) {
-  if (old_start == new_start) return;
+bool Marking::TransferMark(Address old_start, Address new_start) {
+  // This is only used when resizing an object.
+  ASSERT(MemoryChunk::FromAddress(old_start) ==
+         MemoryChunk::FromAddress(new_start));
+  // If the mark doesn't move, we don't check the color of the object.
+  // It doesn't matter whether the object is black, since it hasn't changed
+  // size, so the adjustment to the live data count will be zero anyway.
+  if (old_start == new_start) return false;
 
   MarkBit new_mark_bit = MarkBitFrom(new_start);
 
   if (heap_->incremental_marking()->IsMarking()) {
     MarkBit old_mark_bit = MarkBitFrom(old_start);
 #ifdef DEBUG
     ObjectColor old_color = Color(old_mark_bit);
 #endif
     if (Marking::IsBlack(old_mark_bit)) {
       Marking::MarkBlack(new_mark_bit);
       old_mark_bit.Clear();
+      return true;
     } else if (Marking::IsGrey(old_mark_bit)) {
       old_mark_bit.Next().Clear();
       heap_->incremental_marking()->WhiteToGreyAndPush(
           HeapObject::FromAddress(new_start), new_mark_bit);
       heap_->incremental_marking()->RestartIfNotMarking();
       // TODO(gc): if we shift huge array in the loop we might end up pushing
       // too much into the marking deque. Maybe we should check one or two
       // elements on top/bottom of the marking deque to see whether they are
       // equal to old_start.
     }
 
 #ifdef DEBUG
     ObjectColor new_color = Color(new_mark_bit);
     ASSERT(new_color == old_color);
 #endif
-  } else {
-    if (heap_->InNewSpace(old_start)) {
-      return;
-    } else {
-      MarkBit old_mark_bit = MarkBitFrom(old_start);
-      if (!old_mark_bit.Get()) {
-        return;
-      }
-    }
-    new_mark_bit.Set();
+    return false;
   }
+  MarkBit old_mark_bit = MarkBitFrom(old_start);
+  if (!old_mark_bit.Get()) {
+    return false;
+  }
+  new_mark_bit.Set();
+  return true;
 }
 
 
 void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {
   ASSERT(space->identity() == OLD_POINTER_SPACE ||
          space->identity() == OLD_DATA_SPACE);
 
   PageIterator it(space);
   while (it.has_next()) {
     Page* p = it.next();
@@ skipping 1009 matching lines @@
   }
 }
 
 
 void MarkCompactCollector::MarkMapContents(Map* map) {
   // Mark prototype transitions array but don't push it into marking stack.
   // This will make references from it weak. We will clean dead prototype
   // transitions in ClearNonLiveTransitions.
   FixedArray* prototype_transitions = map->prototype_transitions();
   MarkBit mark = Marking::MarkBitFrom(prototype_transitions);
-  if (!mark.Get()) mark.Set();
+  if (!mark.Get()) {
+    mark.Set();
+    MemoryChunk::IncrementLiveBytes(prototype_transitions->address(),
+                                    prototype_transitions->Size());
+  }
 
   Object** raw_descriptor_array_slot =
       HeapObject::RawField(map, Map::kInstanceDescriptorsOrBitField3Offset);
   Object* raw_descriptor_array = *raw_descriptor_array_slot;
   if (!raw_descriptor_array->IsSmi()) {
     MarkDescriptorArray(
         reinterpret_cast<DescriptorArray*>(raw_descriptor_array));
   }
 
   // Mark the Object* fields of the Map.
@@ skipping 817 matching lines @@
   // migrate live objects and write forwarding addresses.  This stage puts
   // new entries in the store buffer and may cause some pages to be marked
   // scan-on-scavenge.
   SemiSpaceIterator from_it(from_bottom, from_top);
   for (HeapObject* object = from_it.Next();
        object != NULL;
        object = from_it.Next()) {
     MarkBit mark_bit = Marking::MarkBitFrom(object);
     if (mark_bit.Get()) {
       mark_bit.Clear();
-
       int size = object->Size();
       survivors_size += size;
+      MemoryChunk::IncrementLiveBytes(object->address(), -size);
 
       // Aggressively promote young survivors to the old space.
       if (TryPromoteObject(object, size)) {
         continue;
       }
 
       // Promotion failed. Just migrate object to another semispace.
       MaybeObject* allocation = new_space->AllocateRaw(size);
       if (allocation->IsFailure()) {
         if (!new_space->AddFreshPage()) {
@@ skipping 839 matching lines @@
     visitor->VisitPointer(last_buffer[slot_idx]);
   }
 }
 
 
 void SlotsBuffer::Report() {
 }
 
 
 } }  // namespace v8::internal