[NotForCommit] inline ensureMarked.

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 173 matching lines @@
     }
 #endif
 };
 
 template<typename T> class TraceTrait<const T> : public TraceTrait<T> { };
 
 // 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.)
-#define ENABLE_EAGER_TRACING_BY_DEFAULT 0
+#define ENABLE_EAGER_TRACING_BY_DEFAULT 1
 
 // 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.
 #define DISABLE_ALL_EAGER_TRACING 0
 
 // If TraceEagerlyTrait<T>::value is true, then the marker thread should
 // invoke trace() on not-yet-marked objects deriving from class T right
 // away, and not queue their trace callbacks on its marker stack.
@@ skipping 52 matching lines @@
 #endif
 
 template<typename Collection>
 struct OffHeapCollectionTraceTrait;
 
 template<typename T>
 struct ObjectAliveTrait {
     static bool isHeapObjectAlive(Visitor*, T*);
 };
 
+enum MarkingMode {
+    GlobalMarking,
+    ThreadLocalMarking,
+};
+
 // Visitor is used to traverse the Blink object graph. Used for the
 // marking phase of the mark-sweep garbage collector.
 //
 // Pointers are marked and pushed on the marking stack by calling the
 // |mark| method with the pointer as an argument.
 //
 // Pointers within objects are traced by calling the |trace| methods
 // with the object as an argument. Tracing objects will mark all of the
 // contained pointers and push them on the marking stack.
 class PLATFORM_EXPORT Visitor {
 public:
+    Visitor(MarkingMode mode) : m_mode(mode) {}
     virtual ~Visitor() { }
 
     template<typename T>
     static void verifyGarbageCollectedIfMember(T*)
     {
     }
 
     template<typename T>
     static void verifyGarbageCollectedIfMember(Member<T>* t)
     {
@@ skipping 170 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;
+
+    bool ensureMarked(const void*);
 
     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'.
@@ skipping 11 matching lines @@
     }
 
 #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;                      \
-    virtual bool ensureMarked(const Type*) = 0;
+    virtual bool isMarked(const Type*) = 0; \
+    bool ensureMarked(const Type*);
 
     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;
     }
 #endif
 
-    inline bool canTraceEagerly() const { return m_traceDepth < kMaxEagerTraceDepth; }
-    inline void incrementTraceDepth() { m_traceDepth++; }
-    inline void decrementTraceDepth() { ASSERT(m_traceDepth > 0); m_traceDepth--; }
-
 protected:
-    Visitor()
-        : m_traceDepth(0)
-    {
-    }
-
     virtual void registerWeakCell(void**, WeakPointerCallback) = 0;
 #if ENABLE(GC_PROFILE_MARKING)
     void* m_hostObject;
     String m_hostName;
 #endif
 
 private:
     template<typename T>
     static void handleWeakCell(Visitor* self, void* obj)
     {
         T** cell = reinterpret_cast<T**>(obj);
         if (*cell && !self->isAlive(*cell))
             *cell = 0;
     }
 
-    // The maximum depth of eager, unrolled trace() calls that is
-    // considered safe and allowed.
-    const int kMaxEagerTraceDepth = 100;
-
-    int m_traceDepth;
+    MarkingMode m_mode;
 };
 
 // We trace vectors by using the trace trait on each element, which means you
 // can have vectors of general objects (not just pointers to objects) that can
 // be traced.
 template<typename T, size_t N>
 struct OffHeapCollectionTraceTrait<WTF::Vector<T, N, WTF::DefaultAllocator> > {
     typedef WTF::Vector<T, N, WTF::DefaultAllocator> Vector;
 
     static void trace(Visitor* visitor, const Vector& vector)
@@ skipping 33 matching lines @@
     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 the trait allows it, invoke the trace callback right here on the
         // not-yet-marked object.
         if (!DISABLE_ALL_EAGER_TRACING && TraceEagerlyTrait<T>::value) {
-            // Protect against too deep trace call chains, and the
-            // unbounded system stack usage they can bring about.
-            //
-            // Assert against deep stacks so as to flush them out,
-            // but test and appropriately handle them should they occur
-            // in release builds.
-            ASSERT(visitor->canTraceEagerly());
-            if (LIKELY(visitor->canTraceEagerly())) {
-                if (visitor->ensureMarked(t)) {
-                    visitor->incrementTraceDepth();
-                    TraceTrait<T>::trace(visitor, const_cast<T*>(t));
-                    visitor->decrementTraceDepth();
-                }
-                return;
-            }
+            if (visitor->ensureMarked(t))
+                TraceTrait<T>::trace(visitor, const_cast<T*>(t));
+            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 146 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif