Add a weak property type to the virtual machine.

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 <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 {
@@ skipping 39 matching lines @@
         visiting_old_pointers_(false) {}
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       ScavengePointer(current);
     }
   }
 
   void VisitingOldPointers(bool value) { visiting_old_pointers_ = value; }
 
+  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());
+    } else {
+      ASSERT(!raw_key->IsWatched());
+      raw_key->SetWatchedBit();
+    }
+    delay_set_.insert(std::make_pair(raw_key, raw_weak));
+  }
+
+  void Finalize() {
+    DelaySet::iterator it = delay_set_.begin();
+    for (; it != delay_set_.end(); ++it) {
+      WeakProperty::Clear(it->second);
+    }
+  }
+
  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;
     isolate()->store_buffer()->AddPointer(ptr);
@@ skipping 17 matching lines @@
     }
 
     // Read the header word of the object and determine if the object has
     // already been copied.
     uword header = *reinterpret_cast<uword*>(raw_addr);
     uword new_addr = 0;
     if (IsForwarding(header)) {
       // Get the new location of the object.
       new_addr = ForwardedAddr(header);
     } else {
+      if (raw_obj->IsWatched()) {
+        std::pair<DelaySet::iterator, DelaySet::iterator> ret;
+        // Visit all elements with a key equal to raw_obj.
+        ret = delay_set_.equal_range(raw_obj);
+        for (DelaySet::iterator it = ret.first; it != ret.second; ++it) {
+          it->second->VisitPointers(this);
+        }
+        delay_set_.erase(ret.first, ret.second);
+        raw_obj->ClearWatchedBit();
+      }
       intptr_t size = raw_obj->Size();
       // Check whether object should be promoted.
       if (scavenger_->survivor_end_ <= raw_addr) {
         // Not a survivor of a previous scavenge. Just copy the object into the
         // to space.
         new_addr = scavenger_->TryAllocate(size);
       } else {
         // TODO(iposva): Experiment with less aggressive promotion. For example
         // a coin toss determines if an object is promoted or whether it should
         // survive in this generation.
@@ skipping 26 matching lines @@
     *p = new_obj;
     // Update the store buffer as needed.
     if (visiting_old_pointers_) {
       UpdateStoreBuffer(p, new_obj);
     }
   }
 
   Scavenger* scavenger_;
   Heap* heap_;
   Heap* vm_heap_;
+  typedef std::multimap<RawObject*, RawWeakProperty*> DelaySet;
+  DelaySet delay_set_;
 
   bool visiting_old_pointers_;
 
   DISALLOW_COPY_AND_ASSIGN(ScavengerVisitor);
 };
 
 
 class ScavengerWeakVisitor : public HandleVisitor {
  public:
   explicit ScavengerWeakVisitor(Scavenger* scavenger) : scavenger_(scavenger) {
@@ skipping 273 matching lines @@
   isolate->VisitWeakPersistentHandles(visitor,
                                       visit_prologue_weak_persistent_handles);
 }
 
 
 void Scavenger::ProcessToSpace(ScavengerVisitor* visitor) {
   // 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);
+      intptr_t class_id = raw_obj->GetClassId();
+      if (class_id != kWeakPropertyCid) {
+        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()) {
       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);
     }
     visitor->VisitingOldPointers(false);
   }
 }
 
 
+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_) {
     RawObject* raw_obj = RawObject::FromAddr(cur);
     cur += raw_obj->VisitPointers(visitor);
   }
 }
 
 
 void Scavenger::VisitObjects(ObjectVisitor* visitor) const {
@@ skipping 33 matching lines @@
   Timer timer(FLAG_verbose_gc, "Scavenge");
   timer.Start();
   // Setup the visitor and run a scavenge.
   ScavengerVisitor visitor(isolate, this);
   Prologue(isolate, invoke_api_callbacks);
   IterateRoots(isolate, &visitor, !invoke_api_callbacks);
   ProcessToSpace(&visitor);
   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) {
     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;
 }
 
 
 void Scavenger::WriteProtect(bool read_only) {
   space_->Protect(
       read_only ? VirtualMemory::kReadOnly : VirtualMemory::kReadWrite);
 }
 
 }  // namespace dart