Fix lazy sweeping for new marking bit clearing.

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 61 matching lines @@
   ASSERT(owner == HEAP->old_pointer_space() ||
          owner == HEAP->old_data_space() ||
          owner == HEAP->map_space() ||
          owner == HEAP->cell_space() ||
          owner == HEAP->code_space());
   Initialize(reinterpret_cast<PagedSpace*>(owner),
              page->ObjectAreaStart(),
              page->ObjectAreaEnd(),
              kOnePageOnly,
              size_func);
-  ASSERT(!page->IsFlagSet(Page::WAS_SWEPT_CONSERVATIVELY));
+  ASSERT(page->WasSweptPrecisely());
 }
 
 
 void HeapObjectIterator::Initialize(PagedSpace* space,
                                     Address cur, Address end,
                                     HeapObjectIterator::PageMode mode,
                                     HeapObjectCallback size_f) {
   // Check that we actually can iterate this space.
   ASSERT(!space->was_swept_conservatively());
 
@@ skipping 18 matching lines @@
   if (cur_addr_ == NULL) {
     cur_page = space_->anchor();
   } else {
     cur_page = Page::FromAddress(cur_addr_ - 1);
     ASSERT(cur_addr_ == cur_page->ObjectAreaEnd());
   }
   cur_page = cur_page->next_page();
   if (cur_page == space_->anchor()) return false;
   cur_addr_ = cur_page->ObjectAreaStart();
   cur_end_ = cur_page->ObjectAreaEnd();
-  ASSERT(!cur_page->IsFlagSet(Page::WAS_SWEPT_CONSERVATIVELY));
+  ASSERT(cur_page->WasSweptPrecisely());
   return true;
 }
 
 
 #ifdef DEBUG
 void HeapObjectIterator::Verify() {
   // TODO(gc): We should do something here.
 }
 #endif
 
@@ skipping 311 matching lines @@
 
   ASSERT(base == chunk->address());
 
   chunk->heap_ = heap;
   chunk->size_ = size;
   chunk->flags_ = 0;
   chunk->set_owner(owner);
   chunk->slots_buffer_ = NULL;
   Bitmap::Clear(chunk);
   chunk->initialize_scan_on_scavenge(false);
+  chunk->SetFlag(WAS_SWEPT_PRECISELY);
 
   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 320 matching lines @@
 
   bool allocation_pointer_found_in_space =
       (allocation_info_.top != allocation_info_.limit);
   PageIterator page_iterator(this);
   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));
+    ASSERT(page->WasSweptPrecisely());
     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();
@@ skipping 1119 matching lines @@
 
 void PagedSpace::PrepareForMarkCompact() {
   // We don't have a linear allocation area while sweeping.  It will be restored
   // on the first allocation after the sweep.
   // Mark the old linear allocation area with a free space map so it can be
   // skipped when scanning the heap.
   int old_linear_size = static_cast<int>(limit() - top());
   Free(top(), old_linear_size);
   SetTop(NULL, NULL);
 
-  // Stop lazy sweeping and clear marking bits for the space.
+  // Stop lazy sweeping and clear marking bits for unswept pages.
   if (first_unswept_page_ != NULL) {
-    int pages = 0;
     Page* last = last_unswept_page_->next_page();
     Page* p = first_unswept_page_;
     do {
-      pages++;
-      Bitmap::Clear(p);
+      if (ShouldBeSweptLazily(p)) {
+        ASSERT(!p->WasSwept());
+        Bitmap::Clear(p);
+        if (FLAG_gc_verbose) {
+          PrintF("Sweeping 0x%" V8PRIxPTR " lazily abandoned.\n",
+                 reinterpret_cast<intptr_t>(p));
+        }
+      }
       p = p->next_page();
     } while (p != last);
-    if (FLAG_trace_gc) {
-      PrintF("Abandoned %d unswept pages\n", pages);
-    }
   }
   first_unswept_page_ = last_unswept_page_ = Page::FromAddress(NULL);
 
   // Clear the free list before a full GC---it will be rebuilt afterward.
   free_list_.Reset();
-
-  // Clear WAS_SWEPT and WAS_SWEPT_CONSERVATIVELY flags from all pages.
-  PageIterator it(this);
-  while (it.has_next()) {
-    Page* page = it.next();
-    page->ClearSwept();
-    page->ClearFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
-  }
 }
 
 
 bool PagedSpace::ReserveSpace(int size_in_bytes) {
   ASSERT(size_in_bytes <= Page::kMaxHeapObjectSize);
   ASSERT(size_in_bytes == RoundSizeDownToObjectAlignment(size_in_bytes));
   Address current_top = allocation_info_.top;
   Address new_top = current_top + size_in_bytes;
   if (new_top <= allocation_info_.limit) return true;
 
@@ skipping 21 matching lines @@
 
 
 bool PagedSpace::AdvanceSweeper(intptr_t bytes_to_sweep) {
   if (IsSweepingComplete()) return true;
 
   intptr_t freed_bytes = 0;
   Page* last = last_unswept_page_->next_page();
   Page* p = first_unswept_page_;
   do {
     Page* next_page = p->next_page();
-    // Evacuation candidates were swept by evacuator.
-    if (!p->IsEvacuationCandidate() &&
-        !p->IsFlagSet(Page::RESCAN_ON_EVACUATION) &&
-        !p->WasSwept()) {
+    if (ShouldBeSweptLazily(p)) {
+      if (FLAG_gc_verbose) {
+        PrintF("Sweeping 0x%" V8PRIxPTR " lazily advanced.\n",
+               reinterpret_cast<intptr_t>(p));
+      }
       freed_bytes += MarkCompactCollector::SweepConservatively(this, p);
     }
     p = next_page;
   } while (p != last && freed_bytes < bytes_to_sweep);
 
   if (p == last) {
     last_unswept_page_ = first_unswept_page_ = Page::FromAddress(NULL);
   } else {
     first_unswept_page_ = p;
   }
@@ skipping 490 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