Start using store buffers. Handle store buffer overflow situation....

src/mark-compact.cc

 // Copyright 2006-2008 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 83 matching lines @@
   ASSERT(state_ == PREPARE_GC);
 
   // Prepare has selected whether to compact the old generation or not.
   // Tell the tracer.
   if (IsCompacting()) tracer_->set_is_compacting();
 
   MarkLiveObjects();
 
   if (FLAG_collect_maps) ClearNonLiveTransitions();
 
+  SweepSpaces();
   SweepLargeObjectSpace();

[Vyacheslav Egorov (Chromium), 2011/02/02 13:15:47]

You can now move SweepLargeObjectSpace into SweepSpaces. and probably eliminate
it entirely. Just call FreeUnmarkedObjects() directly.

[Erik Corry, 2011/02/03 13:21:17]

Done.

 
-  SweepSpaces();
   PcToCodeCache::FlushPcToCodeCache();
 
   Finish();
 
   // Check that swept all marked objects and
   // null out the GC tracer.
   // TODO(gc) does not work with conservative sweeping.
   // ASSERT(tracer_->marked_count() == 0);
   tracer_ = NULL;
 }
@@ skipping 292 matching lines @@
   InstanceType type = object->map()->instance_type();
   if ((type & kShortcutTypeMask) != kShortcutTypeTag) return object;
 
   Object* second = reinterpret_cast<ConsString*>(object)->unchecked_second();
   if (second != Heap::raw_unchecked_empty_string()) {
     return object;
   }
 
   // Since we don't have the object's start, it is impossible to update the
   // page dirty marks. Therefore, we only replace the string with its left
-  // substring when page dirty marks do not change.
+  // substring when page dirty marks do not change.  TODO(gc): Seems like we

[Vyacheslav Egorov (Chromium), 2011/02/02 13:15:47]

move todo to the new line

[Erik Corry, 2011/02/03 13:21:17]

Done.

+  // could relax this restriction with store buffers.
   Object* first = reinterpret_cast<ConsString*>(object)->unchecked_first();
   if (!Heap::InNewSpace(object) && Heap::InNewSpace(first)) return object;
 
   *p = first;
   return HeapObject::cast(first);
 }
 
 
 class StaticMarkingVisitor : public StaticVisitorBase {
  public:
@@ skipping 993 matching lines @@
     live_lo_objects_size_ += obj->Size();
   } else {
     UNREACHABLE();
   }
 }
 #endif  // DEBUG
 
 
 void MarkCompactCollector::SweepLargeObjectSpace() {
 #ifdef DEBUG
-  ASSERT(state_ == MARK_LIVE_OBJECTS);
-  state_ =
-      compacting_collection_ ? ENCODE_FORWARDING_ADDRESSES : SWEEP_SPACES;
+  ASSERT(state_ == SWEEP_SPACES);
 #endif
   // Deallocate unmarked objects and clear marked bits for marked objects.
   Heap::lo_space()->FreeUnmarkedObjects();
 }
 
 
 // Safe to use during marking phase only.
 bool MarkCompactCollector::SafeIsMap(HeapObject* object) {
   return object->map()->instance_type() == MAP_TYPE;
 }
@@ skipping 56 matching lines @@
       *HeapObject::RawField(current, Map::kPrototypeOffset) =
           real_prototype;
       current = reinterpret_cast<Map*>(next);
     }
   }
 }
 
 
 // We scavange new space simultaneously with sweeping. This is done in two
 // passes.
+//
 // The first pass migrates all alive objects from one semispace to another or
-// promotes them to old space. Forwading address is written directly into
-// first word of object without any encoding. If object is dead we are writing
+// promotes them to old space.  Forwarding address is written directly into
+// first word of object without any encoding.  If object is dead we write
 // NULL as a forwarding address.
-// The second pass updates pointers to new space in all spaces. It is possible
-// to encounter pointers to dead objects during traversal of dirty regions we
-// should clear them to avoid encountering them during next dirty regions
-// iteration.
+//
+// The second pass updates pointers to new space in all spaces.  It is possible
+// to encounter pointers to dead new space objects during traversal of pointers
+// to new space.  We should clear them to avoid encountering them during next
+// pointer iteration.  This is an issue if the store buffer overflows and we
+// have to scan the entire old space, including dead objects, looking for
+// pointers to new space.
 static void MigrateObject(Address dst,
                           Address src,
                           int size,
                           bool to_old_space) {
   if (to_old_space) {
     Heap::CopyBlockToOldSpaceAndUpdateWriteBarrier(dst, src, size);
   } else {
     Heap::CopyBlock(dst, src, size);
   }
-
   Memory::Address_at(src) = dst;
 }
 
 
 class StaticPointersToNewGenUpdatingVisitor : public
   StaticNewSpaceVisitor<StaticPointersToNewGenUpdatingVisitor> {
  public:
   static inline void VisitPointer(Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
@@ skipping 34 matching lines @@
             rinfo->IsPatchedReturnSequence()) ||
            (RelocInfo::IsDebugBreakSlot(rinfo->rmode()) &&
             rinfo->IsPatchedDebugBreakSlotSequence()));
     Object* target = Code::GetCodeFromTargetAddress(rinfo->call_address());
     VisitPointer(&target);
     rinfo->set_call_address(Code::cast(target)->instruction_start());
   }
 };
 
 
