Do not SortUniq store buffer before a regular iteration.

src/store-buffer.cc

 // Copyright 2010 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 78 matching lines @@
   delete virtual_memory_;
   delete[] hash_map_1_;
   delete[] hash_map_2_;
   delete[] old_start_;
   old_start_ = old_top_ = old_limit_ = NULL;
   start_ = limit_ = NULL;
   Heap::public_set_store_buffer_top(start_);
 }
 
 
-
 #if V8_TARGET_ARCH_X64
 static int CompareAddresses(const void* void_a, const void* void_b) {
   intptr_t a =
       reinterpret_cast<intptr_t>(*reinterpret_cast<const Address*>(void_a));
   intptr_t b =
       reinterpret_cast<intptr_t>(*reinterpret_cast<const Address*>(void_b));
   // Unfortunately if int is smaller than intptr_t there is no branch-free
   // way to return a number with the same sign as the difference between the
   // pointers.
   if (a == b) return 0;
@@ skipping 44 matching lines @@
   qsort(reinterpret_cast<void*>(old_start_),
         old_top_ - old_start_,
         sizeof(*old_top_),
         &CompareAddresses);
   Uniq();
 
   old_buffer_is_sorted_ = true;
 }
 
 
+void StoreBuffer::PrepareForIteration() {
+  Compact();
+  if (store_buffer_mode() == kStoreBufferDisabled) {
+    old_top_ = old_start_;
+    return;
+  }
+  ZapHashTables();
+}
+
+
 #ifdef DEBUG
 void StoreBuffer::Clean() {
   if (store_buffer_mode() == kStoreBufferDisabled) {
     old_top_ = old_start_;  // Just clear the cache.
     return;
   }
   ZapHashTables();
   Uniq();  // Also removes things that no longer point to new space.
   CheckForFullBuffer();
 }
@@ skipping 75 matching lines @@
   during_gc_ = false;
   if (store_buffer_mode() == kStoreBufferBeingRebuilt) {
     set_store_buffer_mode(kStoreBufferFunctional);
   }
   Verify();
 }
 
 
 void StoreBuffer::IteratePointersToNewSpace(ObjectSlotCallback callback) {
   if (store_buffer_mode() == kStoreBufferFunctional) {
-    SortUniq();
+    // We do not sort or remove duplicated entries from the store buffer because
+    // we expect that callback will rebuild the store buffer thus removing
+    // all duplicates and pointers to old space.
+    PrepareForIteration();
   }
   if (store_buffer_mode() != kStoreBufferFunctional) {
     old_top_ = old_start_;
     ZapHashTables();
     Heap::public_set_store_buffer_top(start_);
     set_store_buffer_mode(kStoreBufferBeingRebuilt);
     Heap::IteratePointers(Heap::old_pointer_space(),
                           &Heap::IteratePointersToNewSpace,
                           callback,
                           Heap::WATERMARK_SHOULD_BE_VALID);
@@ skipping 10 matching lines @@
     {
       DontMoveStoreBufferEntriesScope scope;
       for (Address* current = old_start_; current < limit; current++) {
 #ifdef DEBUG
         Address* saved_top = old_top_;
 #endif
         Object** cell = reinterpret_cast<Object**>(*current);
         Object* object = *cell;
         // May be invalid if object is not in new space.
         HeapObject* heap_object = reinterpret_cast<HeapObject*>(object);
-        if (Heap::InNewSpace(object)) {
+        if (Heap::InFromSpace(object)) {
           callback(reinterpret_cast<HeapObject**>(cell), heap_object);
         }
         ASSERT(old_top_ == saved_top + 1 || old_top_ == saved_top);
-        ASSERT((old_top_ == saved_top + 1) ==
-               (Heap::InNewSpace(*cell) &&
-                   !Heap::InNewSpace(reinterpret_cast<Address>(cell)) &&
-                   Memory::Address_at(heap_object->address()) != NULL));
       }
     }
   }
 }
 
 
 void StoreBuffer::Compact() {
   Address* top = reinterpret_cast<Address*>(Heap::store_buffer_top());
 
   if (top == start_) return;
@@ skipping 59 matching lines @@
     // TODO(gc): Make the disabling of the store buffer dependendent on
     // those two measures failing:
     // After compression not enough space was freed up in the store buffer.  We
     // might as well stop sorting and trying to eliminate duplicates.
     Counters::store_buffer_overflows.Increment();
     set_store_buffer_mode(kStoreBufferDisabled);
   }
 }
 
 } }  // namespace v8::internal