Oilpan: support eager tracing of objects when marking.

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 169 matching lines @@
 #if ENABLE(ASSERT)
     static void checkGCInfo(Visitor* visitor, const T* t)
     {
         DefaultTraceTrait<T>::checkGCInfo(visitor, t);
     }
 #endif
 };
 
 template<typename T> class TraceTrait<const T> : public TraceTrait<T> { };
 
+// If TraceEagerlyTrait<T>::value is true, then the marker thread should
+// invoke trace() on unmarked objects deriving from class T right away,
+// and not queue its trace callback on the marker stack.
+template<typename T> class TraceEagerlyTrait;
+
+// Specific template specializations of TraceEagerlyTrait<T> can be used
+// to declare that eager tracing should always be used when tracing over
+// GCed objects with class type T. If the trait's boolean 'value' is
+// mapped to 'true' that is; declare it as 'false' to disable eager tracing.
+//
+// Should you want to declare that a class T and all its derived objects,
+// should all be eagerly traced - regardless of the particular class type
+// they end up being traced over - make T derive/inherit from the empty
+// class TraceEagerly.
+//
+// To express the opposite, that a class T and its derived classes should
+// never be eagerly traced, use TraceNonEagerly. This only makes sense
+// if enable eager tracing by default (see ENABLE_EAGER_TRACING_BY_DEFAULT
+// below.)
+class TraceEagerly { };
+class TraceNonEagerly { };
+
+// If ENABLE_EAGER_TRACING_BY_DEFAULT is set to 1, GCed objects will
+// be eagerly traced by default. A class type can opt out by declaring
+// a TraceEagerlyTrait<> specialization, mapping the value to 'false'
+// (see the WILL_NOT_BE_EAGERLY_TRACED() macro below), or derive
+// from the TraceNonEagerly class.
+#define ENABLE_EAGER_TRACING_BY_DEFAULT 0
+
+// DISABLE_ALL_EAGER_TRACING provides the "kill switch" for eager
+// tracing; setting it to 1 will disable the use of eager tracing
+// entirely. That is, eager tracing is disabled even if traits have
+// been declared or types derive from TraceEagerly.
+#define DISABLE_ALL_EAGER_TRACING 0
+
+// If TraceEagerlyTrait<T>::value is true, then the marker thread should
+// invoke trace() on unmarked objects deriving from class T right away,
+// and not queue its trace callback on the marker stack.
+template<typename T>
+class TraceEagerlyTrait {
+    typedef typename WTF::RemoveConst<T>::Type NonConstType;
+    typedef WTF::IsSubclass<NonConstType, TraceEagerly> TraceEagerlySubclass;
+    typedef WTF::IsSubclass<NonConstType, TraceNonEagerly> TraceNonEagerlySubclass;
+public:
+    static const bool value = (DISABLE_ALL_EAGER_TRACING || TraceNonEagerlySubclass::value) ? false : (ENABLE_EAGER_TRACING_BY_DEFAULT || TraceEagerlySubclass::value);
+};
+
+template<typename T>
+class TraceEagerlyTrait<Member<T>> {
+public:
+    static const bool value = TraceEagerlyTrait<T>::value;
+};
+
+template<typename T>
+class TraceEagerlyTrait<WeakMember<T>> {
+public:
+    static const bool value = TraceEagerlyTrait<T>::value;
+};
+
+#if ENABLE(OILPAN)
+#define WILL_BE_EAGERLY_TRACED(Type)        \
+template<>                                  \
+class TraceEagerlyTrait<Type> {             \
+public:                                     \
+    static const bool value = true;         \
+}
+#define WILL_NOT_BE_EAGERLY_TRACED(Type)    \
+template<>                                  \
+class TraceEagerlyTrait<Type> {             \
+public:                                     \
+    static const bool value = false;        \
+}
+#else
+#define WILL_BE_EAGERLY_TRACED(Type)
+#define WILL_NOT_BE_EAGERLY_TRACED(Type)
+#endif
+
+// Set to 1 if you want collections to be eagerly traced regardless
+// of whether the elements are eagerly traceable or not.
+#define ENABLE_EAGER_HEAP_COLLECTION_TRACING ENABLE_EAGER_TRACING_BY_DEFAULT
+
+#if ENABLE_EAGER_HEAP_COLLECTION_TRACING
+#define IS_EAGERLY_TRACED_HEAP_COLLECTION(Type) true
+#else
+#define IS_EAGERLY_TRACED_HEAP_COLLECTION(Type) TraceEagerlyTrait<Type>::value
+#endif
+
 template<typename Collection>
 struct OffHeapCollectionTraceTrait;
 
 template<typename T>
 struct ObjectAliveTrait {
     static bool isHeapObjectAlive(Visitor*, T*);
 };
 
 // Visitor is used to traverse the Blink object graph. Used for the
 // marking phase of the mark-sweep garbage collector.
