Add a weak property type to the virtual machine.

runtime/vm/gc_marker.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/gc_marker.h"
 
+#include <map>

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

Do we get to use stl now?  That's helpful.

+
 #include "vm/allocation.h"
 #include "vm/dart_api_state.h"
 #include "vm/isolate.h"
 #include "vm/pages.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
@@ skipping 113 matching lines @@
   }
 
   MarkingStack* marking_stack() const { return marking_stack_; }
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       MarkObject(*current, current);
     }
   }
 
+  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());
+      WeakProperty::Push(raw_weak, &it->second);
+    } else {
+      ASSERT(!raw_key->IsWatched());
+      raw_key->SetWatchedBit();
+      delay_set_[raw_key] = raw_weak;
+    }

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

So what we are implementing here is a map from Key to a list of RawWeakProperty
objects (where the list is implemented using the next_ field), right?  We make
sure that we only set the mark on the key once, but then we push all of the
associated WeakProperties onto a stack.

Did you consider dropping the next_ field from RawWeakProperty and just making
it an explicit map from key to list?  It would save a word per RawWeakProperty,
since the next_ field is only used during GC.  This may just be premature
optimization, since there won't be so many RawWeakProperties kicking around, but
wanted to discuss it.

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

I am now using a multimap instead of a map.  As such, the next_ field and the
Push and Pop methods are gone.  Done!

+  }
+
+  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);
+      }
+    }
+  }
+
   void set_update_store_buffers(bool val) { update_store_buffers_ = val; }
 
  private:
   void MarkAndPush(RawObject* raw_obj) {
     ASSERT(raw_obj->IsHeapObject());
     ASSERT(page_space_->Contains(RawObject::ToAddr(raw_obj)));
 
     // Mark the object and push it on the marking stack.
     ASSERT(!raw_obj->IsMarked());
     RawClass* raw_class = isolate()->class_table()->At(raw_obj->GetClassId());
     raw_obj->SetMarkBit();
+    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]

Is there are reason that you use WeakProperty::Pop during Finalize but not here?

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

That was an oversight.  This has been superseded by the use of a multimap.

+          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();
+    }
     marking_stack_->Push(raw_obj);
 
     // Update the number of used bytes on this page for fast accounting.
     HeapPage* page = PageSpace::PageFor(raw_obj);
     page->AddUsed(raw_obj->Size());
 
     // TODO(iposva): Should we mark the classes early?
     MarkObject(raw_class, NULL);
   }
 
@@ skipping 16 matching lines @@
 
     // TODO(iposva): merge old and code spaces.
     ASSERT(page_space_->Contains(RawObject::ToAddr(raw_obj)));
     MarkAndPush(raw_obj);
   }
 
   Heap* heap_;
   Heap* vm_heap_;
   PageSpace* page_space_;
   MarkingStack* marking_stack_;
+  typedef std::map<RawObject*, RawWeakProperty*> DelaySet;
+  DelaySet delay_set_;
   bool update_store_buffers_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MarkingVisitor);
 };
 
 
 bool IsUnreachable(const RawObject* raw_obj) {
   if (!raw_obj->IsHeapObject()) {
     return false;
   }
@@ skipping 114 matching lines @@
     }
   }
 }
 
 
 void GCMarker::DrainMarkingStack(Isolate* isolate,
                                  MarkingVisitor* visitor) {
   visitor->set_update_store_buffers(true);
   while (!visitor->marking_stack()->IsEmpty()) {
     RawObject* raw_obj = visitor->marking_stack()->Pop();
-    raw_obj->VisitPointers(visitor);
+    if (raw_obj->GetClassId() != kWeakProperty) {
+      raw_obj->VisitPointers(visitor);
+    } else {
+      RawWeakProperty* raw_weak = reinterpret_cast<RawWeakProperty*>(raw_obj);
+      ProcessWeakProperty(raw_weak, visitor);
+    }
   }
   visitor->set_update_store_buffers(false);
 }
 
 
+void GCMarker::ProcessWeakProperty(RawWeakProperty* raw_weak,
+                                   MarkingVisitor* visitor) {
+  // The fate of the weak property is determined by its key.
+  RawObject* raw_key = raw_weak->ptr()->key_;
+  if (!raw_key->IsMarked()) {
+    // Key is white.  Delay the weak property.
+    visitor->DelayWeakProperty(raw_weak);
+  } else {
+    // Key is gray or black.  Make the weak property black.
+    raw_weak->VisitPointers(visitor);
+  }
+}
+
+
 void GCMarker::MarkObjects(Isolate* isolate,
                            PageSpace* page_space,
                            bool invoke_api_callbacks) {
   MarkingStack marking_stack;
   Prologue(isolate, invoke_api_callbacks);
   MarkingVisitor mark(isolate, heap_, page_space, &marking_stack);
   IterateRoots(isolate, &mark, !invoke_api_callbacks);
   DrainMarkingStack(isolate, &mark);
   IterateWeakReferences(isolate, &mark);
   MarkingWeakVisitor mark_weak;
   IterateWeakRoots(isolate, &mark_weak, invoke_api_callbacks);
+  mark.Finalize();
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart