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

src/spaces.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 418 matching lines @@
                                      Executability executable,
                                      Space* owner) {
   MemoryChunk* chunk = FromAddress(base);
 
   ASSERT(base == chunk->address());
 
   chunk->heap_ = heap;
   chunk->size_ = size;
   chunk->flags_ = 0;
   chunk->set_owner(owner);
-  chunk->markbits()->Clear();
+  Bitmap::Clear(chunk);
   chunk->initialize_scan_on_scavenge(false);
+
   ASSERT(OFFSET_OF(MemoryChunk, flags_) == kFlagsOffset);
 
   if (executable == EXECUTABLE) chunk->SetFlag(IS_EXECUTABLE);
 
   if (owner == heap->old_data_space()) chunk->SetFlag(CONTAINS_ONLY_DATA);
 
   return chunk;
 }
 
 
@@ skipping 346 matching lines @@
   while (page_iterator.has_next()) {
     Page* page = page_iterator.next();
     ASSERT(page->owner() == this);
     if (page == Page::FromAllocationTop(allocation_info_.top)) {
       allocation_pointer_found_in_space = true;
     }
     ASSERT(!page->IsFlagSet(MemoryChunk::WAS_SWEPT_CONSERVATIVELY));
     HeapObjectIterator it(page, NULL);
     Address end_of_previous_object = page->ObjectAreaStart();
     Address top = page->ObjectAreaEnd();
+    int black_size = 0;
     for (HeapObject* object = it.Next(); object != NULL; object = it.Next()) {
       ASSERT(end_of_previous_object <= object->address());
 
       // The first word should be a map, and we expect all map pointers to
       // be in map space.
       Map* map = object->map();
       ASSERT(map->IsMap());
       ASSERT(heap()->map_space()->Contains(map));
 
       // Perform space-specific object verification.
       VerifyObject(object);
 
       // The object itself should look OK.
       object->Verify();
 
       // All the interior pointers should be contained in the heap.
       int size = object->Size();
       object->IterateBody(map->instance_type(), size, visitor);
+      if (Marking::IsBlack(Marking::MarkBitFrom(object))) {
+        black_size += size;
+      }
 
       ASSERT(object->address() + size <= top);
       end_of_previous_object = object->address() + size;
     }
+    CHECK_LE(black_size, page->LiveBytes());
   }
 }
 #endif
 
 
 // -----------------------------------------------------------------------------
 // NewSpace implementation
 
 
 bool NewSpace::Setup(int maximum_semispace_capacity) {
@@ skipping 164 matching lines @@
 }
 
 
 void NewSpace::ResetAllocationInfo() {
   to_space_.Reset();
   UpdateAllocationInfo();
   pages_used_ = 0;
   // Clear all mark-bits in the to-space.
   NewSpacePageIterator it(&to_space_);
   while (it.has_next()) {
-    NewSpacePage* page = it.next();
-    page->markbits()->Clear();
+    Bitmap::Clear(it.next());
   }
 }
 
 
 bool NewSpace::AddFreshPage() {
   Address top = allocation_info_.top;
   if (NewSpacePage::IsAtStart(top)) {
     // The current page is already empty. Don't try to make another.
 
     // We should only get here if someone asks to allocate more
@@ skipping 171 matching lines @@
   }
   capacity_ = new_capacity;
   NewSpacePage* last_page = anchor()->prev_page();
   ASSERT(last_page != anchor());
   for (int i = pages_before + 1; i <= pages_after; i++) {
     Address page_address = end - i * Page::kPageSize;
     NewSpacePage* new_page = NewSpacePage::Initialize(heap(),
                                                       page_address,
                                                       this);
     new_page->InsertAfter(last_page);
-    new_page->markbits()->Clear();
+    Bitmap::Clear(new_page);
     // Duplicate the flags that was set on the old page.
     new_page->SetFlags(last_page->GetFlags(),
                        NewSpacePage::kCopyOnFlipFlagsMask);
     last_page = new_page;
   }
   return true;
 }
 
 
 bool SemiSpace::ShrinkTo(int new_capacity) {
@@ skipping 30 matching lines @@
   bool becomes_to_space = (id_ == kFromSpace);
   id_ = becomes_to_space ? kToSpace : kFromSpace;
   NewSpacePage* page = anchor_.next_page();
   while (page != &anchor_) {
     page->set_owner(this);
     page->SetFlags(flags, mask);
     if (becomes_to_space) {
       page->ClearFlag(MemoryChunk::IN_FROM_SPACE);
       page->SetFlag(MemoryChunk::IN_TO_SPACE);
       page->ClearFlag(MemoryChunk::NEW_SPACE_BELOW_AGE_MARK);
+      page->ResetLiveBytes();
     } else {
       page->SetFlag(MemoryChunk::IN_FROM_SPACE);
       page->ClearFlag(MemoryChunk::IN_TO_SPACE);
     }
     ASSERT(page->IsFlagSet(MemoryChunk::SCAN_ON_SCAVENGE));
     ASSERT(page->IsFlagSet(MemoryChunk::IN_TO_SPACE) ||
            page->IsFlagSet(MemoryChunk::IN_FROM_SPACE));
     page = page->next_page();
   }
 }
@@ skipping 55 matching lines @@
     CHECK(page->IsFlagSet(MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING));
     if (!is_from_space) {
       // The pointers-from-here-are-interesting flag isn't updated dynamically
       // on from-space pages, so it might be out of sync with the marking state.
       if (page->heap()->incremental_marking()->IsMarking()) {
         CHECK(page->IsFlagSet(MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING));
       } else {
         CHECK(!page->IsFlagSet(
             MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING));
       }
+      // TODO(gc): Check that the live_bytes_count_ field matches the
+      // black marking on the page (if we make it match in new-space).
     }
     CHECK(page->IsFlagSet(MemoryChunk::SCAN_ON_SCAVENGE));
     CHECK(page->prev_page()->next_page() == page);
     page = page->next_page();
   }
 }
 
 
 void SemiSpace::AssertValidRange(Address start, Address end) {
   // Addresses belong to same semi-space
@@ skipping 1025 matching lines @@
   LargePage* previous = NULL;
   LargePage* current = first_page_;
   while (current != NULL) {
     HeapObject* object = current->GetObject();
     // Can this large page contain pointers to non-trivial objects.  No other
     // pointer object is this big.
     bool is_pointer_object = object->IsFixedArray();
     MarkBit mark_bit = Marking::MarkBitFrom(object);
     if (mark_bit.Get()) {
       mark_bit.Clear();
+      MemoryChunk::IncrementLiveBytes(object->address(), -object->Size());
       previous = current;
       current = current->next_page();
     } else {
       LargePage* page = current;
       // Cut the chunk out from the chunk list.
       current = current->next_page();
       if (previous == NULL) {
         first_page_ = current;
       } else {
         previous->set_next_page(current);
@@ skipping 110 matching lines @@
   for (HeapObject* obj = obj_it.Next(); obj != NULL; obj = obj_it.Next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       isolate->code_kind_statistics()[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal