During a scavenge, instead of sweeping remembered-set bits for global...

src/heap.cc

 // Copyright 2009 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 583 matching lines @@
       // nodes) we want to verify them as well.
       object->Iterate(&v);
     }
   }
 
   HeapObjectIterator data_it(Heap::old_data_space());
   while (data_it.has_next()) data_it.next()->Iterate(&v);
 }
 #endif
 
+
 void Heap::Scavenge() {
 #ifdef DEBUG
   if (FLAG_enable_slow_asserts) VerifyNonPointerSpacePointers();
 #endif
 
   gc_state_ = SCAVENGE;
 
   // Implements Cheney's copying algorithm
   LOG(ResourceEvent("scavenge", "begin"));
 
@@ skipping 46 matching lines @@
   GlobalHandles::IterateWeakRoots(&scavenge_visitor);
 
 #ifdef V8_HOST_ARCH_64_BIT
   // TODO(X64): Make this go away again. We currently disable RSets for
   // 64-bit-mode.
   HeapObjectIterator old_pointer_iterator(old_pointer_space_);
   while (old_pointer_iterator.has_next()) {
     HeapObject* heap_object = old_pointer_iterator.next();
     heap_object->Iterate(&scavenge_visitor);
   }
-
-  HeapObjectIterator cell_iterator(cell_space_);
-  while (cell_iterator.has_next()) {
-    cell_iterator.next()->Iterate(&scavenge_visitor));
-  }
-
   HeapObjectIterator map_iterator(map_space_);
   while (map_iterator.has_next()) {
     HeapObject* heap_object = map_iterator.next();
     heap_object->Iterate(&scavenge_visitor);
   }
   LargeObjectIterator lo_iterator(lo_space_);
   while (lo_iterator.has_next()) {
     HeapObject* heap_object = lo_iterator.next();
     if (heap_object->IsFixedArray()) {
       heap_object->Iterate(&scavenge_visitor);
     }
   }
 #else  // !defined(V8_HOST_ARCH_64_BIT)
   // Copy objects reachable from the old generation.  By definition,
   // there are no intergenerational pointers in code or data spaces.
   IterateRSet(old_pointer_space_, &ScavengePointer);
-  IterateRSet(cell_space_, &ScavengePointer);
   IterateRSet(map_space_, &ScavengePointer);
   lo_space_->IterateRSet(&ScavengePointer);
 #endif
 
+  // Copy objects reachable from cells by scavenging cell values directly.
+  HeapObjectIterator cell_iterator(cell_space_);
+  while (cell_iterator.has_next()) {
+    HeapObject* cell = cell_iterator.next();
+    if (cell->IsJSGlobalPropertyCell()) {
+      Address value_address =
+          reinterpret_cast<Address>(cell) +
+          (JSGlobalPropertyCell::kValueOffset - kHeapObjectTag);
+      scavenge_visitor.VisitPointer(reinterpret_cast<Object**>(value_address));
+    }
+  }
+
   do {
     ASSERT(new_space_front <= new_space_.top());
 
     // The addresses new_space_front and new_space_.top() define a
     // queue of unprocessed copied objects.  Process them until the
     // queue is empty.
     while (new_space_front < new_space_.top()) {
       HeapObject* object = HeapObject::FromAddress(new_space_front);
       object->Iterate(&scavenge_visitor);
       new_space_front += object->Size();
@@ skipping 118 matching lines @@
     // pointers.
     UpdateRSetVisitor v;
     obj->Iterate(&v);
   }
 #endif  // V8_HOST_ARCH_64_BIT
   return obj->Size();
 }
 
 
 void Heap::RebuildRSets() {
-  // By definition, we do not care about remembered set bits in code or data
-  // spaces.
+  // By definition, we do not care about remembered set bits in code,
+  // data, or cell spaces.
   map_space_->ClearRSet();
   RebuildRSets(map_space_);
 
   old_pointer_space_->ClearRSet();
   RebuildRSets(old_pointer_space_);
 
-  cell_space_->ClearRSet();
-  RebuildRSets(cell_space_);
-
   Heap::lo_space_->ClearRSet();
   RebuildRSets(lo_space_);
 }
 
 
 void Heap::RebuildRSets(PagedSpace* space) {
   HeapObjectIterator it(space);
   while (it.has_next()) Heap::UpdateRSet(it.next());
 }
 
@@ skipping 2001 matching lines @@
       object_address += kPointerSize * kBitsPerInt;
     }
     rset_address += kIntSize;
   }
   return set_bits_count;
 }
 
 
 void Heap::IterateRSet(PagedSpace* space, ObjectSlotCallback copy_object_func) {
   ASSERT(Page::is_rset_in_use());
-  ASSERT(space == old_pointer_space_ ||
-         space == cell_space_ ||
-         space == map_space_);
+  ASSERT(space == old_pointer_space_ || space == map_space_);
 
   static void* paged_rset_histogram = StatsTable::CreateHistogram(
       "V8.RSetPaged",
       0,
       Page::kObjectAreaSize / kPointerSize,
       30);
 
   PageIterator it(space, PageIterator::PAGES_IN_USE);
   while (it.has_next()) {
     Page* page = it.next();
@@ skipping 801 matching lines @@
 #ifdef DEBUG
 bool Heap::GarbageCollectionGreedyCheck() {
   ASSERT(FLAG_gc_greedy);
   if (Bootstrapper::IsActive()) return true;
   if (disallow_allocation_failure()) return true;
   return CollectGarbage(0, NEW_SPACE);
 }
 #endif
 
 } }  // namespace v8::internal