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 is called in
+// the object's owner thread, and can access Member<>s to other
+// garbarge-collected objects allocated in the thread.  However we must not
+// allocate new garbage-collected objects, and must not update Member<> and

[haraken, 2014/10/06 01:55:27]

, and => nor

[tkent, 2014/10/06 05:01:43]

Done.

+// Persistent<> pointers.
+//
+// See ThreadState::registerPreFinalizer.
+//
+// Usage:
+//
+// class Foo : GarbageCollected<Foo> {
+//     USING_PRE_FINALIZER(Foo, dispose);
+// public:
+//     Foo() ....
+// private:
+//     void dispose();
+//     Member<Bar> m_bar;
+// };
+//
+// void Foo::dispose()
+// {
+//     m_bar->...
+// }
+#define USING_PRE_FINALIZER(Class, method)   \
+    public: \
+        static bool invokePreFinalier(void* object, Visitor& visitor)   \

[haraken, 2014/10/06 01:55:27]

invokePreFinalier => invokePreFinalizer

[tkent, 2014/10/06 05:01:43]

Done.

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

[haraken, 2014/10/06 01:55:27]

What's this?

[tkent, 2014/10/06 05:01:43]

This is an idiom to make ';' after USING_PRE_FINALIZER() mandatory.  With this
line, the following will cause a compile error
    USING_PRE_FINALIZER(Foo, dispose)
 
This line helps to avoid to have both of |USING_PRE_FINALIZER();| and
|USING_PRE_FINALIZER()|.

+
 // 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-finalizer function of the target object before the

[haraken, 2014/10/06 01:55:27]

a pref-finalizer function => a pre-finalizer

[tkent, 2014/10/06 05:01:43]

Done.

+    // object is destructed. The class T must have USING_PRE_FINALIZER().  The
+    // argument should be |*this|.  Registering a lot of objects affects GC

[haraken, 2014/10/06 01:55:27]

Would it be possible to define registerPreFinalizer/unregisterPreFinalizer on a
GarbageCollected class so that the caller side can avoid passing |*this|?

[tkent, 2014/10/06 05:01:43]

It's not impossible, however I think it's not an improvement.

ThreadState needs to know a specific type information to get
T::invokePreFinalizer address.
If we added these functions to GarbageCollected, we would need to pass address
of T::invokePreFinalizer like:
    registerPreFinalizer(&IDBRequest::invokePreFinalizer);
This looks worse than |*this|.

[haraken, 2014/10/06 05:26:42]

Makes sense.

+    // 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 registerPreFinalizer(T& target)
+    {
+        ASSERT(!m_preFinalizers.contains(&target));
+        ASSERT(!isSweepInProgress());
+        m_preFinalizers.add(&target, &T::invokePreFinalier);
+    }
+    // Cancel above requests.  The argument should be |*this|.  This function is
+    // ignored if it is called in pre-finalizer functions.
+    template<typename T>
+    void unregisterPreFinalizer(T& target)
+    {
+        ASSERT(&T::invokePreFinalier);
+        unregisterPreFinalizerInternal(&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 unregisterPreFinalizerInternal(void*);
+    void invokePreFinalizers(Visitor&);
 
     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_preFinalizers;

[haraken, 2014/10/06 01:55:28]

Can we add an assertion to verify that m_preFinalizers is empty when the thread
shuts down?

[tkent, 2014/10/06 05:01:43]

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