Avoid scan-on-scavenge pages during full collection.

src/store-buffer.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_STORE_BUFFER_H_
 #define V8_STORE_BUFFER_H_
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/base/platform/platform.h"
 #include "src/globals.h"
 
 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,
-                                            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 24 matching lines @@
   // surviving old-to-new pointers into the store buffer to rebuild it.
   void IteratePointersToNewSpace(ObjectSlotCallback callback);
 
   // Same as IteratePointersToNewSpace but additonally clears maps in objects
   // referenced from the store buffer that do not contain a forwarding pointer.
   void IteratePointersToNewSpaceAndClearMaps(ObjectSlotCallback callback);
 
   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 kOldRegularStoreBufferLength = kStoreBufferLength * 16;
   static const int kHashSetLengthLog2 = 12;
   static const int kHashSetLength = 1 << kHashSetLengthLog2;
 
   void Compact();
 
-  void GCPrologue();
+  void GCPrologue(bool allow_overflow);
   void GCEpilogue();
 
   Object*** Limit() { return reinterpret_cast<Object***>(old_limit_); }
   Object*** Start() { return reinterpret_cast<Object***>(old_start_); }
   Object*** Top() { return reinterpret_cast<Object***>(old_top_); }
   void SetTop(Object*** top) {
     ASSERT(top >= Start());
     ASSERT(top <= Limit());
     old_top_ = reinterpret_cast<Address*>(top);
   }
@@ skipping 23 matching lines @@
 
   // The store buffer is divided up into a new buffer that is constantly being
   // filled by mutator activity and an old buffer that is filled with the data
   // from the new buffer after compression.
   Address* start_;
   Address* limit_;
 
   Address* old_start_;
   Address* old_limit_;
   Address* old_top_;
+
+  // The regular limit specifies how big the store buffer may become during
+  // mutator execution or while scavenging.
+  Address* old_regular_limit_;
+
+  // The reserved limit is bigger then the regular limit. It should be the size
+  // of a semi-space to avoid new scan-on-scavenge during new space evacuation
+  // after sweeping in a full garbage collection.
   Address* old_reserved_limit_;
+
   base::VirtualMemory* old_virtual_memory_;
+  int old_store_buffer_length_;
 
   bool old_buffer_is_sorted_;
   bool old_buffer_is_filtered_;
-  bool during_gc_;
+
+  // If allow_overflow_ is set, we allow the store buffer to grow until
+  // old_reserved_limit_. But we will shrink the store buffer in the epilogue to
+  // stay within the old_regular_limit_.
+  bool allow_overflow_;
+
   // The garbage collector iterates over many pointers to new space that are not
   // handled by the store buffer.  This flag indicates whether the pointers
   // found by the callbacks should be added to the store buffer or not.
   bool store_buffer_rebuilding_enabled_;
   StoreBufferCallback callback_;
   bool may_move_store_buffer_entries_;
 
   base::VirtualMemory* virtual_memory_;
 
   // Two hash sets used for filtering.
   // If address is in the hash set then it is guaranteed to be in the
   // old part of the store buffer.
   uintptr_t* hash_set_1_;
   uintptr_t* hash_set_2_;
   bool hash_sets_are_empty_;
 
   void ClearFilteringHashSets();
 
   bool SpaceAvailable(intptr_t space_needed);
   void Uniq();
   void ExemptPopularPages(int prime_sample_step, int threshold);
 
+  enum ExemptPopularPagesMode {
+    ENSURE_SPACE,
+    SHRINK_TO_REGULAR_SIZE
+  };
+
+  template <ExemptPopularPagesMode mode>
+  void IterativelyExemptPopularPages(intptr_t space_needed);
+
   // Set the map field of the object to NULL if contains a map.
   inline void ClearDeadObject(HeapObject *object);
 
   void IteratePointersToNewSpace(ObjectSlotCallback callback, bool clear_maps);
 
   void FindPointersToNewSpaceInRegion(Address start,
                                       Address end,
                                       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 IteratePointersInStoreBuffer(ObjectSlotCallback slot_callback,
                                     bool clear_maps);
 
 #ifdef VERIFY_HEAP
   void VerifyPointers(LargeObjectSpace* space);
 #endif
 
   friend class StoreBufferRebuildScope;
   friend class DontMoveStoreBufferEntriesScope;
 };
@@ skipping 37 matching lines @@
   }
 
  private:
   StoreBuffer* store_buffer_;
   bool stored_state_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_STORE_BUFFER_H_