Implement IdentityMap<V>, a robust, GC-safe object-identity HashMap.

src/heap/heap.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HEAP_HEAP_H_
 #define V8_HEAP_HEAP_H_
 
 #include <cmath>
 
 #include "src/allocation.h"
@@ skipping 1435 matching lines @@
   void RecordFixedArraySubTypeStats(int array_sub_type, size_t size) {
     DCHECK(array_sub_type <= LAST_FIXED_ARRAY_SUB_TYPE);
     object_counts_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type]++;
     object_sizes_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type] += size;
   }
 
   void TraceObjectStats();
   void TraceObjectStat(const char* name, int count, int size, double time);
   void CheckpointObjectStats();
 
-  // We don't use a LockGuard here since we want to lock the heap
-  // only when FLAG_concurrent_recompilation is true.
+  struct StrongRootsList {

[Benedikt Meurer, 2015/04/29 03:48:35]

Style nit: Please forward declare struct and the two methods below in the .h
file and move the definition of the struct and the implementations of the
methods to the .cc file.

Also since it's a struct and all fields are public, you don't need the _ suffix
on their names.

[titzer, 2015/05/06 09:11:25]

Done.

+    Object** start_;
+    Object** end_;
+    StrongRootsList* next_;
+  };
+
+  void RegisterStrongRoots(Object** start, Object** end) {
+    StrongRootsList* list = new StrongRootsList();
+    list->next_ = strong_roots_list_;
+    list->start_ = start;
+    list->end_ = end;
+    strong_roots_list_ = list;
+  }
+
+  void UnregisterStrongRoots(Object** start) {
+    StrongRootsList* prev = NULL;
+    for (StrongRootsList* list = strong_roots_list_; list; list = list->next_) {
+      if (list->start_ == start) {
+        if (prev) {
+          prev->next_ = list->next_;
+        } else {
+          strong_roots_list_ = list->next_;
+        }
+        delete list;
+      }
+      prev = list;
+    }
+  }
+
+  // Taking this lock prevents the GC from entering a phase that relocates
+  // object references.
   class RelocationLock {
    public:
     explicit RelocationLock(Heap* heap) : heap_(heap) {
       heap_->relocation_mutex_.Lock();
     }
 
-
     ~RelocationLock() { heap_->relocation_mutex_.Unlock(); }
 
    private:
     Heap* heap_;
   };
 
+  // An optional version of the above lock that can be used for some critical
+  // sections on the mutator thread; only safe since the GC currently does not
+  // do concurrent compaction.
+  class OptionalRelocationLock {
+   public:
+    explicit OptionalRelocationLock(Heap* heap, bool concurrent)

[Benedikt Meurer, 2015/04/29 03:48:35]

You don't need explicit here.

[titzer, 2015/05/06 09:11:25]

Done.

+        : heap_(heap), concurrent_(concurrent) {
+      if (concurrent_) heap_->relocation_mutex_.Lock();
+    }
+
+    ~OptionalRelocationLock() {
+      if (concurrent_) heap_->relocation_mutex_.Unlock();
+    }
+
+   private:
+    Heap* heap_;
+    bool concurrent_;
+  };
+
   void AddWeakObjectToCodeDependency(Handle<HeapObject> obj,
                                      Handle<DependentCode> dep);
 
   DependentCode* LookupWeakObjectToCodeDependency(Handle<HeapObject> obj);
 
   void AddRetainedMap(Handle<Map> map);
 
   static void FatalProcessOutOfMemory(const char* location,
                                       bool take_snapshot = false);
 
@@ skipping 667 matching lines @@
   MemoryChunk* chunks_queued_for_free_;
 
   base::Mutex relocation_mutex_;
 
   int gc_callbacks_depth_;
 
   bool deserialization_complete_;
 
   bool concurrent_sweeping_enabled_;
 
+  StrongRootsList* strong_roots_list_;
+
   friend class AlwaysAllocateScope;
   friend class Deserializer;
   friend class Factory;
   friend class GCCallbacksScope;
   friend class GCTracer;
   friend class HeapIterator;
   friend class Isolate;
   friend class MarkCompactCollector;
   friend class MarkCompactMarkingVisitor;
   friend class MapCompact;
@@ skipping 441 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 }
 }  // namespace v8::internal
 
 #endif  // V8_HEAP_HEAP_H_