Oilpan: Add support of pre-finalization callback to Oilpan infrastructure.

Source/platform/heap/ThreadState.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 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 ThreadState_h
 #define ThreadState_h
 
 #include "platform/PlatformExport.h"
 #include "platform/heap/AddressSanitizer.h"
 #include "public/platform/WebThread.h"
+#include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/ThreadSpecific.h"
 #include "wtf/Threading.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/Vector.h"
 
-#if ENABLE(GC_PROFILE_HEAP)
-#include "wtf/HashMap.h"
-#endif
-
 namespace blink {
 
 class BaseHeap;
 class BaseHeapPage;
 class FinalizedHeapObjectHeader;
 struct GCInfo;
 class HeapContainsCache;
 class HeapObjectHeader;
 class PageMemory;
 class PersistentNode;
@@ skipping 65 matching lines @@
         class Class;                                                    \
     }                                                                   \
     namespace blink {                                                 \
         template<> struct ThreadingTrait<Namespace::Class> {            \
             static const ThreadAffinity Affinity = AnyThread;           \
         };                                                              \
     }
 
 template<typename U> class ThreadingTrait<const U> : public ThreadingTrait<U> { };
 
+// Declare that a class has a pre-finalizer function.  The function can access
+// other garbarge-collected members.  However we must not allocate

[haraken, 2014/10/03 06:00:32]

Slightly clearer:

(a) The function can access garbage-collected objects allocated on the thread
heap.
(b) The function cannot access garbage-collected objects allocated on other
thread heaps.
(c) The function cannot allocate garbage-collected objects.
(d) The function cannot change an object graph.

(Note related to CL: We already have an assert for (c). Would it be possible to
add an assert for (b) and (d)? I think we can hook Member::operator->,
Member::operator= etc, but I'm a bit afraid that adding an assert to
Member::operator-> etc will unacceptably slow down performance of Debug builds.)

[tkent, 2014/10/03 06:34:01]

(A), (b), (c), and (d) are correct.  I should add them to the code comment.

I also think complexity to detect (b) and (d) would be unacceptable. These
restrictions are same as the existing HashMap<WeakMember<>> pattern, which is
working well now. So documentation would be enough.

[haraken, 2014/10/03 06:39:18]

Agreed.

+// garbage-collected objects, and must not change content of Member<> and
+// Persistent<>.
+// See ThreadState::registerObjectWithPreFinalizer.
+//
+// Usage:
+//
+// class Foo : GarbageCollected<Foo> {
+//     USING_PRE_FINALIZATION_CALLBACK(Foo, dispose);
+// public:
+//     Foo() ....
+// private:
+//     Member<Bar> m_bar;
+// };
+//
+// void Foo::dispose()
+// {
+//     m_bar->...
+// }
+#define USING_PRE_FINALIZATION_CALLBACK(Class, method)   \

[haraken, 2014/10/03 06:00:31]

USING_PRE_FINALIZATION_CALLBACK => USING_PRE_FINALIZER ?

(Another possible name would be USING_NEAR_DEATH_CALLBACK. I don't have a strong
opinion here. V8 is using "near-death" notifications.)

[tkent, 2014/10/06 01:25:53]

Done.

+    public: \
+    static bool willFinalizeDeadGarbageCollectedObject(void* object, Visitor& visitor)   \

[tkent, 2014/10/03 05:34:26]

wrong indentation.   will fix.

[haraken, 2014/10/03 06:00:31]

willFinalizeDeadGarbageCollectedObject => invokePreFinalizer ?

[tkent, 2014/10/03 06:34:01]

Yeah, it's inconsistent with other names in this patch though I wanted to make
this consistent with GarbageCollectedFinalized::finalizeGarbageCollectedObject.
invokePreFinalizerOfGarbageCollectedObject?

[haraken, 2014/10/03 06:39:18]

I don't have a strong opinion here, but I guess invokePreFinalizer would be
enough and consistent with invokePreFinalizers.

[tkent, 2014/10/06 01:25:53]

Done.

+        { \
+            Class* self = reinterpret_cast<Class*>(object); \
+            if (visitor.isAlive(self)) \
+                return false; \
+            self->method(); \
+            return true; \
+        } \
+    private: \
+        void method()

[Erik Corry, 2014/10/03 09:13:26]

To my mind, declaring the method in the macro like this puts more magic in the
macro than it needs to have.  It's not much work to declare the method
explicitly, and makes the code easier to navigate. Otherwise the reader is left
wondering where this 'dispose' method comes from.

If you were willing to fix the name of the 'dispose' method you could probably
remove this ugly macro completely, and replace it with a single templatized
static method outside the classes. That would mean the dispose method needed to
be public, which I think is OK, since it is essentially called from outside the
object (by the GC infrastructure).

[tkent, 2014/10/06 01:25:53]

Removed the hidden declaration.

