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 ENABLE(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 ENABLE(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 blink {
 
-#if ENABLE(GC_TRACING)
+#if ENABLE(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 291 matching lines @@
     MemoryRegion m_writable;
 };
 
 class GCScope {
 public:
     explicit GCScope(ThreadState::StackState stackState)
         : m_state(ThreadState::current())
         , m_safePointScope(stackState)
         , m_parkedAllThreads(false)
     {
-        TRACE_EVENT0("blink", "Heap::GCScope");
+        TRACE_EVENT0("blink_gc", "Heap::GCScope");
         const char* samplingState = TRACE_EVENT_GET_SAMPLING_STATE();
         if (m_state->isMainThread())
-            TRACE_EVENT_SET_SAMPLING_STATE("blink", "BlinkGCWaiting");
+            TRACE_EVENT_SET_SAMPLING_STATE("blink_gc", "BlinkGCWaiting");
 
         m_state->checkThread();
 
         // FIXME: in an unlikely coincidence that two threads decide
         // to collect garbage at the same time, avoid doing two GCs in
         // a row.
         RELEASE_ASSERT(!m_state->isInGC());
         RELEASE_ASSERT(!m_state->isSweepInProgress());
         if (LIKELY(ThreadState::stopThreads())) {
             m_parkedAllThreads = true;
@@ skipping 119 matching lines @@
 {
     heapObjectHeader()->setDeadMark();
 }
 
 template<typename Header>
 void LargeHeapObject<Header>::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(contains(address));
     if (!objectContains(address) || heapObjectHeader()->hasDeadMark())
         return;
-#if ENABLE(GC_TRACING)
+#if ENABLE(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 129 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 ENABLE(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 ENABLE(GC_PROFILE_HEAP)
+#define GC_PROFILE_HEAP_PAGE_SNAPSHOT_THRESHOLD 0
+template<typename Header>
+void ThreadHeap<Header>::snapshot(TracedValue* json, ThreadState::SnapshotInfo* info)
+{
+    size_t previousPageCount = info->pageCount;
+
+    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.
+        if (info->pageCount < GC_PROFILE_HEAP_PAGE_SNAPSHOT_THRESHOLD) {
+            json->beginArray();
+            json->pushInteger(reinterpret_cast<intptr_t>(page));
+            page->snapshot(json, info);
+            json->endArray();
+        } else {
+            page->snapshot(0, info);
+        }
+    }
+    json->endArray();
+
+    json->beginArray("largeObjects");
+    for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current; current = current->next()) {
+        json->beginDictionary();
+        current->snapshot(json, info);
+        json->endDictionary();
+    }
+    json->endArray();
+
+    json->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 629 matching lines @@
 }
 
 template<typename Header>
 void HeapPage<Header>::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(contains(address));
     Header* header = findHeaderFromAddress(address);
     if (!header || header->hasDeadMark())
         return;
 
-#if ENABLE(GC_TRACING)
+#if ENABLE(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 ENABLE(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 ENABLE(GC_PROFILE_HEAP)
+template<typename Header>
+void HeapPage<Header>::snapshot(TracedValue* 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 ENABLE(GC_PROFILE_HEAP)
+template<typename Header>
+void LargeHeapObject<Header>::snapshot(TracedValue* 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 dead before the final generation.
+        if (age < maxHeapObjectAge)
+            info->generations[tag][age] += 1;
+    }
+
+    if (json) {
+        json->setInteger("class", tag);
+        json->setInteger("size", header->size());
+        json->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 118 matching lines @@
         return true;
     }
     if (Mode == ThreadLocalMarking && (heapPage->orphaned() || !heapPage->terminating()))
         return true;
     // For WeaknessProcessing we should never reach orphaned pages since
     // they should never be registered as objects on orphaned pages are not
     // traced. We cannot assert this here since we might have an off-heap
     // collection. However we assert it in Heap::pushWeakObjectPointerCallback.
 
     VisitorCallback callback = item->callback();
-#if ENABLE(GC_TRACING)
+#if ENABLE(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 54 matching lines @@
     }
     if (m_next)
         return m_next->hasCallbackForObject(object);
 
     return false;
 }
 #endif
 
 class MarkingVisitor : public Visitor {
 public:
-#if ENABLE(GC_TRACING)
+#if ENABLE(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);
         // Check that we are not marking objects that are outside the heap by calling Heap::contains.
         // However we cannot call Heap::contains when outside a GC and we call mark when doing weakness
         // for ephemerons. Hence we only check when called within.
         ASSERT(!ThreadState::isAnyThreadInGC() || Heap::containedInHeapOrOrphanedPage(header));
         ASSERT(objectPointer);
         if (header->isMarked())
             return;
         header->mark();
-#if ENABLE(GC_TRACING)
+#if ENABLE(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 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());
 
             if (it->key == "blink::Document")
                 reportStillAlive(it->value, previouslyLive().get(it->key));
 
             fprintf(stderr, "\n");
@@ skipping 170 matching lines @@
 
 #if !ENABLE(ASSERT)
     s_heapDoesNotContainCache->addEntry(address, true);
 #else
     if (!s_heapDoesNotContainCache->lookup(address))
         s_heapDoesNotContainCache->addEntry(address, true);
 #endif
     return 0;
 }
 
-#if ENABLE(GC_TRACING)
+#if ENABLE(GC_PROFILE_MARKING)
 const GCInfo* Heap::findGCInfo(Address address)
 {
     return ThreadState::findGCInfoFromAllThreads(address);
 }
+#endif
 
+#if ENABLE(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 104 matching lines @@
     if (!gcScope.allThreadsParked()) {
         ThreadState::current()->setGCRequested();
         return;
     }
 
     if (state->isMainThread())
         ScriptForbiddenScope::enter();
 
     s_lastGCWasConservative = false;
 
-    TRACE_EVENT0("blink", "Heap::collectGarbage");
-    TRACE_EVENT_SCOPED_SAMPLING_STATE("blink", "BlinkGC");
+    TRACE_EVENT0("blink_gc", "Heap::collectGarbage");
+    TRACE_EVENT_SCOPED_SAMPLING_STATE("blink_gc", "BlinkGC");
     double timeStamp = WTF::currentTimeMS();
-#if ENABLE(GC_TRACING)
+#if ENABLE(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 17 matching lines @@
 
     // After a global marking we know that any orphaned page that was not reached
     // cannot be reached in a subsequent GC. This is due to a thread either having
     // swept its heap or having done a "poor mans sweep" in prepareForGC which marks
     // objects that are dead, but not swept in the previous GC as dead. In this GC's
     // marking we check that any object marked as dead is not traced. E.g. via a
     // conservatively found pointer or a programming error with an object containing
     // a dangling pointer.
     orphanedPagePool()->decommitOrphanedPages();
 
-#if ENABLE(GC_TRACING)
+#if ENABLE(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 156 matching lines @@
 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;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 }