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

src/spaces.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 56 matching lines @@
   Initialize(space,
              NULL,
              NULL,
              kAllPagesInSpace,
              size_func);
 }
 
 
 HeapObjectIterator::HeapObjectIterator(Page* page,
                                        HeapObjectCallback size_func) {
-  Initialize(page->owner(),
+  Space* owner = page->owner();
+  ASSERT(owner == Heap::old_pointer_space() ||
+         owner == Heap::old_data_space() ||
+         owner == Heap::map_space() ||
+         owner == Heap::cell_space() ||
+         owner == Heap::code_space());
+  Initialize(reinterpret_cast<PagedSpace*>(owner),
              page->ObjectAreaStart(),
              page->ObjectAreaEnd(),
              kOnePageOnly,
              size_func);
   ASSERT(!page->IsFlagSet(Page::WAS_SWEPT_CONSERVATIVELY));
 }
 
 
 void HeapObjectIterator::Initialize(PagedSpace* space,
                                     Address cur, Address end,
@@ skipping 293 matching lines @@
     VirtualMemory::ReleaseRegion(base, *allocated_size);
     size_ -= *allocated_size;
     return NULL;
   }
 
   return base;
 }
 
 
 void Page::InitializeAsAnchor(PagedSpace* owner) {
-  owner_ = owner;
+  set_owner(owner);
   set_prev_page(this);
   set_next_page(this);
 }
 
 
 MemoryChunk* MemoryChunk::Initialize(Address base,
                                      size_t size,
                                      Executability executable,
                                      Space* owner) {
   MemoryChunk* chunk = FromAddress(base);
 
   ASSERT(base == chunk->address());
 
   chunk->size_ = size;
   chunk->flags_ = 0;
-  chunk->owner_ = owner;
+  chunk->set_owner(owner);
   chunk->markbits()->Clear();
+  chunk->set_scan_on_scavenge(false);
 
   if (executable == EXECUTABLE) chunk->SetFlag(IS_EXECUTABLE);
 
   if (owner == Heap::old_data_space()) chunk->SetFlag(CONTAINS_ONLY_DATA);
 
   return chunk;
 }
 
 
 void MemoryChunk::InsertAfter(MemoryChunk* other) {
@@ skipping 999 matching lines @@
 void OldSpaceFreeList::Reset() {
   available_ = 0;
   small_list_ = NULL;
   medium_list_ = NULL;
   large_list_ = NULL;
   huge_list_ = NULL;
 }
 
 
 int OldSpaceFreeList::Free(Address start, int size_in_bytes) {
-#ifdef DEBUG
-  MemoryAllocator::ZapBlock(start, size_in_bytes);
-#endif
   if (size_in_bytes == 0) return 0;
   FreeListNode* node = FreeListNode::FromAddress(start);
   node->set_size(size_in_bytes);
 
   // Early return to drop too-small blocks on the floor.
   if (size_in_bytes < kSmallListMin) return size_in_bytes;
 
   // Insert other blocks at the head of a free list of the appropriate
   // magnitude.
   if (size_in_bytes <= kSmallListMax) {
@@ skipping 139 matching lines @@
   // space than the minimum NewSpace size.
   ASSERT(bytes <= InitialCapacity());
   Address limit = allocation_info_.limit;
   Address top = allocation_info_.top;
   return limit - top >= bytes;
 }
 
 
 void PagedSpace::PrepareForMarkCompact(bool will_compact) {
   ASSERT(!will_compact);
+  // We don't have a linear allocation area while sweeping.  It will be restored
+  // on the first allocation after the sweep.
+  // Mark the old linear allocation area with a free space map so it can be
+  // skipped when scanning the heap.
+  int old_linear_size = limit() - top();
+  Free(top(), old_linear_size);
+  SetTop(NULL, NULL);
 }
 
 
 bool PagedSpace::ReserveSpace(int size_in_bytes) {
   ASSERT(size_in_bytes <= Page::kMaxHeapObjectSize);
   ASSERT(size_in_bytes == RoundUp(size_in_bytes, kPointerSize));
   Address current_top = allocation_info_.top;
   Address new_top = current_top + size_in_bytes;
   if (new_top <= allocation_info_.limit) return true;
 
@@ skipping 173 matching lines @@
 }
 
 
 void PagedSpace::ReportStatistics() {
   int pct = static_cast<int>(Available() * 100 / Capacity());
   PrintF("  capacity: %" V8_PTR_PREFIX "d"
              ", waste: %" V8_PTR_PREFIX "d"
              ", available: %" V8_PTR_PREFIX "d, %%%d\n",
          Capacity(), Waste(), Available(), pct);
 
+  if (was_swept_conservatively_) return;
   ClearHistograms();
   HeapObjectIterator obj_it(this);
   for (HeapObject* obj = obj_it.Next(); obj != NULL; obj = obj_it.Next())
     CollectHistogramInfo(obj);
   ReportHistogram(true);
 }
 #endif
 
 // -----------------------------------------------------------------------------
 // FixedSpace implementation
@@ skipping 346 matching lines @@
   for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       code_kind_statistics[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal