Multi-page growing and shrinking new-space

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 69 matching lines @@
   INLINE(void MarkObjectByPointer(Object** p)) {
     Object* obj = *p;
     // Since we can be sure that the object is not tagged as a failure we can
     // inline a slightly more efficient tag check here than IsHeapObject() would
     // produce.
     if (obj->NonFailureIsHeapObject()) {
       HeapObject* heap_object = HeapObject::cast(obj);
       MarkBit mark_bit = Marking::MarkBitFrom(heap_object);
       if (mark_bit.data_only()) {
         incremental_marking_->MarkBlackOrKeepGrey(mark_bit);
-      } else {
-        if (Marking::IsWhite(mark_bit)) {
-          incremental_marking_->WhiteToGreyAndPush(heap_object, mark_bit);
-        }
+      } else if (Marking::IsWhite(mark_bit)) {
+        incremental_marking_->WhiteToGreyAndPush(heap_object, mark_bit);
       }
     }
   }
 
   Heap* heap_;
   IncrementalMarking* incremental_marking_;
 };
 
 
 class IncrementalMarkingRootMarkingVisitor : public ObjectVisitor {
@@ skipping 42 matching lines @@
              chunk->scan_on_scavenge()) {
     chunk->ClearFlag(MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING);
     chunk->ClearFlag(MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING);
   } else {
     chunk->ClearFlag(MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING);
     chunk->SetFlag(MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING);
   }
 }
 
 
-void IncrementalMarking::SetNewSpacePageFlags(MemoryChunk* chunk,
+void IncrementalMarking::SetNewSpacePageFlags(NewSpacePage* chunk,
                                               bool is_marking) {
   chunk->SetFlag(MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING);
   if (is_marking) {
     chunk->SetFlag(MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING);
   } else {
     chunk->ClearFlag(MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING);
   }
+  chunk->SetFlag(MemoryChunk::SCAN_ON_SCAVENGE);

[Vyacheslav Egorov (Chromium), 2011/06/14 11:52:55]

I am not sure this should be here.

[Erik Corry, 2011/06/14 12:23:17]

I think it's correct.  Scan-on-scavenge means that this page will be scanned on
a new-space collection.  This is definitely the case for new-space pages.

[Lasse Reichstein, 2011/06/14 14:13:03]

Keeping it.

 }
 
 
 void IncrementalMarking::DeactivateWriteBarrierForSpace(PagedSpace* space) {
   PageIterator it(space);
   while (it.has_next()) {
     Page* p = it.next();
     SetOldSpacePageFlags(p, false);
   }
 }
 
 
+void IncrementalMarking::DeactivateWriteBarrierForSpace(NewSpace* space) {

[Erik Corry, 2011/06/14 12:23:17]

This should really be called 'DeactivateIncrementalWriteBarrierForSpace' since
it does not deactivate the write barrier completely, only the remembered set.

[Lasse Reichstein, 2011/06/14 14:13:03]

search-and-replaced.

+  NewSpacePageIterator it(space->ToSpaceLow(), space->ToSpaceHigh());
+  while (it.has_next()) {
+    NewSpacePage* p = it.next();
+    SetNewSpacePageFlags(p, false);
+  }
+}
+
+
 void IncrementalMarking::DeactivateWriteBarrier() {
   DeactivateWriteBarrierForSpace(heap_->old_pointer_space());
   DeactivateWriteBarrierForSpace(heap_->old_data_space());
   DeactivateWriteBarrierForSpace(heap_->cell_space());
   DeactivateWriteBarrierForSpace(heap_->map_space());
   DeactivateWriteBarrierForSpace(heap_->code_space());
-
-  SetNewSpacePageFlags(heap_->new_space()->ActivePage(), false);
+  DeactivateWriteBarrierForSpace(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) {
   PageIterator it(space);
   while (it.has_next()) {
     Page* p = it.next();
     p->markbits()->Clear();
     SetOldSpacePageFlags(p, true);
   }
 }
 
 
+void IncrementalMarking::ClearMarkbits(NewSpace* space) {
+  NewSpacePageIterator it(space->ToSpaceLow(), space->ToSpaceHigh());

[Vyacheslav Egorov (Chromium), 2011/06/14 11:52:55]

I find iterator interface confusing as new space is no longer continuous.

[Erik Corry, 2011/06/14 12:23:17]

Agreed.  It would make more sense if it just took the space as an argument.

[Lasse Reichstein, 2011/06/14 14:13:03]

Actually that's why I want a page iterator to iterate over the pages of the
semispace without doing the book-keeping every time.

[Lasse Reichstein, 2011/06/14 14:13:03]

Changed to use NewSpacePageIterator(space), which does the same thing.

+  while (it.has_next()) {
+    NewSpacePage* p = it.next();
+    p->markbits()->Clear();
+    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());
-  heap_->new_space()->ActivePage()->markbits()->Clear();
-
-  SetNewSpacePageFlags(heap_->new_space()->ActivePage(), true);
+  ClearMarkbits(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->ToSpaceLow(), space->ToSpaceHigh());
+
+  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());
-  ASSERT(heap_->new_space()->ActivePage()->markbits()->IsClean());
+  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.
@@ skipping 91 matching lines @@
 
   // Ready to start incremental marking.
   if (FLAG_trace_incremental_marking) {
     PrintF("[IncrementalMarking] Running\n");
   }
 }
 
 
 void IncrementalMarking::PrepareForScavenge() {
   if (!IsMarking()) return;
-  heap_->new_space()->InactivePage()->markbits()->Clear();
+  NewSpacePageIterator it(heap_->new_space()->FromSpaceLow(),
+                          heap_->new_space()->FromSpaceHigh());
+  while (it.has_next()) {
+    it.next()->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 165 matching lines @@
   }
 
   if (FLAG_trace_incremental_marking || FLAG_trace_gc) {
     double end = OS::TimeCurrentMillis();
     steps_took_ += (end - start);
   }
 }
 
 
 } }  // namespace v8::internal