Implement prologue weak persistent handles.

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 119 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ScavengerVisitor);
 };
 
 
 class ScavengerWeakVisitor : public HandleVisitor {
  public:
   explicit ScavengerWeakVisitor(Scavenger* scavenger) : scavenger_(scavenger) {
   }
 
   void VisitHandle(uword addr) {
-    WeakPersistentHandle* handle =
-        reinterpret_cast<WeakPersistentHandle*>(addr);
+    FinalizablePersistentHandle* handle =
+        reinterpret_cast<FinalizablePersistentHandle*>(addr);
     RawObject* raw_obj = handle->raw();
     if (!raw_obj->IsHeapObject()) return;
     uword raw_addr = RawObject::ToAddr(raw_obj);
     if (scavenger_->from_->Contains(raw_addr)) {
       uword header = *reinterpret_cast<uword*>(raw_addr);
       if (IsForwarding(header)) {
         handle->set_raw(RawObject::FromAddr(ForwardedAddr(header)));
       } else {
-        WeakPersistentHandle::Finalize(handle);
+        FinalizablePersistentHandle::Finalize(handle);
       }
     }
   }
 
  private:
   Scavenger* scavenger_;
 
   DISALLOW_COPY_AND_ASSIGN(ScavengerWeakVisitor);
 };
 
@@ skipping 34 matching lines @@
 }
 
 
 Scavenger::~Scavenger() {
   delete to_;
   delete from_;
   delete space_;
 }
 
 
-void Scavenger::Prologue() {
+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();
   end_ = to_->end();
 }
 
 
-void Scavenger::Epilogue() {
+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)
   memset(from_->pointer(), 0xf3, from_->size());
 #endif  // defined(DEBUG)
+  if (invoke_api_callbacks) {
+    isolate->gc_prologue_callbacks().Invoke();
+  }
 }
 
 
-void Scavenger::IterateRoots(Isolate* isolate, ObjectPointerVisitor* visitor) {
+void Scavenger::IterateRoots(Isolate* isolate,
+                             ObjectPointerVisitor* visitor,
+                             bool visit_prologue_weak_persistent_handles) {
   isolate->VisitObjectPointers(visitor,
+                               visit_prologue_weak_persistent_handles,
                                StackFrameIterator::kDontValidateFrames);
   heap_->IterateOldPointers(visitor);
 }
 
 
-void Scavenger::IterateWeakRoots(Isolate* isolate, HandleVisitor* visitor) {
-  isolate->VisitWeakPersistentHandles(visitor);
+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);
@@ skipping 12 matching lines @@
 void Scavenger::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
   uword cur = FirstObjectStart();
   while (cur < top_) {
     RawObject* raw_obj = RawObject::FromAddr(cur);
     cur += raw_obj->VisitPointers(visitor);
   }
 }
 
 
 void Scavenger::Scavenge() {
+  // TODO(cshapiro): Add a decision procedure for determining when the
+  // the API callbacks should be invoked.
+  Scavenge(false);
+}
+
+
+void Scavenger::Scavenge(bool invoke_api_callbacks) {
   // Scavenging is not reentrant. Make sure that is the case.
   ASSERT(!scavenging_);
   scavenging_ = true;
   Isolate* isolate = Isolate::Current();
   NoHandleScope no_handles(isolate);
 
   if (FLAG_verify_before_gc) {
     OS::PrintErr("Verifying before Scavenge... ");
     heap_->Verify();
     OS::PrintErr(" done.\n");
   }
 
   Timer timer(FLAG_verbose_gc, "Scavenge");
   timer.Start();
   // Setup the visitor and run a scavenge.
   ScavengerVisitor visitor(this);
-  Prologue();
-  IterateRoots(isolate, &visitor);
+  Prologue(isolate, invoke_api_callbacks);
+  IterateRoots(isolate, &visitor, !invoke_api_callbacks);
   ProcessToSpace(&visitor);
   ScavengerWeakVisitor weak_visitor(this);
-  IterateWeakRoots(isolate, &weak_visitor);
-  Epilogue();
+  IterateWeakRoots(isolate, &weak_visitor, invoke_api_callbacks);
+  Epilogue(isolate, invoke_api_callbacks);
   timer.Stop();
   if (FLAG_verbose_gc) {
     OS::PrintErr("Scavenge[%d]: %dus\n", count_, timer.TotalElapsedTime());
   }
 
   if (FLAG_verify_after_gc) {
     OS::PrintErr("Verifying after Scavenge... ");
     heap_->Verify();
     OS::PrintErr(" done.\n");
   }
 
   count_++;
   // Done scavenging. Reset the marker.
   ASSERT(scavenging_);
   scavenging_ = false;
 }
 
 }  // namespace dart