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 23 matching lines @@
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/Task.h"
 #include "platform/TraceEvent.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"
 #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 = Heap::getLastProcessMemoryDump()->createMemoryAllocatorDump(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 1425 matching lines @@
     delete s_weakCallbackStack;
     s_weakCallbackStack = nullptr;
     delete s_postMarkingCallbackStack;
     s_postMarkingCallbackStack = nullptr;
     delete s_markingStack;
     s_markingStack = nullptr;
     delete s_ephemeronStack;
     s_ephemeronStack = nullptr;
     delete s_regionTree;
     s_regionTree = nullptr;
+    if (s_lastProcessMemoryDump) {

[Primiano Tucci (use gerrit), 2015/05/22 15:50:21]

See my other consideration. If you move this to BlinkGCMemoryDumpProvider, these
lines go away.

[ssid, 2015/05/22 17:17:10]

Done.

+        delete s_lastProcessMemoryDump;
+        s_lastProcessMemoryDump = nullptr;
+    }
+
     GCInfoTable::shutdown();
     ThreadState::shutdown();
     ASSERT(Heap::allocatedSpace() == 0);
 }
 
 #if ENABLE(ASSERT)
 BasePage* Heap::findPageFromAddress(Address address)
 {
     BasePage* result = nullptr;
     if (!ThreadState::current()->isInGC())
@@ skipping 185 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
+    // enabled (crbug.com/490087).
+    bool enabled;

[Primiano Tucci (use gerrit), 2015/05/22 15:50:21]

s /enabled/memory_tracing_enabled/

[ssid, 2015/05/22 17:17:10]

Done.

+    TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("memory-infra"), &enabled);
+    if (enabled)
+        Heap::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 235 matching lines @@
         state->setGCState(ThreadState::GCRunning);
         state->makeConsistentForSweeping();
         objectPayloadSize += state->objectPayloadSizeForTesting();
         state->setGCState(ThreadState::EagerSweepScheduled);
         state->setGCState(ThreadState::Sweeping);
         state->setGCState(ThreadState::NoGCScheduled);
     }
     return objectPayloadSize;
 }
 
+WebProcessMemoryDump* Heap::getLastProcessMemoryDump() { return s_lastProcessMemoryDump; }
+
+void Heap::clearLastProcessMemoryDump()

[Primiano Tucci (use gerrit), 2015/05/22 15:50:21]

Ouch, this is really my fault, I forgot that WPMD should have add a .clear()
method.
Let's do this: if you follow my suggestion to move the extra WPMD to
BlinkGCMemoryDumpProvider, you can remove this here and add a method to
BlinkGCMemoryDumpProvider like:
BlinkGCMemoryDumpProvider::clearProcessMemoryDumpForLastGC().

For the moment you will do the delete and re-create (but in
BlinkGCMemoryDumpProvider instead of this file), and once I fix the api you will
just use clear().
Rationale: I want to avoid doing news and frees as mucha s possible.

[ssid, 2015/05/22 17:17:10]

Yes i know. Looked like this file had lots of new(s) and free(s), so i just did
this. moved to ownptr now.

+{
+    if (s_lastProcessMemoryDump)
+        delete s_lastProcessMemoryDump;
+    s_lastProcessMemoryDump = Platform::current()->createProcessMemoryDump();
+}
+
 BasePage* Heap::lookup(Address address)
 {
     ASSERT(ThreadState::current()->isInGC());
     if (!s_regionTree)
         return nullptr;
     if (PageMemoryRegion* region = s_regionTree->lookup(address)) {
         BasePage* page = region->pageFromAddress(address);
         return page && !page->orphaned() ? page : nullptr;
     }
     return nullptr;
@@ skipping 99 matching lines @@
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = nullptr;
 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;
+WebProcessMemoryDump* Heap::s_lastProcessMemoryDump;

[Primiano Tucci (use gerrit), 2015/05/22 15:50:21]

This also goes away :)

[ssid, 2015/05/22 17:17:10]

Done.

 
 } // namespace blink