+
 // List of typed heaps. The list is used to generate the implementation
 // of typed heap related methods.
 //
 // To create a new typed heap add a H(<ClassName>) to the
 // FOR_EACH_TYPED_HEAP macro below.
 #define FOR_EACH_TYPED_HEAP(H)  \
     H(Node)
 
 #define TypedHeapEnumName(Type) Type##Heap,
 #define TypedHeapEnumNameNonFinalized(Type) Type##HeapNonFinalized,
@@ skipping 478 matching lines @@
 
     void getStats(HeapStats&);
     HeapStats& stats() { return m_stats; }
     HeapStats& statsAfterLastGC() { return m_statsAfterLastGC; }
 
     void setupHeapsForTermination();
 
     void registerSweepingTask();
     void unregisterSweepingTask();
 
+    // Request to call a pref-finalize function of the target object before the

[haraken, 2014/10/03 06:00:31]

pre-finalizer

[tkent, 2014/10/06 01:25:53]

Done.

+    // object is destructed. The class T must have
+    // USING_PRE_FINALIZATION_CALLBACK().  The argument should be |*this|.
+    // Registering a lot of objects affects GC performance. We should register
+    // an object only if the object really requires pre-finalizer, and we should
+    // unregister the object if pre-finalizer is unnecessary.
+    template<typename T>
+    void registerObjectWithPreFinalizer(T& target)

[haraken, 2014/10/03 06:00:31]

registerObjectWithPreFinalizer => registerPreFinalizer ?

[tkent, 2014/10/06 01:25:53]

Done.

+    {
+        ASSERT(!m_objectsWithPreFinalizer.contains(&target));

[haraken, 2014/10/03 06:00:31]

Shall we add ASSERT(!isSweepInProgress()) ?

[tkent, 2014/10/06 01:25:53]

Done.

+        m_objectsWithPreFinalizer.add(&target, &T::willFinalizeDeadGarbageCollectedObject);
+    }
+    // Cancel above requests.  The argument should be |*this|.  This function is
+    // ignored if it is called in pre-finalizer functions.
+    template<typename T>
+    void unregisterObjectWithPreFinalizer(T& target)

[haraken, 2014/10/03 06:00:32]

unregisterObjectWithPreFinalizer => unregisterPreFinalizer ?

[tkent, 2014/10/06 01:25:53]

Done.

+    {
+        ASSERT(&T::willFinalizeDeadGarbageCollectedObject);
+        unregisterObjectWithPreFinalizerInternal(&target);
+    }
+
     Mutex& sweepMutex() { return m_sweepMutex; }
 
 private:
     explicit ThreadState();
     ~ThreadState();
 
     friend class SafePointBarrier;
     friend class SafePointAwareMutexLocker;
 
     void enterSafePoint(StackState, void*);
@@ skipping 18 matching lines @@
     // to sweep away any objects that are left on this heap.
     // We assert that nothing must remain after this cleanup.
     // If assertion does not hold we crash as we are potentially
     // in the dangling pointer situation.
     void cleanup();
     void cleanupPages();
 
     void setLowCollectionRate(bool value) { m_lowCollectionRate = value; }
 
     void waitUntilSweepersDone();
+    void unregisterObjectWithPreFinalizerInternal(void*);
+    void invokePreFinalizer(Visitor&);

[haraken, 2014/10/03 06:00:32]

invokePreFinalizer => invokePreFinalizers ?

[tkent, 2014/10/06 01:25:53]

Done.

 
     static WTF::ThreadSpecific<ThreadState*>* s_threadSpecific;
     static SafePointBarrier* s_safePointBarrier;
 
     // This variable is flipped to true after all threads are stoped
     // and outermost GC has started.
     static bool s_inGC;
 
     // We can't create a static member of type ThreadState here
     // because it will introduce global constructor and destructor.
@@ skipping 31 matching lines @@
     bool m_isTerminating;
 
     bool m_lowCollectionRate;
 
     OwnPtr<blink::WebThread> m_sweeperThread;
     int m_numberOfSweeperTasks;
     Mutex m_sweepMutex;
     ThreadCondition m_sweepThreadCondition;
 
     CallbackStack* m_weakCallbackStack;
+    HashMap<void*, bool (*)(void*, Visitor&)> m_objectsWithPreFinalizer;

[haraken, 2014/10/03 06:00:32]

m_objectsWithPreFinalizer => m_preFinalizers ?

[tkent, 2014/10/06 01:25:53]

Done.

 
 #if defined(ADDRESS_SANITIZER)
     void* m_asanFakeStack;
 #endif
 };
 
 template<ThreadAffinity affinity> class ThreadStateFor;
 
 template<> class ThreadStateFor<MainThreadOnly> {
 public:
@@ skipping 116 matching lines @@
     // whether the page is part of a terminting thread or
     // if the page is traced after being terminated (orphaned).
     uintptr_t m_terminating : 1;
     uintptr_t m_tracedAfterOrphaned : 1;
     uintptr_t m_promptlyFreedSize : 17; // == blinkPageSizeLog2
 };
 
 }
 
 #endif // ThreadState_h