Add specialized sweeper for cell and map space.

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 2643 matching lines @@
     }
     // Clear marking bits for current cell.
     cells[cell_index] = 0;
   }
   if (free_start != p->ObjectAreaEnd()) {
     space->Free(free_start, static_cast<int>(p->ObjectAreaEnd() - free_start));
   }
 }
 
 
+// Sweep a page of a space which contains objects of fixed size.  This is used
+// for map space and cell space, it always sweeps those spaces precisely.
+template<int size>
+static void SweepSpecialized(PagedSpace* space, Page* p) {
+  ASSERT(!p->IsEvacuationCandidate() && !p->WasSwept());
+  MarkBit::CellType* cells = p->markbits()->cells();
+  p->MarkSweptPrecisely();
+
+  int last_cell_index =
+      Bitmap::IndexToCell(
+          Bitmap::CellAlignIndex(
+              p->AddressToMarkbitIndex(p->ObjectAreaEnd())));
+
+  int cell_index = Page::kFirstUsedCell;
+  Address free_start = p->ObjectAreaStart();
+  Address free_end = p->ObjectAreaStart();
+  uint32_t mark_mask = 0;
+  uint32_t mark_bits;
+
+  ASSERT(size % kPointerSize == 0);
+  int bits_per_object = size / kPointerSize;
+
+  for (cell_index = Page::kFirstUsedCell;
+       cell_index < last_cell_index || mark_mask != 0;
+       free_end += size, mark_mask <<= bits_per_object) {
+    if (mark_mask == 0) {
+      mark_mask = 1 << (p->AddressToMarkbitIndex(free_end) % 32);
+      mark_bits = cells[cell_index];
+      cells[cell_index] = 0;
+      cell_index++;
+    }
+    if ((mark_bits & mark_mask) != 0) {
+      if (free_end != free_start) {
+        space->Free(free_start, static_cast<int>(free_end - free_start));
+      }
+      free_start = free_end + size;
+    }
+  }
+  if (free_start != p->ObjectAreaEnd()) {
+    space->Free(free_start, static_cast<int>(p->ObjectAreaEnd() - free_start));
+  }
+}
+
+
 void MarkCompactCollector::EvacuateNewSpaceAndCandidates() {
   EvacuateNewSpace();
   EvacuatePages();
 
   // Second pass: find pointers to new space and update them.
   PointersUpdatingVisitor updating_visitor(heap());
 
   // Update pointers in to space.
   SemiSpaceIterator to_it(heap()->new_space()->bottom(),
                           heap()->new_space()->top());
@@ skipping 560 matching lines @@
         if (freed_bytes >= newspace_size && p != space->LastPage()) {
           space->SetPagesToSweep(p->next_page(), space->LastPage());
           lazy_sweeping_active = true;
         }
         break;
       }
       case PRECISE: {
         SweepPrecisely(space, p, SWEEP_ONLY);
         break;
       }
+      case PRECISE_CELLS: {
+        SweepSpecialized<JSGlobalPropertyCell::kSize>(space, p);
+        break;
+      }
+      case PRECISE_MAPS: {
+        SweepSpecialized<Map::kSize>(space, p);
+        break;
+      }
       default: {
         UNREACHABLE();
       }
     }
   }
 }
 
 
 void MarkCompactCollector::SweepSpaces() {
   GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_SWEEP);
 #ifdef DEBUG
   state_ = SWEEP_SPACES;
 #endif
   SweeperType how_to_sweep =
       FLAG_lazy_sweeping ? LAZY_CONSERVATIVE : CONSERVATIVE;
   if (sweep_precisely_) how_to_sweep = PRECISE;
   // 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(), how_to_sweep);
   SweepSpace(heap()->old_data_space(), how_to_sweep);
   SweepSpace(heap()->code_space(), PRECISE);
-  SweepSpace(heap()->cell_space(), PRECISE);
+  SweepSpace(heap()->cell_space(), PRECISE_CELLS);
   { GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_SWEEP_NEWSPACE);
     EvacuateNewSpaceAndCandidates();
   }
   // 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.
-  SweepSpace(heap()->map_space(), PRECISE);
+  SweepSpace(heap()->map_space(), PRECISE_MAPS);
 
   ASSERT(live_map_objects_size_ <= heap()->map_space()->Size());
 
   // Deallocate unmarked objects and clear marked bits for marked objects.
   heap_->lo_space()->FreeUnmarkedObjects();
 }
 
 
 // TODO(1466) ReportDeleteIfNeeded is not called currently.
 // Our profiling tools do not expect intersections between
@@ skipping 50 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal