Persist the scanning state across invocations of ProcessToSpace.

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 "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
@@ skipping 159 matching lines @@
   to_ = new MemoryRegion(space_->address(), semi_space_size);
   uword middle = space_->start() + semi_space_size;
   from_ = new MemoryRegion(reinterpret_cast<void*>(middle), semi_space_size);
 
   // Make sure that the two semi-spaces are aligned properly.
   ASSERT(Utils::IsAligned(to_->start(), kObjectAlignment));
   ASSERT(Utils::IsAligned(from_->start(), kObjectAlignment));
 
   // Setup local fields.
   top_ = FirstObjectStart();
+  resolved_top_ = top_;
   end_ = to_->end();
 
   survivor_end_ = FirstObjectStart();
 
 #if defined(DEBUG)
   memset(to_->pointer(), 0xf3, to_->size());
   memset(from_->pointer(), 0xf3, from_->size());
 #endif  // defined(DEBUG)
 }
 
 
 Scavenger::~Scavenger() {
   delete to_;
   delete from_;
   delete space_;
 }
 
 
 void Scavenger::Prologue(Isolate* isolate, bool invoke_api_callbacks) {
   if (invoke_api_callbacks) {
     isolate->gc_prologue_callbacks().Invoke();
   }
   // Flip the two semi-spaces so that to_ is always the space for allocating
   // objects.
   MemoryRegion* temp = from_;
   from_ = to_;
   to_ = temp;
   top_ = FirstObjectStart();
+  resolved_top_ = top_;
   end_ = to_->end();
 }
 
 
 void Scavenger::Epilogue(Isolate* isolate, bool invoke_api_callbacks) {
   // All objects in the to space have been copied from the from space at this
   // moment.
   survivor_end_ = top_;
 
 #if defined(DEBUG)
@@ skipping 64 matching lines @@
           break;
         }
       }
       // If all key objects are unreachable put the reference on a
       // delay queue.  This reference will be revisited if another
       // reference is scavenged.
       if (is_unreachable) {
         state->DelayWeakReference(reference);
       }
     }
-    if ((FirstObjectStart() < top_) || PromotedStackHasMore()) {
+    if ((resolved_top_ < top_) || PromotedStackHasMore()) {
       ProcessToSpace(visitor);
     } else {
       // Break out of the loop if there has been no forward process.
       break;
     }
   }
   // Deallocate any unreachable references on the delay queue.
   if (state->delayed_weak_references() != NULL) {
     WeakReference* queue = state->delayed_weak_references();
     state->set_delayed_weak_references(NULL);
     while (queue != NULL) {
       delete WeakReference::Pop(&queue);
     }
   }
 }
 
 
 void Scavenger::IterateWeakRoots(Isolate* isolate,
                                  HandleVisitor* visitor,
                                  bool visit_prologue_weak_persistent_handles) {
   isolate->VisitWeakPersistentHandles(visitor,
                                       visit_prologue_weak_persistent_handles);
 }
 
 
 void Scavenger::ProcessToSpace(ObjectPointerVisitor* visitor) {
-  uword resolved_top = FirstObjectStart();
   // Iterate until all work has been drained.
-  while ((resolved_top < top_) || PromotedStackHasMore()) {
-    while (resolved_top < top_) {
-      RawObject* raw_obj = RawObject::FromAddr(resolved_top);
-      resolved_top += raw_obj->VisitPointers(visitor);
+  while ((resolved_top_ < top_) || PromotedStackHasMore()) {
+    while (resolved_top_ < top_) {
+      RawObject* raw_obj = RawObject::FromAddr(resolved_top_);
+      resolved_top_ += raw_obj->VisitPointers(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.
       raw_object->VisitPointers(visitor);
     }
   }
 }
@@ skipping 50 matching lines @@
     OS::PrintErr(" done.\n");
   }
 
   count_++;
   // Done scavenging. Reset the marker.
   ASSERT(scavenging_);
   scavenging_ = false;
 }
 
 }  // namespace dart