@@ skipping 122 matching lines @@
     template<typename T> void trace(const WeakPtr<T>&) { }
 #endif
 
     // 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;
+
+    template<typename T>void markNoTracing(const T* pointer) { mark(pointer, reinterpret_cast<TraceCallback>(0)); }

[kouhei (in TOK), 2014/11/28 01:00:57]

insert space.

[sof, 2014/12/01 10:59:54]

Done.

     void markNoTracing(const void* pointer) { mark(pointer, reinterpret_cast<TraceCallback>(0)); }
     void markNoTracing(HeapObjectHeader* header) { mark(header, reinterpret_cast<TraceCallback>(0)); }
     void markNoTracing(FinalizedHeapObjectHeader* header) { mark(header, reinterpret_cast<TraceCallback>(0)); }
 
     // Used to mark objects during conservative scanning.
     virtual void mark(HeapObjectHeader*, TraceCallback) = 0;
     virtual void mark(FinalizedHeapObjectHeader*, TraceCallback) = 0;
 
     // Used to delay the marking of objects until the usual marking
     // including emphemeron iteration is done. This is used to delay
@@ skipping 45 matching lines @@
     {
         registerWeakCell(reinterpret_cast<void**>(cell), &handleWeakCell<T>);
     }
 
     virtual void registerWeakTable(const void*, EphemeronCallback, EphemeronCallback) = 0;
 #if ENABLE(ASSERT)
     virtual bool weakTableRegistered(const void*) = 0;
 #endif
 
     virtual bool isMarked(const void*) = 0;
+    virtual bool ensureMarked(const void*) = 0;
 
     template<typename T> inline bool isAlive(T* obj)
     {
         // Check that we actually know the definition of T when tracing.
         COMPILE_ASSERT(sizeof(T), WeNeedToKnowTheDefinitionOfTheTypeWeAreTracing);
         // The strongification of collections relies on the fact that once a
         // collection has been strongified, there is no way that it can contain
         // non-live entries, so no entries will be removed. Since you can't set
         // the mark bit on a null pointer, that means that null pointers are
         // always 'alive'.
         if (!obj)
             return true;
         return ObjectAliveTrait<T>::isHeapObjectAlive(this, obj);
     }
     template<typename T> inline bool isAlive(const Member<T>& member)
     {
         return isAlive(member.get());
     }
     template<typename T> inline bool isAlive(RawPtr<T> ptr)
     {
         return isAlive(ptr.get());
     }
 
 #if ENABLE(ASSERT)
     void checkGCInfo(const void*, const GCInfo*);
 #endif
 
     // Macro to declare methods needed for each typed heap.
-#define DECLARE_VISITOR_METHODS(Type)                                  \
-    DEBUG_ONLY(void checkGCInfo(const Type*, const GCInfo*);)          \
-    virtual void mark(const Type*, TraceCallback) = 0;                 \
-    virtual bool isMarked(const Type*) = 0;
+#define DECLARE_VISITOR_METHODS(Type)                            \
+    DEBUG_ONLY(void checkGCInfo(const Type*, const GCInfo*);)    \
+    virtual void mark(const Type*, TraceCallback) = 0;           \
+    virtual bool isMarked(const Type*) = 0;                      \
+    virtual bool ensureMarked(const Type*) = 0;
 
     FOR_EACH_TYPED_HEAP(DECLARE_VISITOR_METHODS)
 #undef DECLARE_VISITOR_METHODS
 
 #if ENABLE(GC_PROFILE_MARKING)
     void setHostInfo(void* object, const String& name)
     {
         m_hostObject = object;
         m_hostName = name;
     }