-// Visitor for updating pointers from live objects in old spaces to new space.
-// It can encounter pointers to dead objects in new space when traversing map
-// space (see comment for MigrateObject).
-static void UpdatePointerToNewGen(HeapObject** p) {
-  if (!(*p)->IsHeapObject()) return;
+static void UpdatePointerToNewGen(HeapObject** p, HeapObject* object) {
+  ASSERT(Heap::InFromSpace(object));
+  ASSERT(*p == object);
 
-  Address old_addr = (*p)->address();
-  ASSERT(Heap::InFromSpace(*p));
+  Address old_addr = object->address();
 
   Address new_addr = Memory::Address_at(old_addr);
 
-  if (new_addr == NULL) {
-    // We encountered pointer to a dead object. Clear it so we will
-    // not visit it again during next iteration of dirty regions.
-    *p = NULL;
+  // The new space sweep will overwrite the map word of dead objects
+  // with NULL. In this case we do not need to transfer this entry to
+  // the store buffer which we are rebuilding.
+  if (new_addr != NULL) {
+    *p = HeapObject::FromAddress(new_addr);
+    if (Heap::InNewSpace(new_addr)) {
+      StoreBuffer::EnterDirectlyIntoStoreBuffer(reinterpret_cast<Address>(p));
+    }
   } else {
-    *p = HeapObject::FromAddress(new_addr);
+    // We have to zap this pointer, because the store buffer may overflow later,
+    // and then we have to scan the entire heap and we don't want to find
+    // spurious newspace pointers in the old space.
+    *p = HeapObject::FromAddress(NULL);  // Fake heap object not in new space.
   }
 }
 
 
 static String* UpdateNewSpaceReferenceInExternalStringTableEntry(Object **p) {
   Address old_addr = HeapObject::cast(*p)->address();
   Address new_addr = Memory::Address_at(old_addr);
   return String::cast(HeapObject::FromAddress(new_addr));
 }
 
@@ skipping 67 matching lines @@
       // Promotion failed. Just migrate object to another semispace.
       // Allocation cannot fail at this point: semispaces are of equal size.
       Object* target = space->AllocateRaw(size)->ToObjectUnchecked();
 
       MigrateObject(HeapObject::cast(target)->address(),
                     current,
                     size,
                     false);
     } else {
       size = object->Size();
+      // Mark dead objects in the new space with null in their map field.
       Memory::Address_at(current) = NULL;
     }
   }
 
   // Second pass: find pointers to new space and update them.
   PointersToNewGenUpdatingVisitor updating_visitor;
 
   // Update pointers in to space.
   Address current = space->bottom();
   while (current < space->top()) {
     HeapObject* object = HeapObject::FromAddress(current);
     current +=
         StaticPointersToNewGenUpdatingVisitor::IterateBody(object->map(),
                                                            object);
   }
 
   // Update roots.
   Heap::IterateRoots(&updating_visitor, VISIT_ALL_IN_SCAVENGE);
 
-  // Update pointers in old spaces.
-  Heap::IterateDirtyRegions(Heap::old_pointer_space(),
-                            &Heap::IteratePointersInDirtyRegion,
-                            &UpdatePointerToNewGen,
-                            Heap::WATERMARK_SHOULD_BE_VALID);
-
-  Heap::lo_space()->IterateDirtyRegions(&UpdatePointerToNewGen);
+  {
+    StoreBufferRebuildScope scope;
+    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 =
           reinterpret_cast<Address>(cell) +
           (JSGlobalPropertyCell::kValueOffset - kHeapObjectTag);
@@ skipping 298 matching lines @@
     }
 #endif
 
     space->SetTop(new_allocation_top);
   }
 }
 
 
 void MarkCompactCollector::SweepSpaces() {
   GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_SWEEP);
-
-  ASSERT(state_ == SWEEP_SPACES);
+#ifdef DEBUG
+  state_ = SWEEP_SPACES;
+#endif
   ASSERT(!IsCompacting());
   // Noncompacting collections simply sweep the spaces to clear the mark
   // bits and free the nonlive blocks (for old and map spaces).  We sweep
   // the map space last because freeing non-live maps overwrites them and
   // the other spaces rely on possibly non-live maps to get the sizes for
   // non-live objects.
   SweepSpace(Heap::old_pointer_space(), CONSERVATIVE);
   SweepSpace(Heap::old_data_space(), CONSERVATIVE);
   SweepSpace(Heap::code_space(), PRECISE);
   // TODO(gc): implement specialized sweeper for cell space.
   SweepSpace(Heap::cell_space(), CONSERVATIVE);
   { GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_SWEEP_NEWSPACE);
     SweepNewSpace(Heap::new_space());
   }
   // TODO(gc): ClearNonLiveTransitions depends on precise sweeping of
   // map space to detect whether unmarked map became dead in this
   // collection or in one of the previous ones.
   // TODO(gc): Implement specialized sweeper for map space.
   SweepSpace(Heap::map_space(), PRECISE);
 
-  Heap::IterateDirtyRegions(Heap::map_space(),
-                            &Heap::IteratePointersInDirtyMapsRegion,
-                            &UpdatePointerToNewGen,
-                            Heap::WATERMARK_SHOULD_BE_VALID);
-
   ASSERT(live_map_objects_size_ <= Heap::map_space()->Size());
 }
 
 
 // Iterate the live objects in a range of addresses (eg, a page or a
 // semispace).  The live regions of the range have been linked into a list.
 // The first live region is [first_live_start, first_live_end), and the last
 // address in the range is top.  The callback function is used to get the
 // size of each live object.
 int MarkCompactCollector::IterateLiveObjectsInRange(
@@ skipping 55 matching lines @@
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal