Unify UpdateSlotsOnPage and SweepPrecisely.

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 2592 matching lines @@
       MapWord map_word = HeapObject::cast(obj)->map_word();
       if (map_word.IsForwardingAddress()) {
         *slot = map_word.ToForwardingAddress();
         ASSERT(!MarkCompactCollector::IsOnEvacuationCandidate(*slot));
       }
     }
   }
 }
 
 
-static void UpdateSlotsOnPage(Page* p, ObjectVisitor* visitor) {
-  // TODO(gc) this is basically clone of SweepPrecisely
-  PagedSpace* space = static_cast<PagedSpace*>(p->owner());

[Vyacheslav Egorov (Chromium), 2011/08/22 17:00:37]

I prefer enums to booleans they make callsites clearer.

[Michael Starzinger, 2011/08/23 07:48:48]

Done.

+// Sweep a space precisely.  After this has been done the space can
+// be iterated precisely, hitting only the live objects.  Code space
+// is always swept precisely because we want to be able to iterate
+// over it.  Map space is swept precisely, because it is not compacted.
+// Slots in live objects pointing into evacuation candidates are updated
+// if requested.
+static void SweepPrecisely(PagedSpace* space, Page* p, bool update_slots) {
+  ASSERT(!p->IsEvacuationCandidate() && !p->WasSwept());
   MarkBit::CellType* cells = p->markbits()->cells();
 
   p->ClearFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
-  p->ClearFlag(MemoryChunk::RESCAN_ON_EVACUATION);
   p->MarkSwept();
 
   int last_cell_index =
       Bitmap::IndexToCell(
           Bitmap::CellAlignIndex(
               p->AddressToMarkbitIndex(p->ObjectAreaEnd())));
 
   int cell_index = Page::kFirstUsedCell;
   Address free_start = p->ObjectAreaStart();
   ASSERT(reinterpret_cast<intptr_t>(free_start) % (32 * kPointerSize) == 0);
@@ skipping 10 matching lines @@
     int live_objects = MarkWordToObjectStarts(cells[cell_index], offsets);
     int live_index = 0;
     for ( ; live_objects != 0; live_objects--) {
       Address free_end = object_address + offsets[live_index++] * kPointerSize;
       if (free_end != free_start) {
         space->Free(free_start, static_cast<int>(free_end - free_start));
       }
       HeapObject* live_object = HeapObject::FromAddress(free_end);
       ASSERT(Marking::IsBlack(Marking::MarkBitFrom(live_object)));
       int size = live_object->Size();
-      UpdateSlotsInRange(HeapObject::RawField(live_object, kPointerSize),
-                         HeapObject::RawField(live_object, size));
+      if (update_slots) {
+        UpdateSlotsInRange(HeapObject::RawField(live_object, kPointerSize),
+                           HeapObject::RawField(live_object, size));
+      }
       free_start = free_end + size;
     }
   }
   if (free_start != p->ObjectAreaEnd()) {
     space->Free(free_start, static_cast<int>(p->ObjectAreaEnd() - free_start));
   }
 }
 
 
 void MarkCompactCollector::EvacuateNewSpaceAndCandidates() {
@@ skipping 39 matching lines @@
            p->IsFlagSet(Page::RESCAN_ON_EVACUATION));
 
     if (p->IsEvacuationCandidate()) {
       SlotsBuffer::UpdateSlotsRecordedIn(p->slots_buffer());
       if (FLAG_trace_fragmentation) {
         PrintF("  page %p slots buffer: %d\n",
                reinterpret_cast<void*>(p),
                SlotsBuffer::SizeOfChain(p->slots_buffer()));
       }
     } else {
-      UpdateSlotsOnPage(p, &updating_visitor);
+      PagedSpace* space = static_cast<PagedSpace*>(p->owner());
+      p->ClearFlag(MemoryChunk::RESCAN_ON_EVACUATION);
+      SweepPrecisely(space, p, true);
     }
   }
 
   // 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 445 matching lines @@
   if (block_address - free_start > 32 * kPointerSize) {
     free_start = DigestFreeStart(free_start, free_start_cell);
     freed_bytes += space->Free(free_start,
                                static_cast<int>(block_address - free_start));
   }
 
   return freed_bytes;
 }
 
 
-// Sweep a space precisely.  After this has been done the space can
-// be iterated precisely, hitting only the live objects.  Code space
-// is always swept precisely because we want to be able to iterate
-// over it.  Map space is swept precisely, because it is not compacted.
-static void SweepPrecisely(PagedSpace* space,
-                           Page* p) {
-  ASSERT(!p->IsEvacuationCandidate() && !p->WasSwept());
-  MarkBit::CellType* cells = p->markbits()->cells();
-
-  p->ClearFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
-
-  int last_cell_index =
-      Bitmap::IndexToCell(
-          Bitmap::CellAlignIndex(
-              p->AddressToMarkbitIndex(p->ObjectAreaEnd())));
-
-  int cell_index = Page::kFirstUsedCell;
-  Address free_start = p->ObjectAreaStart();
-  ASSERT(reinterpret_cast<intptr_t>(free_start) % (32 * kPointerSize) == 0);
-  Address object_address = p->ObjectAreaStart();
-  int offsets[16];
-
-  for (cell_index = Page::kFirstUsedCell;
-       cell_index < last_cell_index;
-       cell_index++, object_address += 32 * kPointerSize) {
-    ASSERT((unsigned)cell_index ==
-        Bitmap::IndexToCell(
-            Bitmap::CellAlignIndex(
-                p->AddressToMarkbitIndex(object_address))));
-    int live_objects = MarkWordToObjectStarts(cells[cell_index], offsets);
-    int live_index = 0;
-    for ( ; live_objects != 0; live_objects--) {
-      Address free_end = object_address + offsets[live_index++] * kPointerSize;
-      if (free_end != free_start) {
-        space->Free(free_start, static_cast<int>(free_end - free_start));
-      }
-      HeapObject* live_object = HeapObject::FromAddress(free_end);
-      ASSERT(Marking::IsBlack(Marking::MarkBitFrom(live_object)));
-      free_start = free_end + live_object->Size();
-    }
-  }
-  if (free_start != p->ObjectAreaEnd()) {
-    space->Free(free_start, static_cast<int>(p->ObjectAreaEnd() - free_start));
-  }
-}
-
-
 void MarkCompactCollector::SweepSpace(PagedSpace* space,
                                       SweeperType sweeper) {
   space->set_was_swept_conservatively(sweeper == CONSERVATIVE ||
                                       sweeper == LAZY_CONSERVATIVE);
 
   space->ClearStats();
 
   PageIterator it(space);
 
   intptr_t freed_bytes = 0;
@@ skipping 21 matching lines @@
         Page* next_page = p->next_page();
         freed_bytes += SweepConservatively(space, p);
         // TODO(gc): tweak the heuristic.
         if (freed_bytes >= newspace_size && p != space->LastPage()) {
           space->SetPagesToSweep(next_page, space->LastPage());
           return;
         }
         break;
       }
       case PRECISE: {
-        SweepPrecisely(space, p);
+        SweepPrecisely(space, p, false);
         break;
       }
       default: {
         UNREACHABLE();
       }
     }
   }
 
   // TODO(gc): set up allocation top and limit using the free list.
 }
@@ skipping 151 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal