Oilpan: Reduce sizeof(Persistent) to 16 byte

Source/platform/heap/Handle.h

 /*
  * Copyright (C) 2014 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 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef Handle_h
 #define Handle_h
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/HeapAllocator.h"
 #include "platform/heap/InlinedGlobalMarkingVisitor.h"
+#include "platform/heap/PersistentNode.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/heap/TraceTraits.h"
 #include "platform/heap/Visitor.h"
 #include "wtf/Functional.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/Locker.h"
+#include "wtf/MainThread.h"
 #include "wtf/RawPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/TypeTraits.h"
 
 namespace blink {
 
 template<typename T> class HeapTerminatedArray;
 
-class PersistentNode {
-public:
-    explicit PersistentNode(TraceCallback trace)
-        : m_trace(trace)
-    {
-    }
-
-    NO_LAZY_SWEEP_SANITIZE_ADDRESS
-    bool isHeapObjectAlive() { return m_trace; }
-
-    // This operator= is important. Without having the operator=, m_next and
-    // m_prev are inproperly copied and it breaks the link list of the
-    // persistent handles.
-    inline PersistentNode& operator=(const PersistentNode& otherref) { return *this; }
-
-private:
-    // Ideally the trace method should be virtual and automatically dispatch
-    // to the most specific implementation. However having a virtual method
-    // on PersistentNode leads to too eager template instantiation with MSVC
-    // which leads to include cycles.
-    // Instead we call the constructor with a TraceCallback which knows the
-    // type of the most specific child and calls trace directly. See
-    // TraceMethodDelegate in Visitor.h for how this is done.
-    void tracePersistentNode(Visitor* visitor)
-    {
-        m_trace(visitor, this);
-    }
-
-    ~PersistentNode()
-    {
-    }
-
-    TraceCallback m_trace;
-    PersistentNode* m_next;
-    PersistentNode* m_prev;
-
-    template<typename T> friend class CrossThreadPersistent;
-    template<typename T> friend class Persistent;
-    template<typename Collection> friend class PersistentHeapCollectionBase;
-    friend class PersistentAnchor;
-    friend class ThreadState;
-};
-
-// A dummy Persistent handle that ensures the list of persistents is never null.
-// This removes a test from a hot path.
-class PersistentAnchor : public PersistentNode {
-public:
-    void tracePersistentNodes(Visitor* visitor)
-    {
-        for (PersistentNode* current = m_next; current != this; current = current->m_next)
-            current->tracePersistentNode(visitor);
-    }
-
-    int numberOfPersistents()
-    {
-        int numberOfPersistents = 0;
-        for (PersistentNode* current = m_next; current != this; current = current->m_next)
-            ++numberOfPersistents;
-        return numberOfPersistents;
-    }
-
-    ~PersistentAnchor()
-    {
-        m_trace = nullptr;
-    }
-
-    template<typename VisitorDispatcher>
-    void trace(VisitorDispatcher visitor)
-    {
-        ASSERT_NOT_REACHED();
-    }
-
-private:
-    PersistentAnchor() : PersistentNode(TraceMethodDelegate<PersistentAnchor, &PersistentAnchor::trace>::trampoline)
-    {
-        m_next = this;
-        m_prev = this;
-    }
-
-    friend class ThreadState;
-};
-
 // Persistent handles are used to store pointers into the
 // managed heap. As long as the Persistent handle is alive
 // the GC will keep the object pointed to alive. Persistent
 // handles can be stored in objects and they are not scoped.
 // Persistent handles must not be used to contain pointers
 // between objects that are in the managed heap. They are only
 // meant to point to managed heap objects from variables/members
 // outside the managed heap.
 //
 // A Persistent is always a GC root from the point of view of
 // the garbage collector.
 //
 // We have to construct and destruct Persistent in the same thread.
 template<typename T>
-class Persistent : public PersistentNode {
+class Persistent final {
 public:
-    Persistent() : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(nullptr)
+    Persistent() : m_raw(nullptr)
     {
         initialize();
     }
 
-    Persistent(std::nullptr_t) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(nullptr)
+    Persistent(std::nullptr_t) : m_raw(nullptr)
     {
         initialize();
     }
 
-    Persistent(T* raw) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(raw)
+    Persistent(T* raw) : m_raw(raw)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
-    Persistent(T& raw) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(&raw)
+    Persistent(T& raw) : m_raw(&raw)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
-    Persistent(const Persistent& other) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(other)
+    Persistent(const Persistent& other) : m_raw(other)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    Persistent(const Persistent<U>& other) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(other)
+    Persistent(const Persistent<U>& other) : m_raw(other)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    Persistent(const Member<U>& other) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(other)
+    Persistent(const Member<U>& other) : m_raw(other)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    Persistent(const RawPtr<U>& other) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(other.get())
+    Persistent(const RawPtr<U>& other) : m_raw(other.get())
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     void clear() { m_raw = nullptr; }
 
     ~Persistent()
     {
         uninitialize();
         m_raw = nullptr;
-        m_trace = nullptr;
     }
 
     template<typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor)
     {
         static_assert(sizeof(T), "T must be fully defined");
         static_assert(IsGarbageCollectedType<T>::value, "T needs to be a garbage collected object");
         visitor->mark(m_raw);
     }
 
@@ skipping 63 matching lines @@
         return *this;
     }
 
     T* get() const { return m_raw; }
 
 private:
     void initialize()
     {
         ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
         state->checkThread();
-        m_prev = state->roots();
-        m_next = m_prev->m_next;
-        m_prev->m_next = this;
-        m_next->m_prev = this;
+        m_persistentNode = state->persistentRegion()->allocatePersistentNode(this, TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline);
     }
 
-    NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void uninitialize()
     {
-        ASSERT(isHeapObjectAlive());
-        ASSERT(m_next->isHeapObjectAlive());
-        ASSERT(m_prev->isHeapObjectAlive());
-        m_next->m_prev = m_prev;
-        m_prev->m_next = m_next;
+        ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
+        state->checkThread();
+        state->persistentRegion()->freePersistentNode(m_persistentNode);
     }
 
     void checkPointer()
     {
 #if ENABLE(ASSERT)
         if (!m_raw)
             return;
 
         // Heap::isHeapObjectAlive(m_raw) checks that m_raw is a traceable
         // object. In other words, it checks that the pointer is either of:
@@ skipping 11 matching lines @@
     void recordBacktrace()
     {
         if (m_raw)
             m_tracingName = Heap::createBacktraceString();
     }
 
     String m_tracingName;
 #else
     inline void recordBacktrace() const { }
 #endif
+    // m_raw is accessed most, so put it at the first field.
     T* m_raw;
+    PersistentNode* m_persistentNode;
 };
 
 // Unlike Persistent, we can destruct a CrossThreadPersistent in a thread
 // different from the construction thread.
 template<typename T>
-class CrossThreadPersistent : public PersistentNode {
+class CrossThreadPersistent final {
 public:
-    CrossThreadPersistent() : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(nullptr)
+    CrossThreadPersistent() : m_raw(nullptr)
     {
         initialize();
     }
 
-    CrossThreadPersistent(std::nullptr_t) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(nullptr)
+    CrossThreadPersistent(std::nullptr_t) : m_raw(nullptr)
     {
         initialize();
     }
 
-    CrossThreadPersistent(T* raw) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(raw)
+    CrossThreadPersistent(T* raw) : m_raw(raw)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
-    CrossThreadPersistent(T& raw) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(&raw)
+    CrossThreadPersistent(T& raw) : m_raw(&raw)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
-    CrossThreadPersistent(const CrossThreadPersistent& other) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(other)
+    CrossThreadPersistent(const CrossThreadPersistent& other) : m_raw(other)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    CrossThreadPersistent(const CrossThreadPersistent<U>& other) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(other)
+    CrossThreadPersistent(const CrossThreadPersistent<U>& other) : m_raw(other)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    CrossThreadPersistent(const Member<U>& other) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(other)
+    CrossThreadPersistent(const Member<U>& other) : m_raw(other)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    CrossThreadPersistent(const RawPtr<U>& other) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(other.get())
+    CrossThreadPersistent(const RawPtr<U>& other) : m_raw(other.get())
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     void clear() { m_raw = nullptr; }
 
     ~CrossThreadPersistent()
     {
         uninitialize();
         m_raw = nullptr;
-        m_trace = nullptr;
     }
 
     template<typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor)
     {
         static_assert(sizeof(T), "T must be fully defined");
         static_assert(IsGarbageCollectedType<T>::value, "T needs to be a garbage collected object");
         visitor->mark(m_raw);
     }
 
@@ skipping 61 matching lines @@
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     T* get() const { return m_raw; }
 
 private:
     void initialize()
     {
-        MutexLocker m_locker(ThreadState::globalRootsMutex());
-        m_prev = &ThreadState::globalRoots();
-        m_next = m_prev->m_next;
-        m_prev->m_next = this;
-        m_next->m_prev = this;
+        m_persistentNode = ThreadState::crossThreadPersistentRegion().allocatePersistentNode(this, TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline);
     }
 
-    NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void uninitialize()
     {
-        MutexLocker m_locker(ThreadState::globalRootsMutex());
-        ASSERT(isHeapObjectAlive());
-        ASSERT(m_next->isHeapObjectAlive());
-        ASSERT(m_prev->isHeapObjectAlive());
-        m_next->m_prev = m_prev;
-        m_prev->m_next = m_next;
+        ThreadState::crossThreadPersistentRegion().freePersistentNode(m_persistentNode);
     }
 
     void checkPointer()
     {
 #if ENABLE(ASSERT)
         if (!m_raw)
             return;
         // Heap::isHeapObjectAlive(m_raw) checks that m_raw is a traceable
         // object. In other words, it checks that the pointer is either of:
         //
@@ skipping 10 matching lines @@
     void recordBacktrace()
     {
         if (m_raw)
             m_tracingName = Heap::createBacktraceString();
     }
 
     String m_tracingName;
 #else
     inline void recordBacktrace() const { }
 #endif
+    // m_raw is accessed most, so put it at the first field.
     T* m_raw;
+    PersistentNode* m_persistentNode;
 };
 
 // PersistentNode must be the left-most class to let the
 // visitor->trace(static_cast<Collection*>(this)) trace the correct position.
 // FIXME: derive affinity based on the collection.
 template<typename Collection>
-class PersistentHeapCollectionBase : public PersistentNode, public Collection {
+class PersistentHeapCollectionBase : public Collection {
     // We overload the various new and delete operators with using the WTF DefaultAllocator to ensure persistent
     // heap collections are always allocated off-heap. This allows persistent collections to be used in
     // DEFINE_STATIC_LOCAL et. al.
     WTF_USE_ALLOCATOR(PersistentHeapCollectionBase, WTF::DefaultAllocator);
 public:
-    PersistentHeapCollectionBase() : PersistentNode(TraceMethodDelegate<PersistentHeapCollectionBase<Collection>, &PersistentHeapCollectionBase<Collection>::trace>::trampoline)
+    PersistentHeapCollectionBase()
     {
         initialize();
     }
 
-    PersistentHeapCollectionBase(const PersistentHeapCollectionBase& other) : PersistentNode(TraceMethodDelegate<PersistentHeapCollectionBase<Collection>, &PersistentHeapCollectionBase<Collection>::trace>::trampoline), Collection(other)
+    PersistentHeapCollectionBase(const PersistentHeapCollectionBase& other) : Collection(other)
     {
         initialize();
     }
 
     template<typename OtherCollection>
-    PersistentHeapCollectionBase(const OtherCollection& other) : PersistentNode(TraceMethodDelegate<PersistentHeapCollectionBase<Collection>, &PersistentHeapCollectionBase<Collection>::trace>::trampoline), Collection(other)
+    PersistentHeapCollectionBase(const OtherCollection& other) : Collection(other)
     {
         initialize();
     }
 
     ~PersistentHeapCollectionBase()
     {
         uninitialize();
-        m_trace = nullptr;
     }
 
     template<typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor)
     {
         static_assert(sizeof(Collection), "Collection must be fully defined");
         visitor->trace(*static_cast<Collection*>(this));
     }
 
 private:
     void initialize()
     {
         ThreadState* state = ThreadState::current();
-        m_prev = state->roots();
-        m_next = m_prev->m_next;
-        m_prev->m_next = this;
-        m_next->m_prev = this;
+        state->checkThread();
+        m_persistentNode = state->persistentRegion()->allocatePersistentNode(this, TraceMethodDelegate<PersistentHeapCollectionBase<Collection>, &PersistentHeapCollectionBase<Collection>::trace>::trampoline);
     }
 
-    NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void uninitialize()
     {
-        ASSERT(isHeapObjectAlive());
-        ASSERT(m_next->isHeapObjectAlive());
-        ASSERT(m_prev->isHeapObjectAlive());
-        m_next->m_prev = m_prev;
-        m_prev->m_next = m_next;
+        ThreadState* state = ThreadState::current();
+        state->checkThread();
+        state->persistentRegion()->freePersistentNode(m_persistentNode);
     }
+
+    PersistentNode* m_persistentNode;
 };
 
 template<
     typename KeyArg,
     typename MappedArg,
     typename HashArg = typename DefaultHash<KeyArg>::Hash,
     typename KeyTraitsArg = HashTraits<KeyArg>,
     typename MappedTraitsArg = HashTraits<MappedArg>>
 class PersistentHeapHashMap : public PersistentHeapCollectionBase<HeapHashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg>> { };
 
@@ skipping 680 matching lines @@
 struct ParamStorageTraits<RawPtr<T>> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
     static_assert(sizeof(T), "T must be fully defined");
 };
 
 template<typename T>
 PassRefPtr<T> adoptRef(blink::RefCountedGarbageCollected<T>*) = delete;
 
 } // namespace WTF
 
 #endif