Lazy peer API.

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"
@@ skipping 493 matching lines @@
     // 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::ProcessPeerReferents() {
+  std::map<RawObject*, void*>::iterator it = peer_.begin();
+  while (it != peer_.end()) {
+    RawObject* raw_obj = it->first;
+    ASSERT(raw_obj->IsHeapObject());
+    uword raw_addr = RawObject::ToAddr(raw_obj);
+    uword header = *reinterpret_cast<uword*>(raw_addr);
+    if (IsForwarding(header)) {
+      // The object has survived.  If it has been copied to new space,
+      // update the table for the new location.  If it has been copied
+      // to old space, move it to the old space table.
+      uword new_addr = ForwardedAddr(header);
+      raw_obj = RawObject::FromAddr(new_addr);
+      void* peer = it->second;
+      peer_.erase(it++);
+      heap_->SetPeer(raw_obj, peer);

[Anton Muhin, 2012/09/13 06:27:07]

That looks sketchy, but I am not sure I remember STL semantics correctly.

My concern is you modify the map while iterating over it.  So are there any
chances that you'll iterate over just added objects too?  That looks possible to
me, esp. if to-spaces resides in higher addresses.

And if all above is possible, won't that make peers disappear?

[cshapiro, 2012/09/15 01:23:41]

Modifying the map while traversing it should be okay as far as the STL is
concerned.  However, as you have observed, this is not correct as far as the
algorithm is concerned.

Using a separate table has some additional advantages.  I will make that change.

+    } else {
+      // The object has become garbage.  Remove its record.
+      peer_.erase(it++);
+    }
+  }
+}
+
+
 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 34 matching lines @@
   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();
+  ProcessPeerReferents();
   Epilogue(isolate, invoke_api_callbacks);
   timer.Stop();
   if (FLAG_verbose_gc) {
     OS::PrintErr("Scavenge[%d]: %"Pd64"us\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);
 }
 
+
+void Scavenger::SetPeer(RawObject* raw_obj, void* peer) {

[Anton Muhin, 2012/09/13 06:27:07]

you've written this code once, maybe abstract away into PeerMap?

+  if (peer == NULL) {
+    peer_.erase(raw_obj);
+  } else {
+    peer_[raw_obj] = peer;
+  }
+}
+
+
+void* Scavenger::GetPeer(RawObject* raw_obj) {
+  std::map<RawObject*, void*>::iterator it = peer_.find(raw_obj);
+  return (it == peer_.end()) ? NULL : it->second;
+}
+
+
+int64_t Scavenger::PeerCount() const {
+  return static_cast<int64_t>(peer_.size());
+}
+
 }  // namespace dart