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

third_party/WebKit/Source/platform/heap/TraceTraits.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 TraceTraits_h
 #define TraceTraits_h
 
 #include "platform/heap/GCInfo.h"
 #include "platform/heap/Heap.h"
 #include "platform/heap/InlinedGlobalMarkingVisitor.h"
@@ skipping 29 matching lines @@
 class WeakPersistent;
 
 template <typename T, bool = NeedsAdjustAndMark<T>::value>
 class AdjustAndMarkTrait;
 
 template <typename T>
 class AdjustAndMarkTrait<T, false> {
   STATIC_ONLY(AdjustAndMarkTrait);
 
  public:
-  static void markWrapper(const WrapperVisitor* visitor, const T* t) {
+  static void fullyMarkAndTraceWrapper(const WrapperVisitor* visitor,
+                                       const T* t) {

[Hannes Payer (out of office), 2016/12/20 15:30:33]

DCHECK(!heapObjectHeader(t)->isWrapperHeaderMarked());

[Michael Lippautz, 2016/12/20 15:57:23]

This one cannot be done, as it is used when we cannot eagerly process an object
in mixin construction. It has to stay conditional.

     if (visitor->markWrapperHeader(heapObjectHeader(t))) {
       visitor->markWrappersInAllWorlds(t);
       visitor->dispatchTraceWrappers(t);
     }
   }
+  static void markWrapperHeaderOnly(const WrapperVisitor* visitor, const T* t) {

[Hannes Payer (out of office), 2016/12/20 15:30:33]

DCHECK(!heapObjectHeader(t)->isWrapperHeaderMarked());

[Michael Lippautz, 2016/12/20 15:57:23]

Done.

+    visitor->markWrapperHeader(heapObjectHeader(t));
+  }
+  static void finishMarkAndTraceMarkedWrapper(const WrapperVisitor* visitor,
+                                              const T* t) {
+    CHECK(heapObjectHeader(t)->isWrapperHeaderMarked());

[Hannes Payer (out of office), 2016/12/20 15:30:34]

s/CHECK/DCHECK/

[Michael Lippautz, 2016/12/20 15:57:23]

Most of the assertions will be CHECKs until this is stabilized a bit more.

+    visitor->markWrappersInAllWorlds(t);
+    visitor->dispatchTraceWrappers(t);
+  }
   static HeapObjectHeader* heapObjectHeader(const T* t) {
     return HeapObjectHeader::fromPayload(t);
   }
 
   template <typename VisitorDispatcher>
   static void mark(VisitorDispatcher visitor, const T* t) {
 #if ENABLE(ASSERT)
     assertObjectHasGCInfo(const_cast<T*>(t), GCInfoTrait<T>::index());
 #endif
     // Default mark method of the trait just calls the two-argument mark
@@ skipping 26 matching lines @@
     }
     visitor->mark(const_cast<T*>(t), &TraceTrait<T>::trace);
   }
 };
 
 template <typename T>
 class AdjustAndMarkTrait<T, true> {
   STATIC_ONLY(AdjustAndMarkTrait);
 
  public:
-  static void markWrapper(const WrapperVisitor* visitor, const T* t) {
-    t->adjustAndMarkWrapper(visitor);
+  static void fullyMarkAndTraceWrapper(const WrapperVisitor* visitor,
+                                       const T* t) {
+    t->adjustAndFullyMarkAndTraceWrapper(visitor);
+  }
+  static void markWrapperHeaderOnly(const WrapperVisitor* visitor, const T* t) {
+    t->adjustAndMarkWrapperHeaderOnly(visitor);
+  }
+  static void finishMarkAndTraceMarkedWrapper(const WrapperVisitor* visitor,
+                                              const T* t) {
+    t->adjustAndFinishMarkAndTraceMarkedWrapper(visitor);
   }
   static HeapObjectHeader* heapObjectHeader(const T* t) {
     return t->adjustAndGetHeapObjectHeader();
   }
 
   template <typename VisitorDispatcher>
   static void mark(VisitorDispatcher visitor, const T* self) {
     if (!self)
       return;
 
@@ skipping 84 matching lines @@
 // to the start of the object in the Blink garbage-collected heap. In
 // that case the pointer has to be adjusted before marking.
 template <typename T>
 class TraceTrait {
   STATIC_ONLY(TraceTrait);
 
  public:
   static void trace(Visitor*, void* self);
   static void trace(InlinedGlobalMarkingVisitor, void* self);
 
-  static void markWrapper(const WrapperVisitor* visitor, const void* t) {
+  static void fullyMarkAndTraceWrapper(const WrapperVisitor* visitor,
+                                       const void* t) {
     static_assert(CanTraceWrappers<T>::value,
                   "T should be able to trace wrappers. See "
                   "dispatchTraceWrappers in WrapperVisitor.h");
-    AdjustAndMarkTrait<T>::markWrapper(visitor, reinterpret_cast<const T*>(t));
+    return AdjustAndMarkTrait<T>::fullyMarkAndTraceWrapper(
+        visitor, reinterpret_cast<const T*>(t));
+  }
+  static void markWrapperHeaderOnly(const WrapperVisitor* visitor,
+                                    const void* t) {
+    static_assert(CanTraceWrappers<T>::value,
+                  "T should be able to trace wrappers. See "
+                  "dispatchTraceWrappers in WrapperVisitor.h");
+    return AdjustAndMarkTrait<T>::markWrapperHeaderOnly(
+        visitor, reinterpret_cast<const T*>(t));
+  }
+  static void finishMarkAndTraceMarkedWrapper(const WrapperVisitor* visitor,
+                                              const void* t) {
+    static_assert(CanTraceWrappers<T>::value,
+                  "T should be able to trace wrappers. See "
+                  "dispatchTraceWrappers in WrapperVisitor.h");
+    AdjustAndMarkTrait<T>::finishMarkAndTraceMarkedWrapper(
+        visitor, reinterpret_cast<const T*>(t));
   }
   static HeapObjectHeader* heapObjectHeader(const void* t) {
     static_assert(CanTraceWrappers<T>::value,
                   "T should be able to trace wrappers. See "
                   "dispatchTraceWrappers in WrapperVisitor.h");
     return AdjustAndMarkTrait<T>::heapObjectHeader(
         reinterpret_cast<const T*>(t));
   }
 
   template <typename VisitorDispatcher>
@@ skipping 549 matching lines @@
     // since iterating over the hash table backing will find the whole
     // chain.
     visitor->markNoTracing(node);
     return false;
   }
 };
 
 }  // namespace WTF
 
 #endif