Implement Visitor::isGlobalMarkingVisitor

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 246 matching lines @@
 // 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:
+    enum VisitorType {
+        GlobalMarkingVisitorType,
+        GenericVisitorType,
+    };
+
     virtual ~Visitor() { }
 
     // One-argument templated mark method. This uses the static type of
     // the argument to get the TraceTrait. By default, the mark method
     // of the TraceTrait just calls the virtual two-argument mark method on this
     // visitor, where the second argument is the static trace method of the trait.
     template<typename T>
     void mark(T* t)
     {
         if (!t)
@@ skipping 247 matching lines @@
     {
         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--; }
 
+    inline bool isGlobalMarkingVisitor() const { return m_isGlobalMarkingVisitor; }
+
 protected:
-    Visitor()
+    Visitor(VisitorType type)

[haraken, 2014/12/16 06:53:30]

Add explicit

[kouhei (in TOK), 2014/12/16 06:58:27]

Done.

         : m_traceDepth(0)
+        , m_isGlobalMarkingVisitor(type == GlobalMarkingVisitorType)
     {
     }
 
     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;
+    bool m_isGlobalMarkingVisitor;

[haraken, 2014/12/16 06:53:29]

Can we store m_visitorType, instead of m_isGlobalMarkingVisitor?

[kouhei (in TOK), 2014/12/16 06:58:27]

"type == GlobalMarkingVisitorType" is slower than m_isGlobalMarkingVisitor, so
I'd prefer just a bool here, but it might be a premature optimization.

 };
 
 // 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 213 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif