On store buffer overflow we mark individidual pages for...

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 1708 matching lines @@
  public:
   static inline void VisitPointer(Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
     HeapObject* obj = HeapObject::cast(*p);
     Address old_addr = obj->address();
 
     if (Heap::new_space()->Contains(obj)) {
       ASSERT(Heap::InFromSpace(*p));
       *p = HeapObject::FromAddress(Memory::Address_at(old_addr));
+      StoreBuffer::EnterDirectlyIntoStoreBuffer(reinterpret_cast<Address>(p));

[Vyacheslav Egorov (Chromium), 2011/03/28 15:13:19]

This visitor is used to visit new space objects.

Their slots should not be entered into store-buffer.

[Erik Corry, 2011/03/28 15:56:07]

Good catch!

     }
   }
 };
 
 
 // Visitor for updating pointers from live objects in old spaces to new space.
 // It does not expect to encounter pointers to dead objects.
 class PointersToNewGenUpdatingVisitor: public ObjectVisitor {
  public:
   void VisitPointer(Object** p) {
@@ skipping 100 matching lines @@
 
   // Flip the semispaces.  After flipping, to space is empty, from space has
   // live objects.
   space->Flip();
   space->ResetAllocationInfo();
 
   int size = 0;
   int survivors_size = 0;
 
   // First pass: traverse all objects in inactive semispace, remove marks,
-  // migrate live objects and write forwarding addresses.
+  // migrate live objects and write forwarding addresses.  This stage puts
+  // new entries in the store buffer and may cause some pages to be marked
+  // scan-on-scavenge.
   for (Address current = from_bottom; current < from_top; current += size) {
     HeapObject* object = HeapObject::FromAddress(current);
 
 
     MarkBit mark_bit = Marking::MarkBitFromNewSpace(object);
     if (mark_bit.Get()) {
       mark_bit.Clear();
       MarkCompactCollector::tracer()->decrement_marked_count();
 
       size = object->Size();
@@ skipping 32 matching lines @@
     current +=
         StaticPointersToNewGenUpdatingVisitor::IterateBody(object->map(),
                                                            object);
   }
 
   // Update roots.
   Heap::IterateRoots(&updating_visitor, VISIT_ALL_IN_SCAVENGE);
   LiveObjectList::IterateElements(&updating_visitor);
 
   {
-    StoreBufferRebuildScope scope;
+    StoreBufferRebuildScope scope(&Heap::ScavengeStoreBufferCallback);
     StoreBuffer::IteratePointersToNewSpace(&UpdatePointerToNewGen);
   }
 
   // Update pointers from cells.
   HeapObjectIterator cell_iterator(Heap::cell_space());
   for (HeapObject* cell = cell_iterator.Next();
        cell != NULL;
        cell = cell_iterator.Next()) {
     if (cell->IsJSGlobalPropertyCell()) {
       Address value_address =
@@ skipping 483 matching lines @@
   if (free_start != p->ObjectAreaEnd()) {
     space->Free(free_start, p->ObjectAreaEnd() - free_start);
   }
 }
 
 
 void MarkCompactCollector::SweepSpace(PagedSpace* space,
                                       SweeperType sweeper) {
   space->set_was_swept_conservatively(sweeper == CONSERVATIVE);
 
-  // We don't have a linear allocation area while sweeping.  It will be restored
-  // on the first allocation after the sweep.
-  space->SetTop(NULL, NULL);
-
   space->ClearStats();
 
   PageIterator it(space);
 
   // During sweeping of paged space we are trying to find longest sequences
   // of pages without live objects and free them (instead of putting them on
   // the free list).
 
   // Page preceding current.
   Page* prev = Page::FromAddress(NULL);
@@ skipping 116 matching lines @@
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal