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()
 {
+    if (Platform::current()->currentThread())
+        Platform::current()->unregisterMemoryDumpProvider(this);
+
     checkThread();

[Primiano Tucci (use gerrit), 2015/05/21 09:56:34]

keep checkThread on the top, if this ends up in the wrong thread, we want to
know ASAP

[ssid, 2015/05/21 11:38:55]

Done.

     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::snapshotMemoryIfNecessary()

[Primiano Tucci (use gerrit), 2015/05/21 09:56:34]

This is a good name.
I wonder though if we really need the other ::snapshotMemory of if we can just
put everything here.

[ssid, 2015/05/21 11:38:55]

Not sure, your call.

+{
+    bool enabled;
+    TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("memory-infra"), &enabled);

[Primiano Tucci (use gerrit), 2015/05/21 09:56:33]

I see why you did it (it's the only way to tell today whether memory infra is
enabled) but I think I prefer exposiing a method here and not having to knowing
the "memory-infra" string inside of blink.
I will think (and expose an API) and let you know

[ssid, 2015/05/21 11:38:55]

Not sure if i should add a TODO here?

+    if (!enabled)
+        return;
+
+    snapshotMemory();
+}
+
+void ThreadState::snapshotMemory()
+{
+    // TODO(ssid): uncomment the following line once the support is available,
+    // and remove the check for dump being null.
+    // m_lastProcessMemoryDump.reset(Platform::current()->getExtraProcessMemoryDump());

[Primiano Tucci (use gerrit), 2015/05/21 09:56:34]

I think we need to do some kind of dual buffering here: keep always two  pmd:
one is the last good one, and another is the one you are currently populating.
So that when we get the onMemoryDump call we don't have to worry if the pmd is
being populated, and we can rely on the fact that we always have a "last good
one" (unless we get the onMemoryDUmp too early and we don't have one at all) 

[ssid, 2015/05/21 11:38:55]

Yes this check is for the case that it isn't available at all.
I don't think we need a last good one, since only one of them can happen at a
time, either a snapshot or a memodyDump, in the same thread. Am I missing
something?

+    if (!m_lastProcessMemoryDump.get())
+        return;
+
+#define SNAPSHOT_HEAP(HeapType) m_heaps[HeapType##HeapIndex]->snapshotMemory(m_lastProcessMemoryDump.get(), #HeapType);
+
+    SNAPSHOT_HEAP(NormalPage1);
+    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_FREE_LIST

[Primiano Tucci (use gerrit), 2015/05/21 09:56:33]

I think you meant to undef SNAPSHOT_HEAP here :)

[ssid, 2015/05/21 11:38:55]

Done.

+
+    // TODO(ssid): Request global dump from blink when support is available.
+}
+
 #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());
 
+    snapshotMemoryIfNecessary();
 #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;
+
+    // TODO(ssid): Swap the memory dumps once the support is available.
+    // memoryDump->swap(m_lastProcessMemoryDump.get());

[Primiano Tucci (use gerrit), 2015/05/21 09:56:33]

The code is not fully there yet, but the final name will be "TakeAllDumpsFrom"
not swap
See crrev.com/1151603004

Also, TakeAllDumpsFrom will gurarrantee that the argument will be emptied and
re-usable after the call (so you will not have to create a new one)

[ssid, 2015/05/21 11:38:55]

Done.

+    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