Oilpan: support eager tracing of objects when marking.

Source/platform/heap/Heap.cpp

 /*
  * 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 554 matching lines @@
         if (objectFields[i] != 0)
             return false;
     }
     return true;
 }
 #endif
 
 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());
     }
 }
 
 template<>
 void LargeObject<HeapObjectHeader>::mark(Visitor* visitor)
 {
     ASSERT(gcInfo());
     if (gcInfo()->hasVTable() && !vTableInitialized(payload())) {
         HeapObjectHeader* header = heapObjectHeader();
         visitor->markNoTracing(header);
@@ skipping 1386 matching lines @@
             result.storedValue->value.add(reinterpret_cast<uintptr_t>(objectPointer));
         }
         ObjectGraph::AddResult result = objectGraph().add(reinterpret_cast<uintptr_t>(objectPointer), std::make_pair(reinterpret_cast<uintptr_t>(m_hostObject), m_hostName));
         ASSERT(result.isNewEntry);
         // fprintf(stderr, "%s[%p] -> %s[%p]\n", m_hostName.ascii().data(), m_hostObject, className.ascii().data(), objectPointer);
 #endif
         if (callback)
             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);
     }
 
     virtual void mark(const void* objectPointer, TraceCallback callback) override
     {
         if (!objectPointer)
             return;
         FinalizedHeapObjectHeader* header = FinalizedHeapObjectHeader::fromPayload(objectPointer);
         visitHeader(header, header->payload(), callback);
     }
@@ skipping 18 matching lines @@
     {
         return Heap::weakTableRegistered(closure);
     }
 #endif
 
     virtual bool isMarked(const void* objectPointer) override
     {
         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 \
     {                                                                             \
         if (!objectPointer)                                                       \
             return;                                                               \
         HeapObjectHeader* header =                                                \
             HeapObjectHeader::fromPayload(objectPointer);                         \
         visitHeader(header, header->payload(), callback);                         \
     }                                                                             \
     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
 
 #if ENABLE(GC_PROFILE_MARKING)
     void reportStats()
     {
         fprintf(stderr, "\n---------- AFTER MARKING -------------------\n");
         for (LiveObjectMap::iterator it = currentlyLive().begin(), end = currentlyLive().end(); it != end; ++it) {
             fprintf(stderr, "%s %u", it->key.ascii().data(), it->value.size());
@@ skipping 767 matching lines @@
 bool Heap::s_lastGCWasConservative = false;
 bool Heap::s_inGC = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = 0;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 } // namespace blink