Oilpan: GC profiling.

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 21 matching lines @@
 #include "platform/heap/Heap.h"
 
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/TraceEvent.h"
 #include "platform/heap/ThreadState.h"
 #include "public/platform/Platform.h"
 #include "wtf/AddressSpaceRandomization.h"
 #include "wtf/Assertions.h"
 #include "wtf/LeakAnnotations.h"
 #include "wtf/PassOwnPtr.h"
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringHash.h"
 #include <stdio.h>
 #include <utility>
 #endif
+#if GC_PROFILE_HEAP
+#include "platform/TracedValue.h"
+#endif
 
 #if OS(POSIX)
 #include <sys/mman.h>
 #include <unistd.h>
 #elif OS(WIN)
 #include <windows.h>
 #endif
 
 namespace WebCore {
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
 static String classOf(const void* object)
 {
     const GCInfo* gcInfo = Heap::findGCInfo(reinterpret_cast<Address>(const_cast<void*>(object)));
     if (gcInfo)
         return gcInfo->m_className;
 
     return "unknown";
 }
 #endif
 
@@ skipping 427 matching lines @@
 {
     return heapObjectHeader()->isMarked();
 }
 
 template<typename Header>
 void LargeHeapObject<Header>::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(contains(address));
     if (!objectContains(address))
         return;
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     visitor->setHostInfo(&address, "stack");
 #endif
     mark(visitor);
 }
 
 template<>
 void LargeHeapObject<FinalizedHeapObjectHeader>::mark(Visitor* visitor)
 {
     if (heapObjectHeader()->hasVTable() && !vTableInitialized(payload()))
         visitor->markConservatively(heapObjectHeader());
@@ skipping 115 matching lines @@
     for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current; current = current->next()) {
         // Check that large pages are blinkPageSize aligned (modulo the
         // osPageSize for the guard page).
         ASSERT(reinterpret_cast<Address>(current) - osPageSize() == roundToBlinkPageStart(reinterpret_cast<Address>(current)));
         if (current->contains(address))
             return current;
     }
     return 0;
 }
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
 template<typename Header>
 const GCInfo* ThreadHeap<Header>::findGCInfoOfLargeHeapObject(Address address)
 {
     for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current; current = current->next()) {
         if (current->contains(address))
             return current->gcInfo();
     }
     return 0;
 }
 #endif
 
+#if GC_PROFILE_HEAP
+template<typename Header>
+void ThreadHeap<Header>::snapshot(TracedDictionaryBase* json, ThreadState::SnapshotInfo* info)
+{
+    size_t previousPageCount = info->pageCount;
+
+    TracedArrayBase& pages = json->beginArray("pages");
+    for (HeapPage<Header>* page = m_firstPage; page; page = page->next(), ++info->pageCount) {
+        // FIXME: To limit the size of the snapshot we only output "threshold" many page snapshots.
+        TracedArrayBase* jsonPage = 0;
+        if (info->pageCount < GC_PROFILE_HEAP_PAGE_DUMP_THRESHOLD) {
+            jsonPage = &pages.beginArray();
+            jsonPage->pushInteger(reinterpret_cast<intptr_t>(page));
+        }
+        page->snapshot(jsonPage, info);
+        if (jsonPage)
+            jsonPage->endArray();
+    }
+    pages.endArray();
+
+    TracedArrayBase& largeObjects = json->beginArray("largeObjects");
+    for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current; current = current->next()) {
+        TracedDictionaryBase& jsonCurrent = largeObjects.beginDictionary();
+        current->snapshot(&jsonCurrent, info);
+        jsonCurrent.endDictionary();
+    }
+    largeObjects.endArray();
+
+    size_t pagePoolSize = 0;
+    for (PagePoolEntry* page = m_pagePool; page; page = page->next())
+        ++pagePoolSize;
+
+    json->setInteger("pagePoolSize", pagePoolSize)
+        .setInteger("pageCount", info->pageCount - previousPageCount);
+}
+#endif
+
 template<typename Header>
 void ThreadHeap<Header>::addToFreeList(Address address, size_t size)
 {
     ASSERT(heapPageFromAddress(address));
     ASSERT(heapPageFromAddress(address + size - 1));
     ASSERT(size < blinkPagePayloadSize());
     // The free list entries are only pointer aligned (but when we allocate
     // from them we are 8 byte aligned due to the header size).
     ASSERT(!((reinterpret_cast<uintptr_t>(address) + sizeof(Header)) & allocationMask));
     ASSERT(!(size & allocationMask));
@@ skipping 528 matching lines @@
 }
 
 template<typename Header>
 void HeapPage<Header>::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(contains(address));
     Header* header = findHeaderFromAddress(address);
     if (!header)
         return;
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     visitor->setHostInfo(&address, "stack");
 #endif
     if (hasVTable(header) && !vTableInitialized(header->payload()))
         visitor->markConservatively(header);
     else
         visitor->mark(header, traceCallback(header));
 }
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
 template<typename Header>
 const GCInfo* HeapPage<Header>::findGCInfo(Address address)
 {
     if (address < payload())
         return 0;
 
     if (gcInfo()) // for non FinalizedObjectHeader
         return gcInfo();
 
     Header* header = findHeaderFromAddress(address);
     if (!header)
         return 0;
 
     return header->gcInfo();
 }
 #endif
 
