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);
+    if (!enabled)
+        return;
+
+    dumpMemory();
+}
+
+void ThreadState::dumpMemory()
+{
+    ASSERT(checkThread());

[ssid, 2015/05/21 16:55:28]

This check is not required here, since method can be called on any thread. In
this case we need to add two dumps, one which is being updated and one which is
being swapped. Do you think there should be a lock? 2 threads can do the
swapping at the same time.

+    if (!m_lastProcessMemoryDump.get()) {
+        // TODO(ssid): uncomment the following line once the support is available,
+        // and remove the return statement.
+        // m_lastProcessMemoryDump.reset(Platform::current()->getExtraProcessMemoryDump());
+        return;
+    }
+
+#define SNAPSHOT_HEAP(HeapType) m_heaps[HeapType##HeapIndex]->dumpMemoryInto(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_HEAP
+
+    // 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());
 
+    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;
+
+    // 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