Clear mark bits while sweeping and not explicitly.

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 262 matching lines @@
 
   heap_->isolate()->pc_to_code_cache()->Flush();
 
   Finish();
 
   tracer_ = NULL;
 }
 
 
 #ifdef DEBUG
-static void VerifyMarkbitsAreClean(PagedSpace* space) {
+void MarkCompactCollector::VerifyMarkbitsAreClean(PagedSpace* space) {
   PageIterator it(space);
 
   while (it.has_next()) {
     Page* p = it.next();
     ASSERT(p->markbits()->IsClean());
   }
 }
 
-static void VerifyMarkbitsAreClean(NewSpace* space) {
+void MarkCompactCollector::VerifyMarkbitsAreClean(NewSpace* space) {
   NewSpacePageIterator it(space->bottom(), space->top());
 
   while (it.has_next()) {
     NewSpacePage* p = it.next();
     ASSERT(p->markbits()->IsClean());
   }
 }
 
-static void VerifyMarkbitsAreClean(Heap* heap) {
-  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());
+void MarkCompactCollector::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
 
 
 static void ClearMarkbits(PagedSpace* space) {
   PageIterator it(space);
 
   while (it.has_next()) {
     Bitmap::Clear(it.next());
   }
 }
 
 
 static void ClearMarkbits(NewSpace* space) {
   NewSpacePageIterator it(space->ToSpaceStart(), space->ToSpaceEnd());
 
   while (it.has_next()) {
     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());
 }
 
 
 bool Marking::TransferMark(Address old_start, Address new_start) {
@@ skipping 83 matching lines @@
   ASSERT(!FLAG_always_compact || !FLAG_never_compact);
 
   if (collect_maps_) CreateBackPointers();
 #ifdef ENABLE_GDB_JIT_INTERFACE
   if (FLAG_gdbjit) {
     // If GDBJIT interface is active disable compaction.
     compacting_collection_ = false;
   }
 #endif
 
+  // Clear marking bits for precise sweeping to collect all garbage.
   if (heap()->incremental_marking()->IsMarking() && PreciseSweepingRequired()) {
     heap()->incremental_marking()->Abort();
+    ClearMarkbits(heap_);
   }
 
   if (!FLAG_never_compact) StartCompaction();
 
   PagedSpaces spaces;
   for (PagedSpace* space = spaces.next();
        space != NULL;
        space = spaces.next()) {
     space->PrepareForMarkCompact();
   }
 
+#ifdef DEBUG
   if (!heap()->incremental_marking()->IsMarking()) {
-    ClearMarkbits(heap_);
-#ifdef DEBUG
-    VerifyMarkbitsAreClean(heap_);
+    VerifyMarkbitsAreClean();
+  }
 #endif
-  }
 
 #ifdef DEBUG
   live_bytes_ = 0;
   live_young_objects_size_ = 0;
   live_old_pointer_objects_size_ = 0;
   live_old_data_objects_size_ = 0;
   live_code_objects_size_ = 0;
   live_map_objects_size_ = 0;
   live_cell_objects_size_ = 0;
   live_lo_objects_size_ = 0;
@@ skipping 2153 matching lines @@
 
 
 // Sweep a space precisely.  After this has been done the space can
 // be iterated precisely, hitting only the live objects.  Code space
 // is always swept precisely because we want to be able to iterate
 // over it.  Map space is swept precisely, because it is not compacted.
 // Slots in live objects pointing into evacuation candidates are updated
 // if requested.
 static void SweepPrecisely(PagedSpace* space, Page* p, SweepingMode mode) {
   ASSERT(!p->IsEvacuationCandidate() && !p->WasSwept());
+  ASSERT(!p->IsFlagSet(MemoryChunk::WAS_SWEPT_CONSERVATIVELY));
   MarkBit::CellType* cells = p->markbits()->cells();
-
-  p->ClearFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
   p->MarkSwept();
 
   int last_cell_index =
       Bitmap::IndexToCell(
           Bitmap::CellAlignIndex(
               p->AddressToMarkbitIndex(p->ObjectAreaEnd())));
 
   int cell_index = Page::kFirstUsedCell;
   Address free_start = p->ObjectAreaStart();
   ASSERT(reinterpret_cast<intptr_t>(free_start) % (32 * kPointerSize) == 0);
@@ skipping 16 matching lines @@
       }
       HeapObject* live_object = HeapObject::FromAddress(free_end);
       ASSERT(Marking::IsBlack(Marking::MarkBitFrom(live_object)));
       int size = live_object->Size();
       if (mode == SWEEP_AND_UPDATE_SLOTS) {
         UpdateSlotsInRange(HeapObject::RawField(live_object, kPointerSize),
                            HeapObject::RawField(live_object, size));
       }
       free_start = free_end + size;
     }
+    // Clear marking bits for current cell.
+    cells[cell_index] = 0;
   }
   if (free_start != p->ObjectAreaEnd()) {
     space->Free(free_start, static_cast<int>(p->ObjectAreaEnd() - free_start));
   }
 }
 
 
 void MarkCompactCollector::EvacuateNewSpaceAndCandidates() {
   EvacuateNewSpace();
   EvacuatePages();
@@ skipping 420 matching lines @@
 
 // Sweeps a space conservatively.  After this has been done the larger free
 // spaces have been put on the free list and the smaller ones have been
 // ignored and left untouched.  A free space is always either ignored or put
 // on the free list, never split up into two parts.  This is important
 // because it means that any FreeSpace maps left actually describe a region of
 // memory that can be ignored when scanning.  Dead objects other than free
 // spaces will not contain the free space map.
 intptr_t MarkCompactCollector::SweepConservatively(PagedSpace* space, Page* p) {
   ASSERT(!p->IsEvacuationCandidate() && !p->WasSwept());
-
-  intptr_t freed_bytes = 0;
-
   MarkBit::CellType* cells = p->markbits()->cells();
-
   p->SetFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
 
-  // This is the start of the 32 word block that we are currently looking at.
-  Address block_address = p->ObjectAreaStart();
-
   int last_cell_index =
       Bitmap::IndexToCell(
           Bitmap::CellAlignIndex(
               p->AddressToMarkbitIndex(p->ObjectAreaEnd())));
 
   int cell_index = Page::kFirstUsedCell;
+  intptr_t freed_bytes = 0;
+
+  // This is the start of the 32 word block that we are currently looking at.
+  Address block_address = p->ObjectAreaStart();
 
   // Skip over all the dead objects at the start of the page and mark them free.
   for (cell_index = Page::kFirstUsedCell;
        cell_index < last_cell_index;
        cell_index++, block_address += 32 * kPointerSize) {
     if (cells[cell_index] != 0) break;
   }
   size_t size = block_address - p->ObjectAreaStart();
   if (cell_index == last_cell_index) {
     freed_bytes += static_cast<int>(space->Free(p->ObjectAreaStart(),
@@ skipping 35 matching lines @@
           // so now we need to find the start of the first live object at the
           // end of the free space.
           free_end = StartOfLiveObject(block_address, cell);
           freed_bytes += space->Free(free_start,
                                      static_cast<int>(free_end - free_start));
         }
       }
       // Update our undigested record of where the current free area started.
       free_start = block_address;
       free_start_cell = cell;
+      // Clear marking bits for current cell.
+      cells[cell_index] = 0;
     }
   }
 
   // Handle the free space at the end of the page.
   if (block_address - free_start > 32 * kPointerSize) {
     free_start = DigestFreeStart(free_start, free_start_cell);
     freed_bytes += space->Free(free_start,
                                static_cast<int>(block_address - free_start));
   }
 
@@ skipping 207 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal