Refactor the Heap into ThreadHeap to prepare for per thread heaps

third_party/WebKit/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 41 matching lines @@
 
 namespace blink {
 
 enum WeaknessPersistentConfiguration {
     NonWeakPersistentConfiguration,
     WeakPersistentConfiguration
 };
 
 enum CrossThreadnessPersistentConfiguration {
     SingleThreadPersistentConfiguration,
-    CrossThreadPersistentConfiguration
+    CrossThreadPersistentConfiguration,
+    XThreadPersistentConfiguration
 };
 
 template<typename T, WeaknessPersistentConfiguration weaknessConfiguration, CrossThreadnessPersistentConfiguration crossThreadnessConfiguration>
 class PersistentBase {
 public:
     PersistentBase() : m_raw(nullptr)
     {
         initialize();
     }
 
@@ skipping 123 matching lines @@
             LEAK_SANITIZER_IGNORE_OBJECT(this);
         }
         return this;
     }
 #endif
 
 private:
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void assign(T* ptr)
     {
+        if (crossThreadnessConfiguration == XThreadPersistentConfiguration
+            && ThreadState::forObject(m_raw) != ThreadState::forObject(ptr)) {
+                uninitialize();
+        }
         m_raw = ptr;
         checkPointer();
         if (m_raw) {
             if (!m_persistentNode)
                 initialize();
             return;
         }
         if (m_persistentNode && crossThreadnessConfiguration != CrossThreadPersistentConfiguration)
             uninitialize();
     }
 
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void initialize()
     {
         ASSERT(!m_persistentNode);
-        if (!m_raw)
+        if (!m_raw || m_raw == reinterpret_cast<T*>(-1))
             return;
 
         TraceCallback traceCallback = TraceMethodDelegate<PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>, &PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>::trace>::trampoline;
-        if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
+        if (crossThreadnessConfiguration == XThreadPersistentConfiguration) {
+            BasePage* page = pageFromObject(m_raw);
+            ASSERT(page);
+            m_persistentNode = page->heap()->threadState()->xThreadPersistentRegion()->allocatePersistentNode(this, traceCallback);
+        } else if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
             m_persistentNode = ThreadState::crossThreadPersistentRegion().allocatePersistentNode(this, traceCallback);
         } else {
             ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
             ASSERT(state->checkThread());
             m_persistentNode = state->persistentRegion()->allocatePersistentNode(this, traceCallback);
 #if ENABLE(ASSERT)
             m_state = state;
 #endif
         }
     }
 
     void uninitialize()
     {
         if (!m_persistentNode)
             return;
 
-        if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
+        if (crossThreadnessConfiguration == XThreadPersistentConfiguration) {
+            ASSERT(m_raw);
+            ASSERT(m_raw != reinterpret_cast<T*>(-1));
+            BasePage* page = pageFromObject(m_raw);
+            ASSERT(page);
+            page->heap()->threadState()->xThreadPersistentRegion()->freePersistentNode(m_persistentNode);
+        } else if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
             ThreadState::crossThreadPersistentRegion().freePersistentNode(m_persistentNode);
         } else {
             ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
             ASSERT(state->checkThread());
             // Persistent handle must be created and destructed in the same thread.
             ASSERT(m_state == state);
             state->persistentRegion()->freePersistentNode(m_persistentNode);
         }
         m_persistentNode = nullptr;
     }
 
     void checkPointer()
     {
+        if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
+            ThreadState* threadState = ThreadState::forObject(m_raw);
+            ASSERT(!threadState || !threadState->perThreadHeapEnabled());
+        }
 #if ENABLE(ASSERT) && defined(ADDRESS_SANITIZER)
         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:
         //
         //   (a) a pointer to the head of an on-heap object.
         //   (b) a pointer to the head of an on-heap mixin object.
         //
@@ skipping 252 matching lines @@
     }
 
     template<typename U>
     CrossThreadWeakPersistent& operator=(const RawPtr<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 };
 
+template<typename T>
+class XThreadPersistent : public PersistentBase<T, NonWeakPersistentConfiguration, XThreadPersistentConfiguration> {

[haraken, 2016/01/07 08:06:22]

I'm considering a way to land the per-thread heap without introducing
XThreadPersistent to the code base. Can we do something like this?

- Remove XThreadPersistent and XThreadPersistentRegion.

- Just use CrossThreadPersistent to store any cross-thread pointer. These
CrossThreadPersistent handles are stored in
ThreadState::crossThreadPersistentRegion(), which is per-process not per-thread.

- When we run a marking phase of a per-thread GC, we iterate
ThreadState::crossThreadPersistentRegion() but ignore all CrossThreadPersistent
handles that hold pointers to objects that don't reside in the thread.

+    typedef PersistentBase<T, NonWeakPersistentConfiguration, XThreadPersistentConfiguration> Parent;
+public:
+    XThreadPersistent() : Parent() { }
+    XThreadPersistent(std::nullptr_t) : Parent(nullptr) { }
+    XThreadPersistent(T* raw) : Parent(raw) { }
+    XThreadPersistent(T& raw) : Parent(raw) { }
+    XThreadPersistent(const XThreadPersistent& other) : Parent(other) { }
+    template<typename U>
+    XThreadPersistent(const XThreadPersistent<U>& other) : Parent(other) { }
+    template<typename U>
+    XThreadPersistent(const Member<U>& other) : Parent(other) { }
+    template<typename U>
+    XThreadPersistent(const RawPtr<U>& other) : Parent(other.get()) { }
+
+    template<typename U>
+    XThreadPersistent& operator=(U* other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    XThreadPersistent& operator=(std::nullptr_t)
+    {
+        Parent::operator=(nullptr);
+        return *this;
+    }
+
+    XThreadPersistent& operator=(const XThreadPersistent& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    XThreadPersistent& operator=(const XThreadPersistent<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    XThreadPersistent& operator=(const Member<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    XThreadPersistent& operator=(const RawPtr<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    explicit XThreadPersistent(WTF::HashTableDeletedValueType) : Parent(reinterpret_cast<T*>(-1))
+    {
+    }
+
+    bool isHashTableDeletedValue() const { return *this == reinterpret_cast<T*>(-1); }
+};
+
 template<typename Collection>
 class PersistentHeapCollectionBase : public Collection {
     // We overload the various new and delete operators with using the WTF PartitionAllocator 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::PartitionAllocator);
 public:
     PersistentHeapCollectionBase()
     {
         initialize();
@@ skipping 485 matching lines @@
 #define ThreadSafeRefCountedWillBeGarbageCollected blink::GarbageCollected
 #define ThreadSafeRefCountedWillBeGarbageCollectedFinalized blink::GarbageCollectedFinalized
 #define PersistentWillBeMember blink::Member
 #define CrossThreadPersistentWillBeMember blink::Member
 #define RefPtrWillBePersistent blink::Persistent
 #define RefPtrWillBeRawPtr WTF::RawPtr
 #define RefPtrWillBeMember blink::Member
 #define RefPtrWillBeWeakMember blink::WeakMember
 #define RefPtrWillBeWeakPersistent blink::WeakPersistent
 #define RefPtrWillBeCrossThreadPersistent blink::CrossThreadPersistent
+#define RefPtrWillBeXThreadPersistent blink::XThreadPersistent
 #define RawPtrWillBeMember blink::Member
 #define RawPtrWillBePersistent blink::Persistent
+#define RawPtrWillBeXThreadPersistent blink::XThreadPersistent
 #define RawPtrWillBeWeakMember blink::WeakMember
 #define RawPtrWillBeWeakPersistent blink::WeakPersistent
 #define RawPtrWillBeUntracedMember blink::UntracedMember
 #define OwnPtrWillBeCrossThreadPersistent blink::CrossThreadPersistent
+#define OwnPtrWillBeXThreadPersistent blink::XThreadPersistent
 #define OwnPtrWillBeMember blink::Member
 #define OwnPtrWillBePersistent blink::Persistent
 #define OwnPtrWillBeRawPtr WTF::RawPtr
 #define PassOwnPtrWillBeRawPtr WTF::RawPtr
 #define WeakPtrWillBeCrossThreadWeakPersistent blink::CrossThreadWeakPersistent
 #define WeakPtrWillBeMember blink::Member
 #define WeakPtrWillBeRawPtr WTF::RawPtr
 #define WeakPtrWillBeWeakMember blink::WeakMember
 #define WeakPtrWillBeWeakPersistent blink::WeakPersistent
 #define NoBaseWillBeGarbageCollected blink::GarbageCollected
@@ skipping 65 matching lines @@
 #define ThreadSafeRefCountedWillBeGarbageCollected WTF::ThreadSafeRefCounted
 #define ThreadSafeRefCountedWillBeGarbageCollectedFinalized WTF::ThreadSafeRefCounted
 #define PersistentWillBeMember blink::Persistent
 #define CrossThreadPersistentWillBeMember blink::CrossThreadPersistent
 #define RefPtrWillBePersistent WTF::RefPtr
 #define RefPtrWillBeRawPtr WTF::RefPtr
 #define RefPtrWillBeMember WTF::RefPtr
 #define RefPtrWillBeWeakMember WTF::RefPtr
 #define RefPtrWillBeWeakPersistent WTF::RefPtr
 #define RefPtrWillBeCrossThreadPersistent WTF::RefPtr
+#define RefPtrWillBeXThreadPersistent WTF::RefPtr
 #define RawPtrWillBeMember WTF::RawPtr
 #define RawPtrWillBePersistent WTF::RawPtr
+#define RawPtrWillBeXThreadPersistent WTF::RawPtr
 #define RawPtrWillBeWeakMember WTF::RawPtr
 #define RawPtrWillBeWeakPersistent WTF::RawPtr
 #define RawPtrWillBeUntracedMember WTF::RawPtr
 #define OwnPtrWillBeCrossThreadPersistent WTF::OwnPtr
+#define OwnPtrWillBeXThreadPersistent WTF::OwnPtr
 #define OwnPtrWillBeMember WTF::OwnPtr
 #define OwnPtrWillBePersistent WTF::OwnPtr
 #define OwnPtrWillBeRawPtr WTF::OwnPtr
 #define PassOwnPtrWillBeRawPtr WTF::PassOwnPtr
 #define WeakPtrWillBeCrossThreadWeakPersistent WTF::WeakPtr
 #define WeakPtrWillBeMember WTF::WeakPtr
 #define WeakPtrWillBeRawPtr WTF::WeakPtr
 #define WeakPtrWillBeWeakMember WTF::WeakPtr
 #define WeakPtrWillBeWeakPersistent WTF::WeakPtr
 #define NoBaseWillBeGarbageCollected blink::DummyBase
@@ skipping 395 matching lines @@
     static_assert(sizeof(T), "T must be fully defined");
     using StorageType = T*;
 
     static StorageType wrap(T* value) { return value; }
     static T* unwrap(const StorageType& value) { return value; }
 };
 
 template<typename T>
 struct PointerParamStorageTraits<T*, true> {
     static_assert(sizeof(T), "T must be fully defined");
-    using StorageType = blink::CrossThreadPersistent<T>;
+    using StorageType = blink::XThreadPersistent<T>;
 
     static StorageType wrap(T* value) { return value; }
     static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
 template<typename T>
 struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
     static_assert(sizeof(T), "T must be fully defined");
 };
 
@@ skipping 10 matching lines @@
     static StorageType wrap(const blink::AllowCrossThreadWeakPersistent<T>& value) { return value.value(); }
 
     // Currently assume that the call sites of this unwrap() account for cleared weak references also.
     // TODO(sof): extend WTF::FunctionWrapper call overloading to also handle (CrossThread)WeakPersistent.
     static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
 template<typename T>
 PassRefPtr<T> adoptRef(blink::RefCountedGarbageCollected<T>*) = delete;
 
+template<typename T> struct HashTraits<blink::XThreadPersistent<T>> : SimpleClassHashTraits<blink::XThreadPersistent<T>> {
+    static const bool emptyValueIsZero = false; // Persistent's constructor needs to be called properly.
+
+    // FIXME: The distinction between PeekInType and PassInType is there for
+    // the sake of the reference counting handles. When they are gone the two
+    // types can be merged into PassInType.
+    // FIXME: Implement proper const'ness for iterator types. Requires support
+    // in the marking Visitor.
+    using PeekInType = const blink::XThreadPersistent<T>&;
+    using PassInType = const blink::XThreadPersistent<T>&;
+    using IteratorGetType = blink::XThreadPersistent<T>*;
+    using IteratorConstGetType = const blink::XThreadPersistent<T>*;
+    using IteratorReferenceType = blink::XThreadPersistent<T>&;
+    using IteratorConstReferenceType = const blink::XThreadPersistent<T>&;
+    static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return *x; }
+    static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return *x; }
+    // FIXME: Similarly, there is no need for a distinction between PeekOutType
+    // and PassOutType without reference counting.
+    using PeekOutType = T*;
+    using PassOutType = T*;
+
+    template<typename U>
+    static void store(const U& value, blink::Persistent<T>& storage) { storage = value; }
+
+    static PeekOutType peek(const blink::XThreadPersistent<T>& value) { return value; }
+    static PassOutType passOut(const blink::XThreadPersistent<T>& value) { return value; }
+};
+
+template<typename T> struct PtrHash<blink::XThreadPersistent<T>> : PtrHash<T*> {
+    static unsigned hash(const blink::XThreadPersistent<T>& key) { return PtrHash<T*>::hash(key.get()); }
+    static bool equal(const blink::XThreadPersistent<T>& a, const blink::XThreadPersistent<T>& b) { return a == b; }
+};
+
+template<typename T> struct DefaultHash<blink::XThreadPersistent<T>> {
+    using Hash = PtrHash<blink::XThreadPersistent<T>>;
+};
+
 } // namespace WTF
 
 #endif