Simple BlinkGC heap compaction.

third_party/WebKit/Source/platform/heap/Visitor.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 225 matching lines @@
     Derived::fromHelper(this)->registerWeakCellWithCallback(
         reinterpret_cast<void**>(
             const_cast<typename std::remove_const<T>::type**>(cell)),
         &handleWeakCell<T>);
   }
 
   template <typename T, void (T::*method)(Visitor*)>
   void registerWeakMembers(const T* obj) {
     registerWeakMembers(obj, &TraceMethodDelegate<T, method>::trampoline);
   }
+
   void registerWeakMembers(const void* object, WeakCallback callback) {
     Derived::fromHelper(this)->registerWeakMembers(object, object, callback);
   }
 
+  template <typename T>
+  void registerBackingStoreReference(T** slot) {
+    Derived::fromHelper(this)->registerMovingObjectReference(
+        reinterpret_cast<MovableReference*>(slot));
+  }
+
+  template <typename T>
+  void registerBackingStoreCallback(T* backingStore,
+                                    MovingObjectCallback callback,
+                                    void* callbackData) {
+    Derived::fromHelper(this)->registerMovingObjectCallback(
+        reinterpret_cast<MovableReference>(backingStore), callback,
+        callbackData);
+  }
+
   inline ThreadState* state() const { return m_state; }
   inline ThreadHeap& heap() const { return state()->heap(); }
 
  private:
   template <typename T>
   static void handleWeakCell(Visitor* self, void* object);
 
-  ThreadState* m_state;
+  ThreadState* const m_state;
 };
 
 // Visitor is used to traverse the Blink object graph. Used for the
 // marking phase of the mark-sweep garbage collector.
 //
 // Pointers are marked and pushed on the marking stack by calling the
 // |mark| method with the pointer as an argument.
 //
 // Pointers within objects are traced by calling the |trace| methods
 // with the object as an argument. Tracing objects will mark all of the
 // contained pointers and push them on the marking stack.
 class PLATFORM_EXPORT Visitor : public VisitorHelper<Visitor> {
  public:
   friend class VisitorHelper<Visitor>;
   friend class InlinedGlobalMarkingVisitor;
 
   enum MarkingMode {
     // This is a default visitor. This is used for GCType=GCWithSweep
     // and GCType=GCWithoutSweep.
     GlobalMarking,
     // This visitor does not trace objects outside the heap of the
     // GCing thread. This is used for GCType=ThreadTerminationGC.
     ThreadLocalMarking,
     // This visitor just marks objects and ignores weak processing.
     // This is used for GCType=TakeSnapshot.
     SnapshotMarking,
     // This visitor is used to trace objects during weak processing.
     // This visitor is allowed to trace only already marked objects.
     WeakProcessing,
+    // Perform global marking along with preparing for additional sweep
+    // compaction of heap arenas afterwards. Compared to the GlobalMarking
+    // visitor, this visitor will also register references to objects
+    // that might be moved during arena compaction -- the compaction
+    // pass will then fix up those references when the object move goes
+    // ahead.
+    GlobalMarkCompacting,

[haraken, 2016/12/09 07:25:56]

GlobalMarkingWithCompaction ?

[sof, 2016/12/09 21:44:05]

Twiddles, done.

   };
 
   static std::unique_ptr<Visitor> create(ThreadState*, BlinkGC::GCType);
 
   virtual ~Visitor();
 
   using VisitorHelper<Visitor>::mark;
 
   // This method marks an object and adds it to the set of objects
   // that should have their trace method called. Since not all
   // objects have vtables we have to have the callback as an
   // explicit argument, but we can use the templated one-argument
   // mark method above to automatically provide the callback
   // function.
   virtual void mark(const void*, TraceCallback) = 0;
 
   // Used to mark objects during conservative scanning.
   virtual void markHeader(HeapObjectHeader*, TraceCallback) = 0;
 
   // Used to delay the marking of objects until the usual marking
   // including emphemeron iteration is done. This is used to delay
   // the marking of collection backing stores until we know if they
   // are reachable from locations other than the collection front
   // object. If collection backings are reachable from other
   // locations we strongify them to avoid issues with iterators and
   // weak processing.
-  virtual void registerDelayedMarkNoTracing(const void*) = 0;
+  // A pointer to the location holding the backing store reference
+  // is passed in. This is done so as to potentially allow that
+  // location to be updated by the garbage collector.
+  virtual void registerDelayedMarkNoTracing(void**) = 0;
 
   // If the object calls this during the regular trace callback, then the
   // WeakCallback argument may be called later, when the strong roots
   // have all been found. The WeakCallback will normally use isAlive
   // to find out whether some pointers are pointing to dying objects. When
   // the WeakCallback is done the object must have purged all pointers
   // to objects where isAlive returned false. In the weak callback it is not
   // allowed to do anything that adds or extends the object graph (e.g.,
   // allocate a new object, add a new reference revive a dead object etc.)
   // Clearing out pointers to other heap objects is allowed, however. Note
@@ skipping 13 matching lines @@
 
   virtual void registerWeakTable(const void*,
                                  EphemeronCallback,
                                  EphemeronCallback) = 0;
 #if ENABLE(ASSERT)
   virtual bool weakTableRegistered(const void*) = 0;
 #endif
 
   virtual bool ensureMarked(const void*) = 0;
 
+  virtual void registerMovingObjectReference(MovableReference*) = 0;
+
+  virtual void registerMovingObjectCallback(MovableReference,
+                                            MovingObjectCallback,
+                                            void*) = 0;
+
   virtual void registerWeakCellWithCallback(void**, WeakCallback) = 0;
 
   inline MarkingMode getMarkingMode() const { return m_markingMode; }
 
+  inline bool isGlobalMarking() const {
+    return m_markingMode == GlobalMarking ||
+           m_markingMode == GlobalMarkCompacting;
+  }
+
  protected:
   Visitor(ThreadState*, MarkingMode);
 
  private:
   static Visitor* fromHelper(VisitorHelper<Visitor>* helper) {
     return static_cast<Visitor*>(helper);
   }
 
-  ThreadState* m_state;
   const MarkingMode m_markingMode;
 };
 
 }  // namespace blink
 
 #endif  // Visitor_h