Implemented lazy sweeping of new space.

src/store-buffer.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 25 matching lines @@
 
 namespace v8 {
 namespace internal {
 
 class Page;
 class PagedSpace;
 class StoreBuffer;
 
 typedef void (*ObjectSlotCallback)(HeapObject** from, HeapObject* to);
 
-typedef void (StoreBuffer::*RegionCallback)(
-    Address start, Address end, ObjectSlotCallback slot_callback);
+typedef void (StoreBuffer::*RegionCallback)(Address start,
+                                            Address end,
+                                            ObjectSlotCallback slot_callback,
+                                            bool clear_maps);
 
 // Used to implement the write barrier by collecting addresses of pointers
 // between spaces.
 class StoreBuffer {
  public:
   explicit StoreBuffer(Heap* heap);
 
   static void StoreBufferOverflow(Isolate* isolate);
 
   inline Address TopAddress();
@@ skipping 16 matching lines @@
   // buffer (some objects are promoted so pointers to them do not need to be in
   // the store buffer).  The later parts of the GC scan the pages that are
   // exempt from the store buffer and process the promotion queue.  These steps
   // can overflow this buffer.  We check for this and on overflow we call the
   // callback set up with the StoreBufferRebuildScope object.
   inline void EnterDirectlyIntoStoreBuffer(Address addr);
 
   // Iterates over all pointers that go from old space to new space.  It will
   // delete the store buffer as it starts so the callback should reenter
   // surviving old-to-new pointers into the store buffer to rebuild it.
-  void IteratePointersToNewSpace(ObjectSlotCallback callback);
+  void IteratePointersToNewSpace(ObjectSlotCallback callback, bool clear_maps);

[titzer, 2013/07/10 17:06:35]

Boolean flags of doom be gone! Recommend to have two separate methods, one which
clears and one which does not clear. The private implementation can use internal
booleans to avoid duplicating the guts, but the public interface should be more
well-defined.

Either that, or you could have the callback itself doing the clearing...

[Hannes Payer (out of office), 2013/07/11 07:30:40]

Done.

 
   static const int kStoreBufferOverflowBit = 1 << (14 + kPointerSizeLog2);
   static const int kStoreBufferSize = kStoreBufferOverflowBit;
   static const int kStoreBufferLength = kStoreBufferSize / sizeof(Address);
   static const int kOldStoreBufferLength = kStoreBufferLength * 16;
   static const int kHashSetLengthLog2 = 12;
   static const int kHashSetLength = 1 << kHashSetLengthLog2;
 
   void Compact();
 
@@ skipping 64 matching lines @@
   bool hash_sets_are_empty_;
 
   void ClearFilteringHashSets();
 
   bool SpaceAvailable(intptr_t space_needed);
   void Uniq();
   void ExemptPopularPages(int prime_sample_step, int threshold);
 
   void FindPointersToNewSpaceInRegion(Address start,
                                       Address end,
-                                      ObjectSlotCallback slot_callback);
+                                      ObjectSlotCallback slot_callback,
+                                      bool clear_maps);
 
   // For each region of pointers on a page in use from an old space call
   // visit_pointer_region callback.
   // If either visit_pointer_region or callback can cause an allocation
   // in old space and changes in allocation watermark then
   // can_preallocate_during_iteration should be set to true.
   void IteratePointersOnPage(
       PagedSpace* space,
       Page* page,
       RegionCallback region_callback,
       ObjectSlotCallback slot_callback);
 
   void FindPointersToNewSpaceInMaps(
     Address start,
     Address end,
-    ObjectSlotCallback slot_callback);
+    ObjectSlotCallback slot_callback,
+    bool clear_maps);
 
   void FindPointersToNewSpaceInMapsRegion(
     Address start,
     Address end,
-    ObjectSlotCallback slot_callback);
+    ObjectSlotCallback slot_callback,
+    bool clear_maps);
 
   void FindPointersToNewSpaceOnPage(
     PagedSpace* space,
     Page* page,
     RegionCallback region_callback,
-    ObjectSlotCallback slot_callback);
+    ObjectSlotCallback slot_callback,
+    bool clear_maps);
 
-  void IteratePointersInStoreBuffer(ObjectSlotCallback slot_callback);
+  void IteratePointersInStoreBuffer(ObjectSlotCallback slot_callback,
+                                    bool clear_maps);
 
 #ifdef VERIFY_HEAP
   void VerifyPointers(PagedSpace* space, RegionCallback region_callback);
   void VerifyPointers(LargeObjectSpace* space);
 #endif
 
   friend class StoreBufferRebuildScope;
   friend class DontMoveStoreBufferEntriesScope;
 };
 
@@ skipping 36 matching lines @@
   }
 
  private:
   StoreBuffer* store_buffer_;
   bool stored_state_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_STORE_BUFFER_H_