Introduce lazy sweeping.

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 610 matching lines @@
 
 // -----------------------------------------------------------------------------
 // PagedSpace implementation
 
 PagedSpace::PagedSpace(Heap* heap,
                        intptr_t max_capacity,
                        AllocationSpace id,
                        Executability executable)
     : Space(heap, id, executable),
       free_list_(this),
-      was_swept_conservatively_(false) {
+      was_swept_conservatively_(false),
+      first_unswept_page_(Page::FromAddress(NULL)),
+      last_unswept_page_(Page::FromAddress(NULL)) {
   max_capacity_ = (RoundDown(max_capacity, Page::kPageSize) / Page::kPageSize)
                   * Page::kObjectAreaSize;
   accounting_stats_.Clear();
 
   allocation_info_.top = NULL;
   allocation_info_.limit = NULL;
 
   anchor_.InitializeAsAnchor(this);
 }
 
@@ skipping 915 matching lines @@
 
   ASSERT(new_node_size - size_in_bytes >= 0);  // New linear size.
 
   const int kThreshold = IncrementalMarking::kAllocatedThreshold;
 
   // Memory in the linear allocation area is counted as allocated.  We may free
   // a little of this again immediately - see below.
   owner_->Allocate(new_node_size);
 
   if (new_node_size - size_in_bytes > kThreshold &&
-      HEAP->incremental_marking()->IsMarking() &&
+      HEAP->incremental_marking()->IsMarkingIncomplete() &&
       FLAG_incremental_marking_steps) {
     // We don't want to give too large linear areas to the allocator while
     // incremental marking is going on, because we won't check again whether
     // we want to do another increment until the linear area is used up.
     owner_->Free(new_node->address() + size_in_bytes + kThreshold,
                  new_node_size - size_in_bytes - kThreshold);
     owner_->SetTop(new_node->address() + size_in_bytes,
                    new_node->address() + size_in_bytes + kThreshold);
   } else {
     // Normally we give the rest of the node to the allocator as its new
@@ skipping 56 matching lines @@
 
 
 // -----------------------------------------------------------------------------
 // OldSpace implementation
 
 void OldSpace::PrepareForMarkCompact(bool will_compact) {
   ASSERT(!will_compact);
   // Call prepare of the super class.
   PagedSpace::PrepareForMarkCompact(will_compact);
 
+  first_unswept_page_ = last_unswept_page_ = Page::FromAddress(NULL);
+
   // Clear the free list before a full GC---it will be rebuilt afterward.
+  // TODO(gc): can we avoid resetting free list?
   free_list_.Reset();
 }
 
 
 bool NewSpace::ReserveSpace(int bytes) {
   // We can't reliably unpack a partial snapshot that needs more new space
   // space than the minimum NewSpace size.
   ASSERT(bytes <= InitialCapacity());
   Address limit = allocation_info_.limit;
   Address top = allocation_info_.top;
@@ skipping 36 matching lines @@
 }
 
 
 // You have to call this last, since the implementation from PagedSpace
 // doesn't know that memory was 'promised' to large object space.
 bool LargeObjectSpace::ReserveSpace(int bytes) {
   return heap()->OldGenerationSpaceAvailable() >= bytes;
 }
 
 
+bool PagedSpace::AdvanceSweeper(intptr_t bytes_to_sweep) {
+  if (IsSweepingComplete()) return true;
+
+  int freed_bytes = 0;
+  Page* last = last_unswept_page_->next_page();
+  Page* p = first_unswept_page_;
+  do {
+    freed_bytes += MarkCompactCollector::SweepConservatively(this, p);
+    p = p->next_page();
+  } while (p != last && freed_bytes < bytes_to_sweep);
+
+  if (p == last) {
+    last_unswept_page_ = first_unswept_page_ = Page::FromAddress(NULL);
+  } else {
+    first_unswept_page_ = p;
+  }
+
+  heap()->LowerOldGenLimits(freed_bytes);
+
+  return IsSweepingComplete();
+}
+
+
 HeapObject* PagedSpace::SlowAllocateRaw(int size_in_bytes) {
   // Allocation in this space has failed.
 
   // Free list allocation failed and there is no next page.  Fail if we have
   // hit the old generation size limit that should cause a garbage
   // collection.
   if (!heap()->always_allocate() &&
       heap()->OldGenerationAllocationLimitReached()) {
     return NULL;
   }
 
+  // If there are unswept pages advance lazy sweeper.
+  if (first_unswept_page_->is_valid()) {
+    AdvanceSweeper(size_in_bytes);
+
+    // Retry the free list allocation.
+    HeapObject* object = free_list_.Allocate(size_in_bytes);
+    if (object != NULL) return object;
+
+    if (!IsSweepingComplete()) {
+      AdvanceSweeper(kMaxInt);
+
+      // Retry the free list allocation.
+      object = free_list_.Allocate(size_in_bytes);
+      if (object != NULL) return object;
+    }
+  }
+
   // Try to expand the space and allocate in the new next page.
   if (Expand()) {
     return free_list_.Allocate(size_in_bytes);
   }
 
   // Finally, fail.
   return NULL;
 }
 
 
@@ skipping 494 matching lines @@
   for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       isolate->code_kind_statistics()[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal