Introduce lazy sweeping.

src/spaces.h

 // 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 996 matching lines @@
  public:
   AllocationStats() { Clear(); }
 
   // Zero out all the allocation statistics (ie, no capacity).
   void Clear() {
     capacity_ = 0;
     size_ = 0;
     waste_ = 0;
   }
 
+  void ClearSizeWaste() {
+    size_ = capacity_;
+    waste_ = 0;
+  }
+

[Erik Corry, 2011/05/09 21:20:11]

Extra blank line here.

+
   // Reset the allocation statistics (ie, available = capacity with no
   // wasted or allocated bytes).
   void Reset() {
     size_ = 0;
     waste_ = 0;
   }
 
   // Accessors for the allocation statistics.
   intptr_t Capacity() { return capacity_; }
   intptr_t Size() { return size_; }
@@ skipping 197 matching lines @@
 
   // Total amount of memory committed for this space.  For paged
   // spaces this equals the capacity.
   intptr_t CommittedMemory() { return Capacity(); }
 
   // Sets the capacity, the available space and the wasted space to zero.
   // The stats are rebuilt during sweeping by adding each page to the
   // capacity and the size when it is encountered.  As free spaces are
   // discovered during the sweeping they are subtracted from the size and added
   // to the available and wasted totals.
-  void ClearStats() { accounting_stats_.Clear(); }
+  void ClearStats() {
+    accounting_stats_.ClearSizeWaste();
+  }
 
   // Available bytes without growing.  These are the bytes on the free list.
   // The bytes in the linear allocation area are not included in this total
   // because updating the stats would slow down allocation.  New pages are
   // immediately added to the free list so they show up here.
   intptr_t Available() { return free_list_.available(); }
 
   // Allocated bytes in this space.  Garbage bytes that were not found due to
   // lazy sweeping are counted as being allocated!  The bytes in the current
   // linear allocation area (between top and limit) are also counted here.
@@ skipping 15 matching lines @@
   // Allocate the requested number of bytes in the space if possible, return a
   // failure object if not.
   MUST_USE_RESULT inline MaybeObject* AllocateRaw(int size_in_bytes);
 
   virtual bool ReserveSpace(int bytes);
 
   // Give a block of memory to the space's free list.  It might be added to
   // the free list or accounted as waste.
   // If add_to_freelist is false then just accounting stats are updated and
   // no attempt to add area to free list is made.
-  void Free(Address start, int size_in_bytes) {
+  int Free(Address start, int size_in_bytes) {
     int wasted = free_list_.Free(start, size_in_bytes);
     accounting_stats_.DeallocateBytes(size_in_bytes - wasted);
+    return size_in_bytes - wasted;
   }
 
   // Set space allocation info.
   void SetTop(Address top, Address limit) {
     ASSERT(top == limit ||
            Page::FromAddress(top) == Page::FromAddress(limit - 1));
     allocation_info_.top = top;
     allocation_info_.limit = limit;
   }
 
@@ skipping 36 matching lines @@
 
   // Report code object related statistics
   void CollectCodeStatistics();
   static void ReportCodeStatistics();
   static void ResetCodeStatistics();
 #endif
 
   bool was_swept_conservatively() { return was_swept_conservatively_; }
   void set_was_swept_conservatively(bool b) { was_swept_conservatively_ = b; }
 
+  void SetPagesToSweep(Page* first, Page* last) {
+    first_unswept_page_ = first;
+    last_unswept_page_ = last;
+
+    Page* p = first;
+    do {
+      p->SetFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
+      p = p->next_page();
+    } while (p != last);
+  }
+
+  bool AdvanceSweeper(intptr_t bytes_to_sweep);
+
+  bool IsSweepingComplete() {
+    return !first_unswept_page_->is_valid();
+  }
+
+  Page* FirstPage() { return anchor_.next_page(); }
+  Page* LastPage() { return anchor_.prev_page(); }
+
  protected:
   // Maximum capacity of this space.
   intptr_t max_capacity_;
 
   // Accounting information for this space.
   AllocationStats accounting_stats_;
 
   // The dummy page that anchors the double linked list of pages.
   Page anchor_;
 
   // The space's free list.
   OldSpaceFreeList free_list_;
 
   // Normal allocation information.
   AllocationInfo allocation_info_;
 
   // Bytes of each page that cannot be allocated.  Possibly non-zero
   // for pages in spaces with only fixed-size objects.  Always zero
   // for pages in spaces with variable sized objects (those pages are
   // padded with free-list nodes).
   int page_extra_;
 
   bool was_swept_conservatively_;
 
+  Page* first_unswept_page_;
+  Page* last_unswept_page_;
+
   // Sets allocation pointer.  If the allocation pointer already pointed to a
   // non-zero-length area then that area may be returned to the free list.
   void SetAllocationInfo(Address start, Address end);
 
   // Expands the space by allocating a fixed number of pages. Returns false if
   // it cannot allocate requested number of pages from OS.
   bool Expand();
 
   // Generic fast case allocation function that tries linear allocation at the
   // address denoted by top in allocation_info_.
@@ skipping 854 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_