Add a weak property type to the virtual machine.

runtime/vm/scavenger.cc

Index: runtime/vm/scavenger.cc
diff --git a/runtime/vm/scavenger.cc b/runtime/vm/scavenger.cc
index 1909ae2b7234c341f36859d60f958aa442105ba3..152f8139685bcaddcd065e163e2b3128ab1a0a35 100644
--- a/runtime/vm/scavenger.cc
+++ b/runtime/vm/scavenger.cc
@@ -4,6 +4,8 @@
 
 #include "vm/scavenger.h"
 
+#include <map>
+
 #include "vm/dart.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
@@ -63,6 +65,29 @@ class ScavengerVisitor : public ObjectPointerVisitor {
 
   void VisitingOldPointers(bool value) { visiting_old_pointers_ = value; }
 
+  void DelayWeakProperty(RawWeakProperty* raw_weak) {

[turnidge, 2012/08/09 18:34:34]

It's a shame about the code duplication between here and gc_marker.cc.  Is this
common for these files?  Is there any simple way to share the code?

I'm pondering whether there could be a WeakPropertyTracker (or whatever) object
that allows you to Process(prop, visitor) and Finalize() that you could use in
each file.

[cshapiro, 2012/08/14 04:58:18]

Most of the supporting methods are now gone.  Can you think of a simplification?
 Ideally, more of this code would be shared i.e. the whole scavenge visitor
could be used by the marker as well.  We should look at this together...

+    RawObject* raw_key = raw_weak->ptr()->key_;
+    DelaySet::iterator it = delay_set_.find(raw_key);
+    if (it != delay_set_.end()) {
+      ASSERT(raw_key->IsWatched());
+      WeakProperty::Push(raw_weak, &it->second);
+    } else {
+      ASSERT(!raw_key->IsWatched());
+      raw_key->SetWatchedBit();
+      delay_set_[raw_key] = raw_weak;
+    }
+  }
+
+  void Finalize() {
+    DelaySet::iterator it = delay_set_.begin();
+    for (; it != delay_set_.end(); ++it) {
+      while (it->second != Object::null()) {
+        RawWeakProperty* head = WeakProperty::Pop(&it->second);
+        WeakProperty::Clear(head);
+      }
+    }
+  }
+
  private:
   void UpdateStoreBuffer(RawObject** p, RawObject* obj) {
     uword ptr = reinterpret_cast<uword>(p);
@@ -100,6 +125,19 @@ class ScavengerVisitor : public ObjectPointerVisitor {
       // Get the new location of the object.
       new_addr = ForwardedAddr(header);
     } else {
+      if (raw_obj->IsWatched()) {
+        DelaySet::iterator it = delay_set_.find(raw_obj);
+        ASSERT(it != delay_set_.end());
+        RawWeakProperty* raw_weak = it->second;
+        while (raw_weak != WeakProperty::null()) {

[turnidge, 2012/08/09 18:34:34]

Ditto comment in other file regarding "Pop".

[cshapiro, 2012/08/14 04:58:18]

Yup.  Done.

+          raw_weak->VisitPointers(this);
+          RawWeakProperty* next = raw_weak->ptr()->next_;
+          raw_weak->ptr()->next_ = WeakProperty::null();
+          raw_weak = next;
+        }
+        delay_set_.erase(it);
+        raw_obj->ClearWatchedBit();
+      }
       intptr_t size = raw_obj->Size();
       // Check whether object should be promoted.
       if (scavenger_->survivor_end_ <= raw_addr) {
@@ -146,6 +184,8 @@ class ScavengerVisitor : public ObjectPointerVisitor {
   Scavenger* scavenger_;
   Heap* heap_;
   Heap* vm_heap_;
+  typedef std::map<RawObject*, RawWeakProperty*> DelaySet;
+  DelaySet delay_set_;
 
   bool visiting_old_pointers_;
 
@@ -439,7 +479,13 @@ void Scavenger::ProcessToSpace(ScavengerVisitor* visitor) {
   while ((resolved_top_ < top_) || PromotedStackHasMore()) {
     while (resolved_top_ < top_) {
       RawObject* raw_obj = RawObject::FromAddr(resolved_top_);
-      resolved_top_ += raw_obj->VisitPointers(visitor);
+      intptr_t class_id = raw_obj->GetClassId();
+      if (class_id != kWeakProperty) {
+        resolved_top_ += raw_obj->VisitPointers(visitor);
+      } else {
+        RawWeakProperty* raw_weak = reinterpret_cast<RawWeakProperty*>(raw_obj);
+        resolved_top_ += ProcessWeakProperty(raw_weak, visitor);
+      }
     }
     visitor->VisitingOldPointers(true);
     while (PromotedStackHasMore()) {
@@ -454,6 +500,23 @@ void Scavenger::ProcessToSpace(ScavengerVisitor* visitor) {
 }
 
 
+uword Scavenger::ProcessWeakProperty(RawWeakProperty* raw_weak,
+                                     ScavengerVisitor* visitor) {
+  // The fate of the weak property is determined by its key.
+  RawObject* raw_key = raw_weak->ptr()->key_;
+  uword raw_addr = RawObject::ToAddr(raw_key);
+  uword header = *reinterpret_cast<uword*>(raw_addr);
+  if (!IsForwarding(header)) {
+    // Key is white.  Delay the weak property.
+    visitor->DelayWeakProperty(raw_weak);
+    return raw_weak->Size();
+  } else {
+    // Key is gray or black.  Make the weak property black.
+    return raw_weak->VisitPointers(visitor);
+  }
+}
+
+
 void Scavenger::VisitObjectPointers(ObjectPointerVisitor* visitor) const {
   uword cur = FirstObjectStart();
   while (cur < top_) {
@@ -507,6 +570,7 @@ void Scavenger::Scavenge(bool invoke_api_callbacks) {
   IterateWeakReferences(isolate, &visitor);
   ScavengerWeakVisitor weak_visitor(this);
   IterateWeakRoots(isolate, &weak_visitor, invoke_api_callbacks);
+  visitor.Finalize();
   Epilogue(isolate, invoke_api_callbacks);
   timer.Stop();
   if (FLAG_verbose_gc) {