Unify markbits for old and new spaces.

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 187 matching lines @@
 }
 
 
 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());
   ClearMarkbits(heap_->map_space());
   ClearMarkbits(heap_->code_space());
+  heap_->new_space()->ActivePage()->markbits()->Clear();
 
   SetNewSpacePageFlags(heap_->new_space()->ActivePage(), true);
 
   LargePage* lop = heap_->lo_space()->first_page();
   while (lop->is_valid()) {
     SetOldSpacePageFlags(lop, true);
     lop = lop->next_page();
   }
 }
 
 
 #ifdef DEBUG
 void IncrementalMarking::VerifyMarkbitsAreClean(PagedSpace* space) {
   PageIterator it(space);
 
   while (it.has_next()) {
     Page* p = it.next();
     ASSERT(p->markbits()->IsClean());
   }
 }
 
 
 void IncrementalMarking::VerifyMarkbitsAreClean() {
   VerifyMarkbitsAreClean(heap_->old_pointer_space());
   VerifyMarkbitsAreClean(heap_->old_data_space());
   VerifyMarkbitsAreClean(heap_->code_space());
   VerifyMarkbitsAreClean(heap_->cell_space());
   VerifyMarkbitsAreClean(heap_->map_space());
+  ASSERT(heap_->new_space()->ActivePage()->markbits()->IsClean());
 }
 #endif
 
 
 bool IncrementalMarking::WorthActivating() {
 #ifndef DEBUG
   static const intptr_t kActivationThreshold = 8 * MB;
 #else
   // TODO(gc) consider setting this to some low level so that some
   // debug tests run with incremental marking and some without.
@@ skipping 74 matching lines @@
   PatchIncrementalMarkingRecordWriteStubs(true);
 
   EnsureMarkingDequeIsCommitted();
 
   // Initialize marking stack.
   Address addr = static_cast<Address>(marking_deque_memory->address());
   marking_deque_.Initialize(addr,
                             addr + marking_deque_memory->size());
 
   // Clear markbits.
-  Address new_space_low = heap_->new_space()->ToSpaceLow();
-  Address new_space_high = heap_->new_space()->ToSpaceHigh();
-  heap_->marking()->ClearRange(
-      new_space_low, static_cast<int>(new_space_high - new_space_low));
-
   ClearMarkbits();
 
 #ifdef DEBUG
   VerifyMarkbitsAreClean();
 #endif
 
   // Mark strong roots grey.
   IncrementalMarkingRootMarkingVisitor visitor(heap_, this);
   heap_->IterateStrongRoots(&visitor, VISIT_ONLY_STRONG);
 
   // Ready to start incremental marking.
   if (FLAG_trace_incremental_marking) {
     PrintF("[IncrementalMarking] Running\n");
   }
 }
 
 
 void IncrementalMarking::PrepareForScavenge() {
   if (!IsMarking()) return;
-
-  Address new_space_low = heap_->new_space()->FromSpaceLow();
-  Address new_space_high = heap_->new_space()->FromSpaceHigh();
-  heap_->marking()->ClearRange(
-      new_space_low, static_cast<int>(new_space_high - new_space_low));
+  heap_->new_space()->InactivePage()->markbits()->Clear();
 }
 
 
 void IncrementalMarking::UpdateMarkingDequeAfterScavenge() {
   if (!IsMarking()) return;
 
   intptr_t current = marking_deque_.bottom();
   intptr_t mask = marking_deque_.mask();
   intptr_t limit = marking_deque_.top();
   HeapObject** array = marking_deque_.array();
@@ skipping 126 matching lines @@
     while (!marking_deque_.IsEmpty() && bytes_to_process > 0) {
       HeapObject* obj = marking_deque_.Pop();
 
       // Explicitly skip one word fillers. Incremental markbit patterns are
       // correct only for objects that occupy at least two words.
       Map* map = obj->map();
       if (map != filler_map) {
         ASSERT(IsGrey(marking->MarkBitFrom(obj)));
         int size = obj->SizeFromMap(map);
         bytes_to_process -= size;
-        MarkBit map_mark_bit = marking->MarkBitFromOldSpace(map);
+        MarkBit map_mark_bit = marking->MarkBitFrom(map);
         if (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);
         MarkBlack(obj_mark_bit);
       }
     }
     if (marking_deque_.IsEmpty()) MarkingComplete();
   }
 
@@ skipping 10 matching lines @@
   }
 
   if (FLAG_trace_incremental_marking || FLAG_trace_gc) {
     double end = OS::TimeCurrentMillis();
     steps_took_ += (end - start);
   }
 }
 
 
 } }  // namespace v8::internal