Adding blink gc memory dump infrastructure for thread specific dumps.

Source/platform/heap/ThreadState.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/ThreadState.h"
 
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/TraceEvent.h"
 #include "platform/heap/AddressSanitizer.h"
 #include "platform/heap/CallbackStack.h"
 #include "platform/heap/Handle.h"
 #include "platform/heap/Heap.h"
 #include "platform/heap/SafePoint.h"
 #include "public/platform/Platform.h"
+#include "public/platform/WebMemoryAllocatorDump.h"
+#include "public/platform/WebProcessMemoryDump.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/Partitions.h"
 #include "wtf/ThreadingPrimitives.h"
 #if ENABLE(GC_PROFILING)
 #include "platform/TracedValue.h"
 #include "wtf/text/StringHash.h"
 #endif
 
@@ skipping 68 matching lines @@
     }
 
     for (int heapIndex = 0; heapIndex < LargeObjectHeapIndex; heapIndex++)
         m_heaps[heapIndex] = new NormalPageHeap(this, heapIndex);
     m_heaps[LargeObjectHeapIndex] = new LargeObjectHeap(this, LargeObjectHeapIndex);
 
     m_likelyToBePromptlyFreed = adoptArrayPtr(new int[likelyToBePromptlyFreedArraySize]);
     clearHeapAges();
 
     m_weakCallbackStack = new CallbackStack();
+
+    if (Platform::current()->currentThread())
+        Platform::current()->registerMemoryDumpProvider(this);
 }
 
 ThreadState::~ThreadState()
 {
     checkThread();
+
+    if (Platform::current()->currentThread())
+        Platform::current()->unregisterMemoryDumpProvider(this);
+
     delete m_weakCallbackStack;
     m_weakCallbackStack = nullptr;
     for (int i = 0; i < NumberOfHeaps; ++i)
         delete m_heaps[i];
     deleteAllValues(m_interruptors);
     **s_threadSpecific = nullptr;
     if (isMainThread()) {
         s_mainThreadStackStart = 0;
         s_mainThreadUnderestimatedStackSize = 0;
     }
@@ skipping 228 matching lines @@
 
 void ThreadState::visitPersistents(Visitor* visitor)
 {
     m_persistents->trace(visitor);
     if (m_traceDOMWrappers) {
         TRACE_EVENT0("blink_gc", "V8GCController::traceDOMWrappers");
         m_traceDOMWrappers(m_isolate, visitor);
     }
 }
 
+void ThreadState::dumpMemoryIfNecessary()
+{
+    bool enabled;
+    TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("memory-infra"), &enabled);

[Primiano Tucci (use gerrit), 2015/05/21 18:43:10]

Ok to this as a temporary hack, but plz add a cleanup TODO here saying that this
should be exposed by meminfra soon.

[ssid, 2015/05/22 13:34:06]

Done. Check heap.cpp

+    if (!enabled)
+        return;
+
+    m_lastProcessMemoryDump = adoptPtr(Platform::current()->createProcessMemoryDump());
+
+#define SNAPSHOT_HEAP(HeapType)                                                                          \
+    {                                                                                                    \
+        String allocatorBaseName;                                                                        \
+        if (isMainThread()) {                                                                            \
+            allocatorBaseName = String("blink_gc/thread_main/heaps/" #HeapType);                         \
+        }                                                                                                \
+        else {                                                                                           \
+            allocatorBaseName = String::format("blink_gc/thread_%ld/heaps/" #HeapType, m_thread);        \
+        }                                                                                                \
+        m_heaps[HeapType##HeapIndex]->dumpMemoryInto(m_lastProcessMemoryDump.get(), &allocatorBaseName); \
+    }
+
+    SNAPSHOT_HEAP(NormalPage1);

[Primiano Tucci (use gerrit), 2015/05/21 18:43:10]

You either want to remove the ; here (otherwise some compilers will complain
about empty statement), or turn the #defines into
#define SNAPSHOT_HEAP(HeapType) \
  do { ... stuff ... } while(0)

So the expansion ends up with a ; after the while(0).
Not sure what is the most common patter, go figure out in cs :)

[ssid, 2015/05/22 13:34:07]

This is the style in the same file. function ThreadState::snapshot().

+    SNAPSHOT_HEAP(NormalPage2);
+    SNAPSHOT_HEAP(NormalPage3);
+    SNAPSHOT_HEAP(NormalPage4);
+    SNAPSHOT_HEAP(Vector1);
+    SNAPSHOT_HEAP(Vector2);
+    SNAPSHOT_HEAP(Vector3);
+    SNAPSHOT_HEAP(Vector4);
+    SNAPSHOT_HEAP(InlineVector);
+    SNAPSHOT_HEAP(HashTable);
+    SNAPSHOT_HEAP(LargeObject);
+    FOR_EACH_TYPED_HEAP(SNAPSHOT_HEAP);
+
+#undef SNAPSHOT_HEAP
+
+    // TODO(ssid): Request global dump from blink when support is available
+    // (crbug.com/490087).

[Primiano Tucci (use gerrit), 2015/05/21 18:43:10]

Maybe add a line here saying: For the moment the dump is periodically invoked by
the MemoryDumpManager every X secs.

[ssid, 2015/05/22 13:34:06]

done at heap.cpp

+}
+
 #if ENABLE(GC_PROFILING)
 const GCInfo* ThreadState::findGCInfo(Address address)
 {
     if (BasePage* page = findPageFromAddress(address))
         return page->findGCInfo(address);
     return nullptr;
 }
 
 size_t ThreadState::SnapshotInfo::getClassTag(const GCInfo* gcInfo)
 {
@@ skipping 442 matching lines @@
     makeConsistentForSweeping();
     prepareRegionTree();
     flushHeapDoesNotContainCacheIfNeeded();
     clearHeapAges();
 }
 
 void ThreadState::postGC(GCType gcType)
 {
     ASSERT(isInGC());
 
+    dumpMemoryIfNecessary();
 #if ENABLE(GC_PROFILING)
     // We snapshot the heap prior to sweeping to get numbers for both resources
     // that have been allocated since the last GC and for resources that are
     // going to be freed.
     bool gcTracingEnabled;
     TRACE_EVENT_CATEGORY_GROUP_ENABLED("blink_gc", &gcTracingEnabled);
 
     if (gcTracingEnabled) {
         bool disabledByDefaultGCTracingEnabled;
         TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("blink_gc"), &disabledByDefaultGCTracingEnabled);
@@ skipping 361 matching lines @@
         m_vectorBackingHeapIndex = heapIndexOfVectorHeapLeastRecentlyExpanded(Vector1HeapIndex, Vector4HeapIndex);
 }
 
 void ThreadState::promptlyFreed(size_t gcInfoIndex)
 {
     size_t entryIndex = gcInfoIndex & likelyToBePromptlyFreedArrayMask;
     // See the comment in vectorBackingHeap() for why this is +3.
     m_likelyToBePromptlyFreed[entryIndex] += 3;
 }
 
+bool ThreadState::onMemoryDump(WebProcessMemoryDump* memoryDump)
+{
+    // Returns true because it might be able to provide dump in future. On
+    // returning false, the memory dump manager stops collecting dumps from
+    // this provider.
+    if (!m_lastProcessMemoryDump.get())
+        return true;

[Primiano Tucci (use gerrit), 2015/05/21 18:43:10]

Ok for now, but this should really return false.
If we return true we will confuse the UI. it is ok for the moment, as this is
unlikely but should be fixed soon.

Please add a TODO and reference crbug.com/490783 (I've just created) and reword
the comment as.
// TODO(ssid): Temporary workaround while crbug.com/490783 gets fixed. This
should return false in the unlikely case that we didn't see a GC yet, which in
turn will cause the dump to be invalidated.

[ssid, 2015/05/22 13:34:06]

Not sure if this is relevant any more.

+
+    memoryDump->takeAllDumpsFrom(m_lastProcessMemoryDump.get());
+    return true;
+}
+
 #if ENABLE(GC_PROFILING)
 const GCInfo* ThreadState::findGCInfoFromAllThreads(Address address)
 {
     bool needLockForIteration = !ThreadState::current()->isInGC();
     if (needLockForIteration)
         threadAttachMutex().lock();
 
     for (ThreadState* state : attachedThreads()) {
         if (const GCInfo* gcInfo = state->findGCInfo(address)) {
             if (needLockForIteration)
@@ skipping 70 matching lines @@
         json->beginArray(it->key.ascii().data());
         for (size_t age = 0; age <= maxHeapObjectAge; ++age)
             json->pushInteger(it->value.ages[age]);
         json->endArray();
     }
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("blink_gc"), statsName, this, json.release());
 }
 #endif
 
 } // namespace blink