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 "public/platform/WebProcessMemoryDump.h"

[Primiano Tucci (use gerrit), 2015/05/22 19:45:57]

I think you don't need this anymore

[ssid, 2015/05/26 11:08:43]

Done.

 #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()->mainThread())

[Primiano Tucci (use gerrit), 2015/05/22 19:45:57]

Question for haraken@: for production (i.e. non tests) is the global Heap::
always initialized and torn down on the main thread?

[ssid, 2015/05/26 11:08:43]

changed it.

+        Platform::current()->registerMemoryDumpProvider(BlinkGCMemoryDumpProvider::instance());
 }
 
 void Heap::shutdown()
 {
+    if (Platform::current()->mainThread())
+        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)
 {
+    // TODO(ssid): Change this to use api from memory-infra to check tracing
+    // memory_tracing_enabled (crbug.com/490087).
+    bool enabled;

[Primiano Tucci (use gerrit), 2015/05/22 19:45:57]

Can you encapsulate this into a "static inline bool" method of
BlinkGCMemoryDumpProvider, so we hide this dust under our class, and in future
just fix ours?
P.S. I know that BlinkGCMemoryDumpProvider is a singleton, but just for this one
use a "static inline bool" as we want this to be a fastpath.

[ssid, 2015/05/26 11:08:43]

Done.

+    TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("memory-infra"), &enabled);
+    if (enabled)
+        BlinkGCMemoryDumpProvider::instance()->clearLastProcessMemoryDump();
+
     ASSERT(ThreadState::current()->isInGC());
-    for (ThreadState* state : ThreadState::attachedThreads())
+    for (ThreadState* state : ThreadState::attachedThreads()) {
+        if (enabled)
+            state->dumpMemory();
+
         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