- 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>
 
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/store_buffer.h"
 #include "vm/verifier.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
-// Scavenger uses RawObject::kFreeBit to distinguish forwaded and non-forwarded
-// objects because scavenger can never encounter free list element during
-// evacuation and thus all objects scavenger encounters have
-// kFreeBit cleared.
+// Scavenger uses RawObject::kMarkBit to distinguish forwaded and non-forwarded
+// objects because scavenger can never encounter marked elements during
+// evacuation and thus all objects scavenger encounters have the
+// kMarkBit cleared.
 enum {
-  kForwardingMask = 1,
+  kForwardingMask = RawObject::kMarkBit,
   kNotForwarded = 0,
-  kForwarded = 1,
+  kForwarded = kForwardingMask,
 };
 
 
 static inline bool IsForwarding(uword header) {
   uword bits = header & kForwardingMask;
   ASSERT((bits == kNotForwarded) || (bits == kForwarded));
   return bits == kForwarded;
 }
 
 
@@ skipping 75 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;
+    if (!obj->IsNewObject() || visiting_old_object_->IsRemembered()) {
+      return;
+    }
+    visiting_old_object_->SetRememberedBit();
     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
@@ skipping 156 matching lines @@
 };
 
 
 Scavenger::Scavenger(Heap* heap, intptr_t max_capacity, uword object_alignment)
     : heap_(heap),
       object_alignment_(object_alignment),
       scavenging_(false) {
   // Verify assumptions about the first word in objects which the scavenger is
   // going to use for forwarding pointers.
   ASSERT(Object::tags_offset() == 0);
-  ASSERT(kForwardingMask == (1 << RawObject::kFreeBit));
 
   // Allocate the virtual memory for this scavenge heap.
   space_ = VirtualMemory::Reserve(max_capacity);
   if (space_ == NULL) {
     FATAL("Out of memory.\n");
   }
 
   // Allocate the entire space at the beginning.
   space_->Commit(false);
 
@@ skipping 79 matching lines @@
   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) {
+        ASSERT(raw_object->IsRemembered());
+        raw_object->ClearRememberedBit();
         visitor->VisitingOldObject(raw_object);
         raw_object->VisitPointers(visitor);
         handled++;
         if (handled == count) {
           break;
         }
       }
     }
     delete pending;
     pending = next;
@@ skipping 117 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