- Add a WeakTable to the VM. This is used to remember the

runtime/vm/heap.cc

 // Copyright (c) 2012, 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/heap.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/flags.h"
 #include "vm/heap_histogram.h"
 #include "vm/heap_profiler.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_set.h"
 #include "vm/os.h"
 #include "vm/pages.h"
 #include "vm/raw_object.h"
 #include "vm/scavenger.h"
 #include "vm/stack_frame.h"
 #include "vm/verifier.h"
 #include "vm/virtual_memory.h"
+#include "vm/weak_table.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, verbose_gc, false, "Enables verbose GC.");
 DEFINE_FLAG(int, verbose_gc_hdr, 40, "Print verbose GC header interval.");
 DEFINE_FLAG(bool, verify_before_gc, false,
             "Enables heap verification before GC.");
 DEFINE_FLAG(bool, verify_after_gc, false,
             "Enables heap verification after GC.");
 DEFINE_FLAG(bool, gc_at_alloc, false, "GC at every allocation.");
 DEFINE_FLAG(int, new_gen_heap_size, 32, "new gen heap size in MB,"
             "e.g: --new_gen_heap_size=64 allocates a 64MB new gen heap");
 DEFINE_FLAG(int, old_gen_heap_size, Heap::kHeapSizeInMB,
             "old gen heap size in MB,"
             "e.g: --old_gen_heap_size=1024 allocates a 1024MB old gen heap");
 
-Heap::Heap() : read_only_(false), gc_in_progress_(false) {
+  Heap::Heap() : read_only_(false), gc_in_progress_(false) {
+  for (WeakSelector sel = static_cast<WeakSelector>(0);
+       sel < kNumWeakSelectors;
+       sel++) {
+    new_weak_tables_[sel] = new WeakTable(0);
+    old_weak_tables_[sel] = new WeakTable(0);
+  }
   new_space_ = new Scavenger(this,
                              (FLAG_new_gen_heap_size * MB),
                              kNewObjectAlignmentOffset);
   old_space_ = new PageSpace(this, (FLAG_old_gen_heap_size * MB));
   stats_.num_ = 0;
 }
 
 
 Heap::~Heap() {
   delete new_space_;
@@ skipping 304 matching lines @@
       return "debugging";
     case kGCTestCase:
       return "test case";
     default:
       UNREACHABLE();
       return "";
   }
 }
 
 
-void Heap::SetPeer(RawObject* raw_obj, void* peer) {
+int64_t Heap::PeerCount() const {
+  return new_weak_tables_[kPeers]->count() + old_weak_tables_[kPeers]->count();
+}
+
+
+int64_t Heap::HashCount() const {
+  return
+      new_weak_tables_[kHashes]->count() + old_weak_tables_[kHashes]->count();
+}
+
+
+intptr_t Heap::GetWeakEntry(RawObject* raw_obj, WeakSelector sel) const {
   if (raw_obj->IsNewObject()) {
-    new_space_->SetPeer(raw_obj, peer);
+    return new_weak_tables_[sel]->GetValue(raw_obj);
+  }
+  ASSERT(raw_obj->IsOldObject());
+  return old_weak_tables_[sel]->GetValue(raw_obj);
+}
+
+
+void Heap::SetWeakEntry(RawObject* raw_obj, WeakSelector sel, intptr_t val) {
+  if (raw_obj->IsNewObject()) {
+    new_weak_tables_[sel] = new_weak_tables_[sel]->SetValue(raw_obj, val);
   } else {
     ASSERT(raw_obj->IsOldObject());
-    old_space_->SetPeer(raw_obj, peer);
+    old_weak_tables_[sel] = old_weak_tables_[sel]->SetValue(raw_obj, val);
   }
 }
 
 
-void* Heap::GetPeer(RawObject* raw_obj) {
-  if (raw_obj->IsNewObject()) {
-    return new_space_->GetPeer(raw_obj);
-  }
-  ASSERT(raw_obj->IsOldObject());
-  return old_space_->GetPeer(raw_obj);
-}
-
-
-int64_t Heap::PeerCount() const {
-  return new_space_->PeerCount() + old_space_->PeerCount();
-}
-
-
 void Heap::RecordBeforeGC(Space space, GCReason reason) {
   ASSERT(!gc_in_progress_);
   gc_in_progress_ = true;
   stats_.num_++;
   stats_.space_ = space;
   stats_.reason_ = reason;
   stats_.before_.micros_ = OS::GetCurrentTimeMicros();
   stats_.before_.new_used_ = new_space_->in_use();
   stats_.before_.new_capacity_ = new_space_->capacity();
   stats_.before_.old_used_ = old_space_->in_use();
@@ skipping 100 matching lines @@
     heap->DisableGrowthControl();
 }
 
 
 NoHeapGrowthControlScope::~NoHeapGrowthControlScope() {
     Heap* heap = reinterpret_cast<Isolate*>(isolate())->heap();
     heap->SetGrowthControlState(current_growth_controller_state_);
 }
 
 }  // namespace dart