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

src/incremental-marking.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 68 matching lines @@
   // Mark object pointed to by p.
   INLINE(void MarkObjectByPointer(Object** p)) {
     Object* obj = *p;
     // Since we can be sure that the object is not tagged as a failure we can
     // inline a slightly more efficient tag check here than IsHeapObject() would
     // produce.
     if (obj->NonFailureIsHeapObject()) {
       HeapObject* heap_object = HeapObject::cast(obj);
       MarkBit mark_bit = Marking::MarkBitFrom(heap_object);
       if (mark_bit.data_only()) {
-        incremental_marking_->MarkBlackOrKeepGrey(mark_bit);
+        if (incremental_marking_->MarkBlackOrKeepGrey(mark_bit)) {
+          MemoryChunk::IncrementLiveBytes(heap_object->address(),
+                                          heap_object->Size());
+        }
       } else if (Marking::IsWhite(mark_bit)) {
         incremental_marking_->WhiteToGreyAndPush(heap_object, mark_bit);
       }
     }
   }
 
   Heap* heap_;
   IncrementalMarking* incremental_marking_;
 };
 
@@ skipping 15 matching lines @@
   }
 
  private:
   void MarkObjectByPointer(Object** p) {
     Object* obj = *p;
     if (!obj->IsHeapObject()) return;
 
     HeapObject* heap_object = HeapObject::cast(obj);
     MarkBit mark_bit = Marking::MarkBitFrom(heap_object);
     if (mark_bit.data_only()) {
-      incremental_marking_->MarkBlackOrKeepGrey(mark_bit);
+      if (incremental_marking_->MarkBlackOrKeepGrey(mark_bit)) {
+          MemoryChunk::IncrementLiveBytes(heap_object->address(),
+                                          heap_object->Size());
+      }
     } else {
       if (Marking::IsWhite(mark_bit)) {
         incremental_marking_->WhiteToGreyAndPush(heap_object, mark_bit);
       }
     }
   }
 
   Heap* heap_;
   IncrementalMarking* incremental_marking_;
 };
@@ skipping 60 matching lines @@
     SetOldSpacePageFlags(lop, false);
     lop = lop->next_page();
   }
 }
 
 
 void IncrementalMarking::ClearMarkbits(PagedSpace* space) {
   PageIterator it(space);
   while (it.has_next()) {
     Page* p = it.next();
-    p->markbits()->Clear();
+    Bitmap::Clear(p);
     SetOldSpacePageFlags(p, true);
   }
 }
 
 
 void IncrementalMarking::ClearMarkbits(NewSpace* space) {
   NewSpacePageIterator it(space->ToSpaceStart(), space->ToSpaceEnd());
   while (it.has_next()) {
     NewSpacePage* p = it.next();
-    p->markbits()->Clear();
+    Bitmap::Clear(p);
     SetNewSpacePageFlags(p, true);
   }
 }
 
 
 void IncrementalMarking::ClearMarkbits() {
   // TODO(gc): Clear the mark bits in the sweeper.
   ClearMarkbits(heap_->old_pointer_space());
   ClearMarkbits(heap_->old_data_space());
   ClearMarkbits(heap_->cell_space());
@@ skipping 144 matching lines @@
     PrintF("[IncrementalMarking] Running\n");
   }
 }
 
 
 void IncrementalMarking::PrepareForScavenge() {
   if (!IsMarking()) return;
   NewSpacePageIterator it(heap_->new_space()->FromSpaceStart(),
                           heap_->new_space()->FromSpaceEnd());
   while (it.has_next()) {
-    it.next()->markbits()->Clear();
+    Bitmap::Clear(it.next());
   }
 }
 
 
 void IncrementalMarking::UpdateMarkingDequeAfterScavenge() {
   if (!IsMarking()) return;
 
   intptr_t current = marking_deque_.bottom();
   intptr_t mask = marking_deque_.mask();
   intptr_t limit = marking_deque_.top();
@@ skipping 39 matching lines @@
     Map* filler_map = heap_->one_pointer_filler_map();
     IncrementalMarkingMarkingVisitor marking_visitor(heap_, this);
     while (!marking_deque_.IsEmpty()) {
       HeapObject* obj = marking_deque_.Pop();
 
       // Explicitly skip one word fillers. Incremental markbit patterns are
       // correct only for objects that occupy at least two words.
       if (obj->map() != filler_map) {
         obj->Iterate(&marking_visitor);
         MarkBit mark_bit = Marking::MarkBitFrom(obj);
+        ASSERT(!Marking::IsBlack(mark_bit));
         Marking::MarkBlack(mark_bit);
+        MemoryChunk::IncrementLiveBytes(obj->address(), obj->Size());
       }
     }
     state_ = COMPLETE;
     if (FLAG_trace_incremental_marking) {
       double end = OS::TimeCurrentMillis();
       PrintF("[IncrementalMarking] Complete (hurry), spent %d ms.\n",
              static_cast<int>(end - start));
     }
   }
 }
@@ skipping 80 matching lines @@
         ASSERT(Marking::IsGrey(Marking::MarkBitFrom(obj)));
         int size = obj->SizeFromMap(map);
         bytes_to_process -= size;
         MarkBit map_mark_bit = Marking::MarkBitFrom(map);
         if (Marking::IsWhite(map_mark_bit)) {
           WhiteToGreyAndPush(map, map_mark_bit);
         }
         // TODO(gc) switch to static visitor instead of normal visitor.
         obj->IterateBody(map->instance_type(), size, &marking_visitor);
         MarkBit obj_mark_bit = Marking::MarkBitFrom(obj);
+        ASSERT(!Marking::IsBlack(obj_mark_bit));
         Marking::MarkBlack(obj_mark_bit);
+        MemoryChunk::IncrementLiveBytes(obj->address(), size);
       }
     }
     if (marking_deque_.IsEmpty()) MarkingComplete();
   }
 
   allocated_ = 0;
 
   steps_count_++;
 
   if ((steps_count_ % kAllocationMarkingFactorSpeedupInterval) == 0) {
     allocation_marking_factor_ += kAllocationMarkingFactorSpeedup;
     allocation_marking_factor_ *= 1.3;
     if (FLAG_trace_gc) {
       PrintF("Marking speed increased to %d\n", allocation_marking_factor_);
     }
   }
 
   if (FLAG_trace_incremental_marking || FLAG_trace_gc) {
     double end = OS::TimeCurrentMillis();
     steps_took_ += (end - start);
   }
 }
 
 
 } }  // namespace v8::internal