- Remember objects (not addresses) in the old generation containing new pointers.

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 57 matching lines @@
 class ScavengerVisitor : public ObjectPointerVisitor {
  public:
   explicit ScavengerVisitor(Isolate* isolate, Scavenger* scavenger)
       : ObjectPointerVisitor(isolate),
         scavenger_(scavenger),
         heap_(scavenger->heap_),
         vm_heap_(Dart::vm_isolate()->heap()),
         delayed_weak_stack_(),
         growth_policy_(PageSpace::kControlGrowth),
         bytes_promoted_(0),
-#ifdef DEBUG
-        in_scavenge_pointer_(false),
-#endif
-        visiting_old_pointers_(false) { }
+        visiting_old_object_(NULL),
+        in_scavenge_pointer_(false) { }
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       ScavengePointer(current);
     }
   }
 
   GrowableArray<RawObject*>* DelayedWeakStack() {
     return &delayed_weak_stack_;
   }
 
-  bool* VisitingOldPointersAddr() { return &visiting_old_pointers_; }
+  void VisitingOldObject(RawObject* obj) {
+    ASSERT((obj == NULL) || obj->IsOldObject());
+    visiting_old_object_ = obj;
+  }
 
   void DelayWeakProperty(RawWeakProperty* raw_weak) {
     RawObject* raw_key = raw_weak->ptr()->key_;
     DelaySet::iterator it = delay_set_.find(raw_key);
     if (it != delay_set_.end()) {
       ASSERT(raw_key->IsWatched());
     } else {
       ASSERT(!raw_key->IsWatched());
       raw_key->SetWatchedBit();
     }
@@ skipping 11 matching lines @@
 
  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(ptr);
+    isolate()->store_buffer()->AddPointer(
+        reinterpret_cast<uword>(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 96 matching lines @@
       memmove(reinterpret_cast<void*>(new_addr),
               reinterpret_cast<void*>(raw_addr),
               size);
       // Remember forwarding address.
       ForwardTo(raw_addr, new_addr);
     }
     // Update the reference.
     RawObject* new_obj = RawObject::FromAddr(new_addr);
     *p = new_obj;
     // Update the store buffer as needed.
-    if (visiting_old_pointers_) {
+    if (visiting_old_object_ != NULL) {
       UpdateStoreBuffer(p, new_obj);
     }
   }
 
   Scavenger* scavenger_;
   Heap* heap_;
   Heap* vm_heap_;
   typedef std::multimap<RawObject*, RawWeakProperty*> DelaySet;
   DelaySet delay_set_;
   GrowableArray<RawObject*> delayed_weak_stack_;
   PageSpace::GrowthPolicy growth_policy_;
   // TODO(cshapiro): use this value to compute survival statistics for
   // new space growth policy.
   intptr_t bytes_promoted_;
-
-#ifdef DEBUG
+  RawObject* visiting_old_object_;
   bool in_scavenge_pointer_;
-#endif
-  bool visiting_old_pointers_;
 
   DISALLOW_COPY_AND_ASSIGN(ScavengerVisitor);
 };
 
 
 class ScavengerWeakVisitor : public HandleVisitor {
  public:
   explicit ScavengerWeakVisitor(Scavenger* scavenger) : scavenger_(scavenger) {
   }
 
@@ skipping 114 matching lines @@
 #endif  // defined(DEBUG)
   if (invoke_api_callbacks) {
     isolate->gc_epilogue_callbacks().Invoke();
   }
 }
 
 
 void Scavenger::IterateStoreBuffers(Isolate* isolate,
                                     ScavengerVisitor* visitor) {
   // Iterating through the store buffers.
-  BoolScope bs(visitor->VisitingOldPointersAddr(), true);
   // Grab the deduplication sets out of the store buffer.
   StoreBuffer::DedupSet* pending = isolate->store_buffer()->DedupSets();
   intptr_t entries = 0;
-  intptr_t duplicates = 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** pointer = reinterpret_cast<RawObject**>(set->At(i));
-      if (pointer != NULL) {
-        RawObject* value = *pointer;
-        // Skip entries that have been overwritten with Smis.
-        if (value->IsHeapObject()) {
-          if (from_->Contains(RawObject::ToAddr(value))) {
-            visitor->VisitPointer(pointer);
-          } else {
-            duplicates++;
-          }
-        }
+      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);
-  heap_->RecordData(kStoreBufferDuplicates, duplicates);
   StoreBufferBlock* block = isolate->store_buffer_block();
   entries = block->Count();
-  duplicates = 0;
   for (intptr_t i = 0; i < entries; i++) {
-    RawObject** pointer = reinterpret_cast<RawObject**>(block->At(i));
-    RawObject* value = *pointer;
-    if (value->IsHeapObject()) {
-      if (from_->Contains(RawObject::ToAddr(value))) {
-        visitor->VisitPointer(pointer);
-      } else {
-        duplicates++;
-      }
-    }
+    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);
-  heap_->RecordData(kStoreBufferBlockDuplicates, duplicates);
+  // 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,
                                visit_prologue_weak_persistent_handles,
                                StackFrameIterator::kDontValidateFrames);
@@ skipping 98 matching lines @@
       RawObject* raw_obj = RawObject::FromAddr(resolved_top_);
       intptr_t class_id = raw_obj->GetClassId();
       if (class_id != kWeakPropertyCid) {
         resolved_top_ += raw_obj->VisitPointers(visitor);
       } else {
         RawWeakProperty* raw_weak = reinterpret_cast<RawWeakProperty*>(raw_obj);
         resolved_top_ += ProcessWeakProperty(raw_weak, visitor);
       }
     }
     {
-      BoolScope bs(visitor->VisitingOldPointersAddr(), true);
       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.
+        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 128 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