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

runtime/vm/heap.h

 // 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.
 
 #ifndef VM_HEAP_H_
 #define VM_HEAP_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/pages.h"
 #include "vm/scavenger.h"
+#include "vm/weak_table.h"
 
 namespace dart {
 
 // Forward declarations.
 class Isolate;
 class ObjectPointerVisitor;
 class ObjectSet;
 class VirtualMemory;
 
 DECLARE_FLAG(bool, verbose_gc);
 DECLARE_FLAG(bool, verify_before_gc);
 DECLARE_FLAG(bool, verify_after_gc);
 DECLARE_FLAG(bool, gc_at_alloc);
 
 class Heap {
  public:
   enum Space {
     kNew,
     kOld,
     kCode,
   };
 
+  enum WeakSelector {
+    kPeers = 0,
+    kHashes,
+    kNumWeakSelectors
+  };
+
   enum ApiCallbacks {
     kIgnoreApiCallbacks,
     kInvokeApiCallbacks
   };
 
   enum GCReason {
     kNewSpace,
     kPromotionFailure,
     kOldSpace,
     kFull,
@@ skipping 115 matching lines @@
   void StartEndAddress(uword* start, uword* end) const;
 
   ObjectSet* CreateAllocatedObjectSet() const;
 
   // Generates a profile of the current and VM isolate heaps.
   void Profile(Dart_FileWriteCallback callback, void* stream) const;
   void ProfileToFile(const char* reason) const;
 
   static const char* GCReasonToString(GCReason gc_reason);
 
-  // Associates a peer with an object.  If an object has a peer, it is
-  // replaced.  A value of NULL disassociate an object from its peer.
-  void SetPeer(RawObject* raw_obj, void* peer);
+  // Associate a peer with an object.  A non-existent peer is equal to NULL.
+  void SetPeer(RawObject* raw_obj, void* peer) {
+    SetWeakEntry(raw_obj, kPeers, reinterpret_cast<intptr_t>(peer));
+  }
+  void* GetPeer(RawObject* raw_obj) const {
+    return reinterpret_cast<void*>(GetWeakEntry(raw_obj, kPeers));
+  }
+  int64_t PeerCount() const;
 
-  // Retrieves the peer associated with an object.  Returns NULL if
-  // there is no association.
-  void* GetPeer(RawObject* raw_obj);
+  // Associate an identity hashCode with an object. An non-existent hashCode
+  // is equal to 0.
+  void SetHash(RawObject* raw_obj, intptr_t hash) {
+    SetWeakEntry(raw_obj, kHashes, hash);
+  }
+  intptr_t GetHash(RawObject* raw_obj) const {
+    return GetWeakEntry(raw_obj, kHashes);
+  }
+  int64_t HashCount() const;
 
-  // Returns the number of objects with a peer.
-  int64_t PeerCount() const;
+  // Used by the GC algorithms to propagate weak entries.
+  intptr_t GetWeakEntry(RawObject* raw_obj, WeakSelector sel) const;
+  void SetWeakEntry(RawObject* raw_obj, WeakSelector sel, intptr_t val);
+
+  WeakTable* GetWeakTable(Space space, WeakSelector selector) const {
+    if (space == kNew) {
+      return new_weak_tables_[selector];
+    }
+    ASSERT(space ==kOld);
+    return old_weak_tables_[selector];
+  }
+  void SetWeakTable(Space space, WeakSelector selector, WeakTable* value) {
+    if (space == kNew) {
+      new_weak_tables_[selector] = value;
+    } else {
+      ASSERT(space == kOld);
+      old_weak_tables_[selector] = value;
+    }
+  }
 
   // Stats collection.
   void RecordTime(int id, int64_t micros) {
     ASSERT((id >= 0) && (id < GCStats::kDataEntries));
     stats_.times_[id] = micros;
   }
 
   void RecordData(int id, intptr_t value) {
     ASSERT((id >= 0) && (id < GCStats::kDataEntries));
     stats_.data_[id] = value;
@@ skipping 48 matching lines @@
   // GC stats collection.
   void RecordBeforeGC(Space space, GCReason reason);
   void RecordAfterGC();
   void PrintStats();
   void UpdateObjectHistogram();
 
   // The different spaces used for allocation.
   Scavenger* new_space_;
   PageSpace* old_space_;
 
+  WeakTable* new_weak_tables_[kNumWeakSelectors];
+  WeakTable* old_weak_tables_[kNumWeakSelectors];
+
   // GC stats collection.
   GCStats stats_;
 
   // This heap is in read-only mode: No allocation is allowed.
   bool read_only_;
 
   // GC on the heap is in progress.
   bool gc_in_progress_;
 
   friend class GCTestHelper;
@@ skipping 24 matching lines @@
   NoHeapGrowthControlScope();
   ~NoHeapGrowthControlScope();
  private:
   bool current_growth_controller_state_;
   DISALLOW_COPY_AND_ASSIGN(NoHeapGrowthControlScope);
 };
 
 }  // namespace dart
 
 #endif  // VM_HEAP_H_