@@ skipping 56 matching lines @@
 
 template<typename T>
 class DefaultTraceTrait<T, false> {
 public:
     static void mark(Visitor* visitor, const T* t)
     {
         // Default mark method of the trait just calls the two-argument mark
         // method on the visitor. The second argument is the static trace method
         // of the trait, which by default calls the instance method
         // trace(Visitor*) on the object.
+        //
+        // If trait allows it, invoke trace callback right here on unmarked objects.
+        if (!DISABLE_ALL_EAGER_TRACING && TraceEagerlyTrait<T>::value) {
+            if (!visitor->ensureMarked(t))
+                TraceTrait<T>::trace(visitor, const_cast<T*>(t));

[haraken, 2014/11/28 05:20:05]

Just recursively tracing an object is not enough for correctness. Here we need
the same logic as Heap::popAndInvokeTraceCallback() (e.g., checking
page->terminating etc). It would be great if we could share the implementation
with Heap::popAndInvokeTraceCallback().

[haraken, 2014/11/28 12:39:27]

Are you going to address this one? Or is it not a concern?

[sof, 2014/11/28 12:44:27]

I need to make progress on other fronts right now. But it is a concern & I will
add the required cross-heap bailout check (to ensureMarked, I think.)

[sof, 2014/12/01 10:59:54]

Now addressed, but a gnarlier issue to get right.

i.e., the trace-needed check has now been moved up before pushing the trace
callback onto the marking stack. At the cost of having to check a flag -- I
don't see a way around that without having a separate marking visitor for
thread-local markings. Let me know what you think.

+            return;
+        }
         visitor->mark(const_cast<T*>(t), &TraceTrait<T>::trace);
     }
 
 #if ENABLE(ASSERT)
     static void checkGCInfo(Visitor* visitor, const T* t)
     {
         visitor->checkGCInfo(const_cast<T*>(t), GCInfoTrait<T>::get());
     }
 #endif
 };
@@ skipping 70 matching lines @@
 
 class PLATFORM_EXPORT GarbageCollectedMixin {
 public:
     virtual void adjustAndMark(Visitor*) const = 0;
     virtual bool isHeapObjectAlive(Visitor*) const = 0;
     virtual void trace(Visitor*) { }
 };
 
 #define USING_GARBAGE_COLLECTED_MIXIN(TYPE) \
 public: \
-    virtual void adjustAndMark(blink::Visitor* visitor) const override    \
+    virtual void adjustAndMark(blink::Visitor* visitor) const override \
     { \
         typedef WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<TYPE>::Type, blink::GarbageCollected> IsSubclassOfGarbageCollected; \
-        COMPILE_ASSERT(IsSubclassOfGarbageCollected::value, OnlyGarbageCollectedObjectsCanHaveGarbageCollectedMixins); \
+        COMPILE_ASSERT(IsSubclassOfGarbageCollected::value, OnlyGarbageCollectedObjectsCanHaveGarbageCollectedMixins);                  \
+        if (!DISABLE_ALL_EAGER_TRACING && TraceEagerlyTrait<TYPE>::value) {             \
+            if (!visitor->ensureMarked(static_cast<const TYPE*>(this)))                 \
+                TraceTrait<TYPE>::trace(visitor, const_cast<TYPE*>(this));              \
+            return;                                                                     \
+        }                                                                               \
         visitor->mark(static_cast<const TYPE*>(this), &blink::TraceTrait<TYPE>::trace); \
     } \
-    virtual bool isHeapObjectAlive(blink::Visitor* visitor) const override  \
+    virtual bool isHeapObjectAlive(blink::Visitor* visitor) const override              \
     { \
         return visitor->isAlive(this); \
     } \
 private:
 
 #if ENABLE(OILPAN)
 #define WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(TYPE) USING_GARBAGE_COLLECTED_MIXIN(TYPE)
 #else
 #define WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(TYPE)
 #endif
@@ skipping 43 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif