- Remember the fact that an object has been added to the

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 103 matching lines @@
   intptr_t bytes_promoted() const { return bytes_promoted_; }
 
  private:
   void UpdateStoreBuffer(RawObject** p, RawObject* obj) {
     uword ptr = reinterpret_cast<uword>(p);
     ASSERT(obj->IsHeapObject());
     ASSERT(!scavenger_->Contains(ptr));
     ASSERT(!heap_->CodeContains(ptr));
     ASSERT(heap_->Contains(ptr));
     // If the newly written object is not a new object, drop it immediately.
-    if (!obj->IsNewObject()) return;
-    isolate()->store_buffer()->AddPointer(
-        reinterpret_cast<uword>(visiting_old_object_));
+    if (!obj->IsNewObject() || visiting_old_object_->IsRemembered()) {
+      return;
+    }
+    visiting_old_object_->SetRememberedBit();
+    isolate()->store_buffer()->AddObjectGC(visiting_old_object_);
   }
 
   void ScavengePointer(RawObject** p) {
     // ScavengePointer cannot be called recursively.
 #ifdef DEBUG
     ASSERT(!in_scavenge_pointer_);
     BoolScope bs(&in_scavenge_pointer_, true);
 #endif
 
     RawObject* raw_obj = *p;
@@ skipping 230 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.
-  // Use DrainBlock directly instead of ProcessBlock because we are in the
-  // middle of a scavenge cycle and thus do not care if we are temporary
-  // running over the max number of deduplication sets.
-  StoreBufferBlock* block = isolate->store_buffer_block();
-  heap_->RecordData(kStoreBufferBlockEntries, block->Count());
-  isolate->store_buffer()->DrainBlock(block);
+  StoreBuffer* buffer = isolate->store_buffer();
+  heap_->RecordData(kStoreBufferBlockEntries, buffer->Count());
 
   // Iterating through the store buffers.
   // Grab the deduplication sets out of the store buffer.
-  StoreBuffer::DedupSet* pending = isolate->store_buffer()->DedupSets();
+  StoreBufferBlock* pending = isolate->store_buffer()->Blocks();
   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;
+    StoreBufferBlock* next = pending->next();
+    intptr_t count = pending->Count();
     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;
-        }
-      }
+    for (intptr_t i = 0; i < count; i++) {
+      RawObject* raw_object = pending->At(i);
+      ASSERT(raw_object->IsRemembered());
+      raw_object->ClearRememberedBit();
+      visitor->VisitingOldObject(raw_object);
+      raw_object->VisitPointers(visitor);
     }
     delete pending;
     pending = next;
   }
   heap_->RecordData(kStoreBufferEntries, entries);
   // Done iterating through old objects remembered in the store buffers.
   visitor->VisitingOldObject(NULL);
 }
 
 
@@ skipping 110 matching lines @@
         RawWeakProperty* raw_weak = reinterpret_cast<RawWeakProperty*>(raw_obj);
         resolved_top_ += ProcessWeakProperty(raw_weak, visitor);
       }
     }
     {
       while (PromotedStackHasMore()) {
         RawObject* raw_object = RawObject::FromAddr(PopFromPromotedStack());
         // Resolve or copy all objects referred to by the current object. This
         // can potentially push more objects on this stack as well as add more
         // objects to be resolved in the to space.
+        ASSERT(!raw_object->IsRemembered());
         visitor->VisitingOldObject(raw_object);
         raw_object->VisitPointers(visitor);
       }
       visitor->VisitingOldObject(NULL);
     }
     while (!delayed_weak_stack->is_empty()) {
       // Pop the delayed weak object from the stack and visit its pointers.
       RawObject* weak_property = delayed_weak_stack->RemoveLast();
       weak_property->VisitPointers(visitor);
     }
@@ skipping 125 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