Drain StoreBufferBlock into store buffer instead of iterating over it directly.

runtime/vm/scavenger.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/scavenger.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 
@@ skipping 373 matching lines @@
   memset(from_->pointer(), 0xf3, from_->size());
 #endif  // defined(DEBUG)
   if (invoke_api_callbacks) {
     isolate->gc_epilogue_callbacks().Invoke();
   }
 }
 
 
 void Scavenger::IterateStoreBuffers(Isolate* isolate,
                                     ScavengerVisitor* visitor) {
+  // Drain store buffer block into store buffer to deduplicate it. It might be
+  // full of large objects repeated multiple times.
+  StoreBufferBlock* block = isolate->store_buffer_block();
+  isolate->store_buffer()->ProcessBlock(block);

[siva, 2013/04/19 18:27:41]

Why is it not ok to just call
block->ProcessBuffer(isolate);
here.

[Vyacheslav Egorov (Google), 2013/04/19 19:40:20]

ProcessBuffer would use normal AddPointer and thus it might schedule an
interrupt if we have too many deduplication sets. But we do not actually need
this interrupt --- we are in the middle of scavenge already.

If I would use ProcessBuffer here I might get some redundant scavenges due to
this interrupt.

On 2013/04/19 18:27:41, siva wrote:

+  heap_->RecordData(kStoreBufferBlockEntries, block->Count());
+  block->Reset();

[siva, 2013/04/19 18:27:41]

This reset would not be needed if you did a
block->ProcessBuffer(isolate);

[Vyacheslav Egorov (Google), 2013/04/19 19:40:20]

Done.

+
   // Iterating through the store buffers.
   // Grab the deduplication sets out of the store buffer.
   StoreBuffer::DedupSet* pending = isolate->store_buffer()->DedupSets();
   intptr_t entries = 0;
   while (pending != NULL) {
     StoreBuffer::DedupSet* next = pending->next();
     HashSet* set = pending->set();
     intptr_t count = set->Count();
     intptr_t size = set->Size();
     intptr_t handled = 0;
     entries += count;
     for (intptr_t i = 0; i < size; i++) {
       RawObject* raw_object = reinterpret_cast<RawObject*>(set->At(i));
       if (raw_object != NULL) {
         visitor->VisitingOldObject(raw_object);
         raw_object->VisitPointers(visitor);
         handled++;
         if (handled == count) {
           break;
         }
       }
     }
     delete pending;
     pending = next;
   }
   heap_->RecordData(kStoreBufferEntries, entries);
-  StoreBufferBlock* block = isolate->store_buffer_block();
-  entries = block->Count();
-  for (intptr_t i = 0; i < entries; i++) {
-    RawObject* raw_object = reinterpret_cast<RawObject*>(block->At(i));
-    ASSERT(raw_object->IsHeapObject());
-    visitor->VisitingOldObject(raw_object);
-    raw_object->VisitPointers(visitor);
-  }
-  block->Reset();
-  heap_->RecordData(kStoreBufferBlockEntries, entries);
   // Done iterating through old objects remembered in the store buffers.
   visitor->VisitingOldObject(NULL);
 }
 
 
 void Scavenger::IterateRoots(Isolate* isolate,
                              ScavengerVisitor* visitor,
                              bool visit_prologue_weak_persistent_handles) {
   int64_t start = OS::GetCurrentTimeMicros();
   isolate->VisitObjectPointers(visitor,
@@ skipping 257 matching lines @@
   PeerTable::iterator it = peer_table_.find(raw_obj);
   return (it == peer_table_.end()) ? NULL : it->second;
 }
 
 
 int64_t Scavenger::PeerCount() const {
   return static_cast<int64_t>(peer_table_.size());
 }
 
 }  // namespace dart