Adding blink gc memory dump infrastructure for thread specific dumps.

Source/platform/heap/ThreadState.h

 /*
  * 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.
  */
 
 #ifndef ThreadState_h
 #define ThreadState_h
 
 #include "platform/PlatformExport.h"
 #include "platform/heap/AddressSanitizer.h"
 #include "platform/heap/ThreadingTraits.h"
+#include "public/platform/WebMemoryDumpProvider.h"
 #include "public/platform/WebThread.h"
 #include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/ThreadSpecific.h"
 #include "wtf/Threading.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/text/WTFString.h"
 
@@ skipping 110 matching lines @@
 const size_t numberOfGenerationsToTrack = 8;
 const size_t maxHeapObjectAge = numberOfGenerationsToTrack - 1;
 
 struct AgeCounts {
     int ages[numberOfGenerationsToTrack];
     AgeCounts() { std::fill(ages, ages + numberOfGenerationsToTrack, 0); }
 };
 typedef HashMap<String, AgeCounts> ClassAgeCountsMap;
 #endif
 
-class PLATFORM_EXPORT ThreadState {
+class PLATFORM_EXPORT ThreadState : public WebMemoryDumpProvider {

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

We discussed this offline (there is a thread in the internal oilpan ML pending).
There seems to be one ThreadState per therad, but PostGC seems to be called once
on a single (probably main) thread, and scans all the threads.
As a consequence, having this as the dumper is odd because:
 - Will give the false expectation that the onMemoryDump is called on the same
Thread of this ThreadState, while that will not be the case.
 - Will end up register one dumper per thread, and it seems that we don't really
need it.

We should have an external dumper class (just one).
All the thread states should dumpInto a shared WebProcessMemoryDump (obtained
through the new API that is landing), and later on the dumper should just merge
(takeAllDumps()) that dump into the WPMD passed to onMemoryDump.
If my understandings of the oilpan threading model are correct, we can do this
by using just one extra WPMD, no locks, and no double-buffering.

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

Done.

     WTF_MAKE_NONCOPYABLE(ThreadState);
 public:
     // When garbage collecting we need to know whether or not there
     // can be pointers to Blink GC managed objects on the stack for
     // each thread. When threads reach a safe point they record
     // whether or not they have pointers on the stack.
     enum StackState {
         NoHeapPointersOnStack,
         HeapPointersOnStack
     };
@@ skipping 272 matching lines @@
     // Visit local thread stack and trace all pointers conservatively.
     void visitStack(Visitor*);
 
     // Visit the asan fake stack frame corresponding to a slot on the
     // real machine stack if there is one.
     void visitAsanFakeStackForPointer(Visitor*, Address);
 
     // Visit all persistents allocated on this thread.
     void visitPersistents(Visitor*);
 
+    // Takes dump of memory statistics when tracing is enabled with memory
+    // category.
+    void dumpMemoryIfNecessary();

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

Had a second thought about this, please don't hate me, I'm very terrible in
naming decisions.
How about dumpIfMemoryProfilingIsEnabled() ?
"necessary" is a bit generic :)
If you are not convinced, don't worry, probably in the next patchset I will
propose another different name :P

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

Haha now there is no need to think about it. :) Peace

+
 #if ENABLE(GC_PROFILING)
     const GCInfo* findGCInfo(Address);
     static const GCInfo* findGCInfoFromAllThreads(Address);
 
     struct SnapshotInfo {
         ThreadState* state;
 
         size_t freeSize;
         size_t pageCount;
 
@@ skipping 132 matching lines @@
         return m_heaps[heapIndex];
     }
     BaseHeap* expandedVectorBackingHeap(size_t gcInfoIndex);
     static bool isVectorHeapIndex(int heapIndex)
     {
         return Vector1HeapIndex <= heapIndex && heapIndex <= Vector4HeapIndex;
     }
     void allocationPointAdjusted(int heapIndex);
     void promptlyFreed(size_t gcInfoIndex);
 
+    // WebMemoryDumpProvider implementation.
+    bool onMemoryDump(WebProcessMemoryDump*) override;

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

This should go away from here, as per discussion up.

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

Done.

+
 private:
     ThreadState();
     ~ThreadState();
 
     void enterSafePoint(StackState, void*);
     NO_SANITIZE_ADDRESS void copyStackUntilSafePointScope();
     void clearSafePointScopeMarker()
     {
         m_safePointStackCopy.clear();
         m_safePointScopeMarker = nullptr;
@@ skipping 77 matching lines @@
 
     v8::Isolate* m_isolate;
     void (*m_traceDOMWrappers)(v8::Isolate*, Visitor*);
 
 #if defined(ADDRESS_SANITIZER)
     void* m_asanFakeStack;
 #endif
 
     Vector<PageMemoryRegion*> m_allocatedRegionsSinceLastGC;
 
+    OwnPtr<WebProcessMemoryDump> m_lastProcessMemoryDump;

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

And this should be just one, shared by all the ThreadState(s).

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

Done.

+
 #if ENABLE(GC_PROFILING)
     double m_nextFreeListSnapshotTime;
 #endif
     // Ideally we want to allocate an array of size |gcInfoTableMax| but it will
     // waste memory. Thus we limit the array size to 2^8 and share one entry
     // with multiple types of vectors. This won't be an issue in practice,
     // since there will be less than 2^8 types of objects in common cases.
     static const int likelyToBePromptlyFreedArraySize = (1 << 8);
     static const int likelyToBePromptlyFreedArrayMask = likelyToBePromptlyFreedArraySize - 1;
     OwnPtr<int[]> m_likelyToBePromptlyFreed;
@@ skipping 12 matching lines @@
 };
 
 template<> class ThreadStateFor<AnyThread> {
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
 } // namespace blink
 
 #endif // ThreadState_h