[wrapper-tracing] Reduce marking overhead: Tri-color marking without 3 colors

third_party/WebKit/Source/platform/heap/GarbageCollected.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef GarbageCollected_h
 #define GarbageCollected_h
 
 #include "platform/heap/ThreadState.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
@@ skipping 59 matching lines @@
 // Note that this is only enabled for Member<B>. For Member<A> which we can
 // compute the object header addr statically, this dynamic dispatch is not used.
 //
 class PLATFORM_EXPORT GarbageCollectedMixin {
  public:
   typedef int IsGarbageCollectedMixinMarker;
   virtual void adjustAndMark(Visitor*) const = 0;
   virtual void trace(Visitor*) {}
   virtual void adjustAndMark(InlinedGlobalMarkingVisitor) const = 0;
   virtual void trace(InlinedGlobalMarkingVisitor);
-  virtual void adjustAndMarkWrapper(const WrapperVisitor*) const = 0;
+  virtual void adjustAndFullyMarkAndTraceWrapper(
+      const WrapperVisitor*) const = 0;
+  virtual void adjustAndMarkWrapperHeaderOnly(const WrapperVisitor*) const = 0;
+  virtual void adjustAndFinishMarkAndTraceMarkedWrapper(
+      const WrapperVisitor*) const = 0;
   virtual bool isHeapObjectAlive() const = 0;
   virtual HeapObjectHeader* adjustAndGetHeapObjectHeader() const = 0;
 };
 
 #define DEFINE_GARBAGE_COLLECTED_MIXIN_METHODS(VISITOR, TYPE)                 \
  public:                                                                      \
   void adjustAndMark(VISITOR visitor) const override {                        \
     typedef WTF::IsSubclassOfTemplate<typename std::remove_const<TYPE>::type, \
                                       blink::GarbageCollected>                \
         IsSubclassOfGarbageCollected;                                         \
     static_assert(                                                            \
         IsSubclassOfGarbageCollected::value,                                  \
         "only garbage collected objects can have garbage collected mixins");  \
     if (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);                           \
   }                                                                           \
                                                                               \
  private:
 
-#define DEFINE_GARBAGE_COLLECTED_MIXIN_WRAPPER_METHODS(TYPE)                  \
- public:                                                                      \
-  void adjustAndMarkWrapper(const WrapperVisitor* visitor) const override {   \
-    typedef WTF::IsSubclassOfTemplate<typename std::remove_const<TYPE>::type, \
-                                      blink::GarbageCollected>                \
-        IsSubclassOfGarbageCollected;                                         \
-    static_assert(                                                            \
-        IsSubclassOfGarbageCollected::value,                                  \
-        "only garbage collected objects can have garbage collected mixins");  \
-    AdjustAndMarkTrait<TYPE>::markWrapper(visitor,                            \
-                                          static_cast<const TYPE*>(this));    \
-  }                                                                           \
-  HeapObjectHeader* adjustAndGetHeapObjectHeader() const override {           \
-    typedef WTF::IsSubclassOfTemplate<typename std::remove_const<TYPE>::type, \
-                                      blink::GarbageCollected>                \
-        IsSubclassOfGarbageCollected;                                         \
-    static_assert(                                                            \
-        IsSubclassOfGarbageCollected::value,                                  \
-        "only garbage collected objects can have garbage collected mixins");  \
-    return AdjustAndMarkTrait<TYPE>::heapObjectHeader(                        \
-        static_cast<const TYPE*>(this));                                      \
-  }                                                                           \
-                                                                              \
+#define DEFINE_GARBAGE_COLLECTED_MIXIN_WRAPPER_METHODS(TYPE)                   \
+ private:                                                                      \
+  typedef WTF::IsSubclassOfTemplate<typename std::remove_const<TYPE>::type,    \
+                                    blink::GarbageCollected>                   \
+      IsSubclassOfGarbageCollected;                                            \
+                                                                               \
+ public:                                                                       \
+  void adjustAndFullyMarkAndTraceWrapper(const WrapperVisitor* visitor)        \

[Michael Lippautz, 2016/12/20 15:10:30]

Ideally we could use covariant return types here. E.g. have something like
  TYPE* castToBase() override;
which would be the only method needed here.

Since we don't have a common supertype though (GarbageCollected<A> !=
GarbageCollected<B>) I do not (yet) see how to do it.

+      const override {                                                         \
+    static_assert(                                                             \
+        IsSubclassOfGarbageCollected::value,                                   \
+        "only garbage collected objects can have garbage collected mixins");   \
+    return AdjustAndMarkTrait<TYPE>::fullyMarkAndTraceWrapper(                 \
+        visitor, static_cast<const TYPE*>(this));                              \
+  }                                                                            \
+  void adjustAndMarkWrapperHeaderOnly(const WrapperVisitor* visitor)           \
+      const override {                                                         \
+    static_assert(                                                             \
+        IsSubclassOfGarbageCollected::value,                                   \
+        "only garbage collected objects can have garbage collected mixins");   \
+    return AdjustAndMarkTrait<TYPE>::markWrapperHeaderOnly(                    \
+        visitor, static_cast<const TYPE*>(this));                              \
+  }                                                                            \
+  void adjustAndFinishMarkAndTraceMarkedWrapper(const WrapperVisitor* visitor) \
+      const override {                                                         \
+    static_assert(                                                             \
+        IsSubclassOfGarbageCollected::value,                                   \
+        "only garbage collected objects can have garbage collected mixins");   \
+    AdjustAndMarkTrait<TYPE>::finishMarkAndTraceMarkedWrapper(                 \
+        visitor, static_cast<const TYPE*>(this));                              \
+  }                                                                            \
+  HeapObjectHeader* adjustAndGetHeapObjectHeader() const override {            \
+    static_assert(                                                             \
+        IsSubclassOfGarbageCollected::value,                                   \
+        "only garbage collected objects can have garbage collected mixins");   \
+    return AdjustAndMarkTrait<TYPE>::heapObjectHeader(                         \
+        static_cast<const TYPE*>(this));                                       \
+  }                                                                            \
+                                                                               \
  private:
 
 // A C++ object's vptr will be initialized to its leftmost base's vtable after
 // the constructors of all its subclasses have run, so if a subclass constructor
 // tries to access any of the vtbl entries of its leftmost base prematurely,
 // it'll find an as-yet incorrect vptr and fail. Which is exactly what a
 // garbage collector will try to do if it tries to access the leftmost base
 // while one of the subclass constructors of a GC mixin object triggers a GC.
 // It is consequently not safe to allow any GCs while these objects are under
 // (sub constructor) construction.
@@ skipping 186 matching lines @@
   static FalseType isSizeofKnown(...);
   static T& t;
 
  public:
   static const bool value = sizeof(TrueType) == sizeof(isSizeofKnown(&t));
 };
 
 }  // namespace blink
 
 #endif