Oilpan: support eager tracing of objects when marking.

Source/platform/heap/Heap.cpp

Index: Source/platform/heap/Heap.cpp
diff --git a/Source/platform/heap/Heap.cpp b/Source/platform/heap/Heap.cpp
index a53b497aa0be8dc26ddb55d156f0101e9d23b8d5..3987142b2c77f7729f60f297c709c690ae5583ac 100644
--- a/Source/platform/heap/Heap.cpp
+++ b/Source/platform/heap/Heap.cpp
@@ -572,12 +572,12 @@ static bool isUninitializedMemory(void* objectPointer, size_t objectSize)
 template<>
 void LargeObject<FinalizedHeapObjectHeader>::mark(Visitor* visitor)
 {
-    if (heapObjectHeader()->hasVTable() && !vTableInitialized(payload())) {
-        FinalizedHeapObjectHeader* header = heapObjectHeader();
+    FinalizedHeapObjectHeader* header = heapObjectHeader();
+    if (header->hasVTable() && !vTableInitialized(payload())) {
         visitor->markNoTracing(header);
         ASSERT(isUninitializedMemory(header->payload(), header->payloadSize()));
     } else {
-        visitor->mark(heapObjectHeader(), heapObjectHeader()->traceCallback());
+        visitor->mark(header, header->traceCallback());
     }
 }
 
@@ -1984,17 +1984,14 @@ public:
             Heap::pushTraceCallback(m_markingStack, const_cast<void*>(objectPointer), callback);
     }
 
+    // We need both HeapObjectHeader and FinalizedHeapObjectHeader versions to correctly find the payload.
     virtual void mark(HeapObjectHeader* header, TraceCallback callback) override
     {
-        // We need both the HeapObjectHeader and FinalizedHeapObjectHeader
-        // version to correctly find the payload.
         visitHeader(header, header->payload(), callback);
     }
 
     virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback) override
     {
-        // We need both the HeapObjectHeader and FinalizedHeapObjectHeader
-        // version to correctly find the payload.
         visitHeader(header, header->payload(), callback);
     }
 
@@ -2033,6 +2030,52 @@ public:
         return FinalizedHeapObjectHeader::fromPayload(objectPointer)->isMarked();
     }
 
+    virtual bool ensureMarked(const void* objectPointer) override

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

Shall we flip true/false of the return value? It looks more natural to return
true when ensureMarked succeeded in marking.

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

Can we share the implementation of ensureMarked with Heap::visitHeader()?

Basically ensureMarked needs to do the same thing as Heap::visitHeader(), except
that it returns true/false instead of calling pushTraceCallback().

[sof, 2014/11/28 12:05:08]

I would prefer not to do that exercise; there's trivial amounts of logic
involved, and if you somehow generalize visitHeader() (have it return a bool
result), you risk slowing down your inner loop when marking by shuffling return
values into registers (or onto the stack) for no good reason, as it is ignored
most of the time.

[sof, 2014/11/28 12:05:08]

Meaning is still not self-evident, but flipped.

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

Sounds reasonable. Given that the code that ensureMarked is missing against
visitHeader is just code for heap profiling, it would be OK to omit it at the
moment.

+    {
+        if (!objectPointer)
+            return true;
+#if ENABLE(ASSERT)
+        if (isMarked(objectPointer))
+            return true;
+
+        markNoTracing(objectPointer);
+#else
+        FinalizedHeapObjectHeader* header =
+            FinalizedHeapObjectHeader::fromPayload(objectPointer);
+        if (header->isMarked())
+            return true;
+        header->mark();
+#endif
+        return false;
+    }
+
+#if ENABLE(ASSERT)

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

Would you describe why we need ENABLE(ASSERT) / no ENABLE(ASSERT) version?

[sof, 2014/11/28 12:05:08]

A debug-specific version is provided essentially because of the asserts (and GC
profile marking support) that visitHeader() performs, which markNoTracing()
bottoms out in.

3-4 method calls are reqd to get to visitHeader(), so I didn't want to risk any
inlining machinery pointlessly getting in the way in a release build.

[kouhei (in TOK), 2014/12/02 00:41:58]

Thanks for the explanation. Would you add a comment for this?

[sof, 2014/12/02 09:52:15]

Certainly, done.

+#define DEFINE_ENSURE_MARKED_METHOD(Type)                                                       \
+    virtual bool ensureMarked(const Type* objectPointer) override                               \
+    {                                                                                           \
+        if (!objectPointer)                                                                     \
+            return true;                                                                        \
+        COMPILE_ASSERT(!NeedsAdjustAndMark<Type>::value, CanOnlyUseIsMarkedOnNonAdjustedTypes); \
+        if (isMarked(objectPointer))                                                            \
+            return true;                                                                        \
+        markNoTracing(objectPointer);                                                           \
+        return false;                                                                           \
+    }
+#else
+#define DEFINE_ENSURE_MARKED_METHOD(Type)                          \
+    virtual bool ensureMarked(const Type* objectPointer) override  \
+    {                                                              \
+        if (!objectPointer)                                        \
+            return true;                                           \
+        HeapObjectHeader* header =                                 \
+            HeapObjectHeader::fromPayload(objectPointer);          \
+        if (header->isMarked())                                    \
+            return true;                                           \
+        header->mark();                                            \
+        return false;                                              \
+    }
+#endif
+
     // This macro defines the necessary visitor methods for typed heaps
 #define DEFINE_VISITOR_METHODS(Type)                                              \
     virtual void mark(const Type* objectPointer, TraceCallback callback) override \
@@ -2046,7 +2089,8 @@ public:
     virtual bool isMarked(const Type* objectPointer) override                     \
     {                                                                             \
         return HeapObjectHeader::fromPayload(objectPointer)->isMarked();          \
-    }
+    }                                                                             \
+    DEFINE_ENSURE_MARKED_METHOD(Type)
 
     FOR_EACH_TYPED_HEAP(DEFINE_VISITOR_METHODS)
 #undef DEFINE_VISITOR_METHODS