+#if GC_PROFILE_HEAP
+template<typename Header>
+void HeapPage<Header>::snapshot(TracedArrayBase* json, ThreadState::SnapshotInfo* info)
+{
+    Header* header = 0;
+    for (Address addr = payload(); addr < end(); addr += header->size()) {
+        header = reinterpret_cast<Header*>(addr);
+        if (json)
+            json->pushInteger(header->encodedSize());
+        if (header->isFree()) {
+            info->freeSize += header->size();
+            continue;
+        }
+
+        size_t tag = info->getClassTag(header->gcInfo());
+        size_t age = header->age();
+        if (json)
+            json->pushInteger(tag);
+        if (header->isMarked()) {
+            info->liveCount[tag] += 1;
+            info->liveSize += header->size();
+            // Count objects that are live when promoted to the final generation.
+            if (age == maxHeapObjectAge - 1)
+                info->generations[tag][maxHeapObjectAge] += 1;
+            header->incAge();
+        } else {
+            info->deadCount[tag] += 1;
+            info->deadSize += header->size();
+            // Count objects that are dead before the final generation.
+            if (age < maxHeapObjectAge)
+                info->generations[tag][age] += 1;
+        }
+    }
+}
+#endif
+
 #if defined(ADDRESS_SANITIZER)
 template<typename Header>
 void HeapPage<Header>::poisonUnmarkedObjects()
 {
     for (Address headerAddress = payload(); headerAddress < end(); ) {
         Header* header = reinterpret_cast<Header*>(headerAddress);
         ASSERT(header->size() < blinkPagePayloadSize());
 
         if (!header->isFree() && !header->isMarked())
             ASAN_POISON_MEMORY_REGION(header->payload(), header->payloadSize());
@@ skipping 41 matching lines @@
     return header->hasVTable();
 }
 
 template<typename Header>
 void LargeHeapObject<Header>::getStats(HeapStats& stats)
 {
     stats.increaseAllocatedSpace(size());
     stats.increaseObjectSpace(payloadSize());
 }
 
+#if GC_PROFILE_HEAP
+template<typename Header>
+void LargeHeapObject<Header>::snapshot(TracedDictionaryBase* json, ThreadState::SnapshotInfo* info)
+{
+    Header* header = heapObjectHeader();
+    size_t tag = info->getClassTag(header->gcInfo());
+    size_t age = header->age();
+    if (isMarked()) {
+        info->liveCount[tag] += 1;
+        info->liveSize += header->size();
+        // Count objects that are live when promoted to the final generation.
+        if (age == maxHeapObjectAge - 1)
+            info->generations[tag][maxHeapObjectAge] += 1;
+        header->incAge();
+    } else {
+        info->deadCount[tag] += 1;
+        info->deadSize += header->size();
+        // Count objects that are live when promoted to the final generation.
+        if (age == maxHeapObjectAge - 1)
+            info->generations[tag][maxHeapObjectAge] += 1;
+        header->incAge();
+    }
+
+    if (json) {
+        json->setInteger("class", tag)
+            .setInteger("size", header->size())
+            .setInteger("isMarked", isMarked());
+    }
+}
+#endif
+
 template<typename Entry>
 void HeapExtentCache<Entry>::flush()
 {
     if (m_hasEntries) {
         for (int i = 0; i < numberOfEntries; i++)
             m_entries[i] = Entry();
         m_hasEntries = false;
     }
 }
 
@@ skipping 94 matching lines @@
             return false;
         }
         CallbackStack* nextStack = m_next;
         *first = nextStack;
         delete this;
         return nextStack->popAndInvokeCallback(first, visitor);
     }
     Item* item = --m_current;
 
     VisitorCallback callback = item->callback();
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     if (ThreadState::isAnyThreadInGC()) // weak-processing will also use popAndInvokeCallback
         visitor->setHostInfo(item->object(), classOf(item->object()));
 #endif
     callback(visitor, item->object());
 
     return true;
 }
 
 void CallbackStack::invokeCallbacks(CallbackStack** first, Visitor* visitor)
 {
@@ skipping 37 matching lines @@
     }
     if (m_next)
         return m_next->hasCallbackForObject(object);
 
     return false;
 }
 #endif
 
 class MarkingVisitor : public Visitor {
 public:
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     typedef HashSet<uintptr_t> LiveObjectSet;
     typedef HashMap<String, LiveObjectSet> LiveObjectMap;
     typedef HashMap<uintptr_t, std::pair<uintptr_t, String> > ObjectGraph;
 #endif
 
     inline void visitHeader(HeapObjectHeader* header, const void* objectPointer, TraceCallback callback)
     {
         ASSERT(header);
         ASSERT(objectPointer);
         if (header->isMarked())
             return;
         header->mark();
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
         MutexLocker locker(objectGraphMutex());
         String className(classOf(objectPointer));
         {
             LiveObjectMap::AddResult result = currentlyLive().add(className, LiveObjectSet());
             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
@@ skipping 85 matching lines @@
         visitHeader(header, header->payload(), callback);                         \
     }                                                                             \
     virtual bool isMarked(const Type* objectPointer) OVERRIDE                     \
     {                                                                             \
         return HeapObjectHeader::fromPayload(objectPointer)->isMarked();          \
     }
 
     FOR_EACH_TYPED_HEAP(DEFINE_VISITOR_METHODS)
 #undef DEFINE_VISITOR_METHODS
 
-#if ENABLE(GC_TRACING)
+#if 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());
 
             if (it->key == "WebCore::Document")
                 reportStillAlive(it->value, previouslyLive().get(it->key));
 
             fprintf(stderr, "\n");
@@ skipping 157 matching lines @@
 
 #ifdef NDEBUG
     s_heapDoesNotContainCache->addEntry(address, true);
 #else
     if (!s_heapDoesNotContainCache->lookup(address))
         s_heapDoesNotContainCache->addEntry(address, true);
 #endif
     return 0;
 }
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
 const GCInfo* Heap::findGCInfo(Address address)
 {
     return ThreadState::findGCInfoFromAllThreads(address);
 }
+#endif
 
+#if GC_PROFILE_MARKING
 void Heap::dumpPathToObjectOnNextGC(void* p)
 {
     static_cast<MarkingVisitor*>(s_markingVisitor)->dumpPathToObjectOnNextGC(p);
 }
 
 String Heap::createBacktraceString()
 {
     int framesToShow = 3;
     int stackFrameSize = 16;
     ASSERT(stackFrameSize >= framesToShow);
@@ skipping 96 matching lines @@
     GCScope gcScope(stackState);
     // Check if we successfully parked the other threads. If not we bail out of the GC.
     if (!gcScope.allThreadsParked()) {
         ThreadState::current()->setGCRequested();
         return;
     }
 
     ScriptForbiddenScope forbiddenScope;
     s_lastGCWasConservative = false;
 
-    TRACE_EVENT0("blink", "Heap::collectGarbage");
-    TRACE_EVENT_SCOPED_SAMPLING_STATE("blink", "BlinkGC");
+    TRACE_EVENT0(GC_PROFILE_GROUP, "Heap::collectGarbage");
+    TRACE_EVENT_SCOPED_SAMPLING_STATE(GC_PROFILE_GROUP, "BlinkGC");
     double timeStamp = WTF::currentTimeMS();
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     static_cast<MarkingVisitor*>(s_markingVisitor)->objectGraph().clear();
 #endif
 
     // Disallow allocation during garbage collection (but not
     // during the finalization that happens when the gcScope is
     // torn down).
     NoAllocationScope<AnyThread> noAllocationScope;
 
     prepareForGC();
 
@@ skipping 16 matching lines @@
     // to do cleanup (specifically clear the queued bits for weak hash
     // tables).
     while (popAndInvokeWeakPointerCallback(s_markingVisitor)) { }
 
     CallbackStack::clear(&s_ephemeronStack);
 
     // It is not permitted to trace pointers of live objects in the weak
     // callback phase, so the marking stack should still be empty here.
     ASSERT(s_markingStack->isEmpty());
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
     static_cast<MarkingVisitor*>(s_markingVisitor)->reportStats();
 #endif
 
     if (blink::Platform::current()) {
         uint64_t objectSpaceSize;
         uint64_t allocatedSpaceSize;
         getHeapSpaceSize(&objectSpaceSize, &allocatedSpaceSize);
         blink::Platform::current()->histogramCustomCounts("BlinkGC.CollectGarbage", WTF::currentTimeMS() - timeStamp, 0, 10 * 1000, 50);
         blink::Platform::current()->histogramCustomCounts("BlinkGC.TotalObjectSpace", objectSpaceSize / 1024, 0, 4 * 1024 * 1024, 50);
         blink::Platform::current()->histogramCustomCounts("BlinkGC.TotalAllocatedSpace", allocatedSpaceSize / 1024, 0, 4 * 1024 * 1024, 50);
@@ skipping 68 matching lines @@
 template class ThreadHeap<HeapObjectHeader>;
 
 Visitor* Heap::s_markingVisitor;
 CallbackStack* Heap::s_markingStack;
 CallbackStack* Heap::s_weakCallbackStack;
 CallbackStack* Heap::s_ephemeronStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 }