Clear mark bits while sweeping and not explicitly.

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 212 matching lines @@
   DeactivateIncrementalWriteBarrierForSpace(heap_->new_space());
 
   LargePage* lop = heap_->lo_space()->first_page();
   while (lop->is_valid()) {
     SetOldSpacePageFlags(lop, false);
     lop = lop->next_page();
   }
 }
 
 
-void IncrementalMarking::ClearMarkbits(PagedSpace* space) {
+void IncrementalMarking::ActivateIncrementalWriteBarrier(PagedSpace* space) {
   PageIterator it(space);
   while (it.has_next()) {
     Page* p = it.next();
-    Bitmap::Clear(p);
     SetOldSpacePageFlags(p, true);
   }
 }
 
 
-void IncrementalMarking::ClearMarkbits(NewSpace* space) {
+void IncrementalMarking::ActivateIncrementalWriteBarrier(NewSpace* space) {
   NewSpacePageIterator it(space->ToSpaceStart(), space->ToSpaceEnd());
   while (it.has_next()) {
     NewSpacePage* p = it.next();
-    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());
-  ClearMarkbits(heap_->map_space());
-  ClearMarkbits(heap_->code_space());
-  ClearMarkbits(heap_->new_space());
+void IncrementalMarking::ActivateIncrementalWriteBarrier() {
+  ActivateIncrementalWriteBarrier(heap_->old_pointer_space());
+  ActivateIncrementalWriteBarrier(heap_->old_data_space());
+  ActivateIncrementalWriteBarrier(heap_->cell_space());
+  ActivateIncrementalWriteBarrier(heap_->map_space());
+  ActivateIncrementalWriteBarrier(heap_->code_space());
+  ActivateIncrementalWriteBarrier(heap_->new_space());
 
   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(NewSpace* space) {
-  NewSpacePageIterator it(space->ToSpaceStart(), space->ToSpaceEnd());
-
-  while (it.has_next()) {
-    NewSpacePage* 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());
-  VerifyMarkbitsAreClean(heap_->new_space());
-}
-#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.
   static const intptr_t kActivationThreshold = 0;
 #endif
 
   return FLAG_incremental_marking &&
@@ skipping 89 matching lines @@
   PatchIncrementalMarkingRecordWriteStubs(heap_, mode);
 
   EnsureMarkingDequeIsCommitted();
 
   // Initialize marking stack.
   Address addr = static_cast<Address>(marking_deque_memory_->address());
   size_t size = marking_deque_memory_->size();
   if (FLAG_force_marking_deque_overflows) size = 64 * kPointerSize;
   marking_deque_.Initialize(addr, addr + size);
 
-  // Clear markbits.
-  ClearMarkbits();
+  ActivateIncrementalWriteBarrier();
 
 #ifdef DEBUG
-  VerifyMarkbitsAreClean();
+  // Marking bits are cleared by the sweeper.
+  heap_->mark_compact_collector()->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");
   }
@@ skipping 205 matching lines @@
     double end = OS::TimeCurrentMillis();
     double delta = (end - start);
     longest_step_ = Max(longest_step_, delta);
     steps_took_ += delta;
     steps_took_since_last_gc_ += delta;
   }
 }
 
 
 } }  // namespace v8::internal