Adding blink gc memory dump infrastructure for thread specific dumps.

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 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/heap/Heap.h"
 
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/Task.h"
 #include "platform/TraceEvent.h"
+#include "platform/heap/BlinkGCMemoryDumpProvider.h"
 #include "platform/heap/CallbackStack.h"
 #include "platform/heap/MarkingVisitor.h"
 #include "platform/heap/PageMemory.h"
 #include "platform/heap/PagePool.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/heap/ThreadState.h"
 #include "public/platform/Platform.h"
+#include "public/platform/WebMemoryAllocatorDump.h"
 #include "wtf/Assertions.h"
 #include "wtf/ContainerAnnotations.h"
 #include "wtf/LeakAnnotations.h"
 #include "wtf/MainThread.h"
 #include "wtf/PageAllocator.h"
 #include "wtf/Partitions.h"
 #include "wtf/PassOwnPtr.h"
 #if ENABLE(GC_PROFILING)
 #include "platform/TracedValue.h"
 #include "wtf/HashMap.h"
@@ skipping 152 matching lines @@
 
     ASSERT(!m_firstUnsweptPage);
     // Add the BaseHeap's pages to the orphanedPagePool.
     for (BasePage* page = m_firstPage; page; page = page->next()) {
         Heap::decreaseAllocatedSpace(page->size());
         Heap::orphanedPagePool()->addOrphanedPage(heapIndex(), page);
     }
     m_firstPage = nullptr;
 }
 
+void BaseHeap::dumpMemory(const String& dumpBaseName)
+{
+    size_t pageCount = 0;
+    for (BasePage* page = m_firstPage; page; page = page->next()) {
+        pageCount++;
+    }
+    WebMemoryAllocatorDump* allocatorDump = BlinkGCMemoryDumpProvider::instance()->createMemoryAllocatorDumpForLastGC(dumpBaseName);
+    allocatorDump->AddScalar("blink_page_count", "objects", pageCount);
+}
+
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
 BasePage* BaseHeap::findPageFromAddress(Address address)
 {
     for (BasePage* page = m_firstPage; page; page = page->next()) {
         if (page->contains(address))
             return page;
     }
     for (BasePage* page = m_firstUnsweptPage; page; page = page->next()) {
         if (page->contains(address))
             return page;
@@ skipping 1392 matching lines @@
     s_heapDoesNotContainCache = new HeapDoesNotContainCache();
     s_markingVisitor = new MarkingVisitor<Visitor::GlobalMarking>();
     s_freePagePool = new FreePagePool();
     s_orphanedPagePool = new OrphanedPagePool();
     s_allocatedObjectSize = 0;
     s_allocatedSpace = 0;
     s_markedObjectSize = 0;
     s_estimatedMarkingTimePerByte = 0.0;
 
     GCInfoTable::init();
+
+    if (Platform::current()->currentThread())
+        Platform::current()->registerMemoryDumpProvider(BlinkGCMemoryDumpProvider::instance());
 }
 
 void Heap::shutdown()
 {
+    if (Platform::current()->currentThread())
+        Platform::current()->unregisterMemoryDumpProvider(BlinkGCMemoryDumpProvider::instance());
+
     s_shutdownCalled = true;
     ThreadState::shutdownHeapIfNecessary();
 }
 
 void Heap::doShutdown()
 {
     // We don't want to call doShutdown() twice.
     if (!s_markingVisitor)
         return;
 
@@ skipping 214 matching lines @@
 
 void Heap::preGC()
 {
     ASSERT(!ThreadState::current()->isInGC());
     for (ThreadState* state : ThreadState::attachedThreads())
         state->preGC();
 }
 
 void Heap::postGC(ThreadState::GCType gcType)
 {
+    bool enabled = BlinkGCMemoryDumpProvider::isMemoryTracingEnabled();

[Primiano Tucci (use gerrit), 2015/05/26 11:24:06]

nit: const bool isMemoryTracingEnabled =
BlinkGCMemoryDumpProvider::isMemoryTracingEnabled();

[ssid, 2015/05/27 13:15:06]

Done.

+    if (enabled)
+        BlinkGCMemoryDumpProvider::instance()->clearLastGCProcessMemoryDump();
+
     ASSERT(ThreadState::current()->isInGC());
-    for (ThreadState* state : ThreadState::attachedThreads())
+    for (ThreadState* state : ThreadState::attachedThreads()) {
+        if (enabled)
+            state->dumpMemory();

[haraken, 2015/05/26 12:21:59]

postGC wouldn't be a good timing to take memory dump, because it runs _before_
collecting objects. As commented in the other place, I guess a better way to
take the dump would be to forced a sweep-disabled version of GC when
onMemoryDump is requested. Then the concern about the dump timing is gone --
onMemoryDump can just take the dump when it is requested.

If you want, I can implement Heap::collectGarbageWithoutSweeping for you.

[Primiano Tucci (use gerrit), 2015/05/26 14:18:03]

Oh, I think did it in PostGC because the existing HeapVisualizer code was
creating snapshots there.
See my comment there. If we go for the Option1-first-then-Option2 plan what is
the right place to collect the stats for the last GC?
See my comments above. Depending on how much time this would take, we might get
started with a suboptimal (but locally consistent) dump @ GC, and the move to
the on-demand one.
But if collectGarbageWithoutSweeping is a matter of small refactoring, we can
just do it soon.

+
         state->postGC(gcType);
+    }
+
+    // TODO(ssid): Request global dump from blink when support is available
+    // (crbug.com/490087). For the moment the dump is periodically invoked by
+    // the MemoryDumpManager every X secs.
 }
 
 const char* Heap::gcReasonString(GCReason reason)
 {
     switch (reason) {
 #define STRINGIFY_REASON(reason) case reason: return #reason;
         STRINGIFY_REASON(IdleGC);
         STRINGIFY_REASON(PreciseGC);
         STRINGIFY_REASON(ConservativeGC);
         STRINGIFY_REASON(ForcedGC);
@@ skipping 356 matching lines @@
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 // We don't want to use 0 KB for the initial value because it may end up
 // triggering the first GC of some thread too prematurely.
 size_t Heap::s_estimatedLiveObjectSize = 512 * 1024;
 size_t Heap::s_externalObjectSizeAtLastGC = 0;
 double Heap::s_estimatedMarkingTimePerByte = 0.0;
 
 } // namespace blink