Oilpan: GC profiling.

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/Handle.h"
 #include "platform/heap/Heap.h"
 #include "public/platform/Platform.h"
 #include "wtf/ThreadingPrimitives.h"
 
+#if GC_PROFILE_HEAP
+#include "platform/TracedValue.h"
+#endif
+
 #if OS(WIN)
 #include <stddef.h>
 #include <windows.h>
 #include <winnt.h>
 #elif defined(__GLIBC__)
 extern "C" void* __libc_stack_end;  // NOLINT
 #endif
 
 #if defined(MEMORY_SANITIZER)
 #include <sanitizer/msan_interface.h>
@@ skipping 472 matching lines @@
         // Whether or not the pointer was within an object it was certainly
         // within a page that is part of the heap, so we don't want to ask the
         // other other heaps or put this address in the
         // HeapDoesNotContainCache.
         return true;
     }
 
     return false;
 }
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
 const GCInfo* ThreadState::findGCInfo(Address address)
 {
     BaseHeapPage* page = heapPageFromAddress(address);
     if (page) {
         return page->findGCInfo(address);
     }
     return 0;
 }
 #endif
 
+#if GC_PROFILE_HEAP
+size_t ThreadState::SnapshotInfo::getClassTag(const GCInfo* gcinfo)
+{
+    HashMap<const GCInfo*, size_t>::AddResult result = classTags.add(gcinfo, classTags.size());
+    if (result.isNewEntry) {
+        liveCount.append(0);
+        deadCount.append(0);
+        generations.append(Vector<int, 8>());
+        generations.last().fill(0, 8);
+    }
+    return result.storedValue->value;
+}
+
+void ThreadState::snapshot()
+{
+    SnapshotInfo info(this);
+    TracedValue json;
+
+#define SNAPSHOT_HEAP(HeapType)                                         \
+    {                                                                   \
+        TracedDictionary<TracedArray<TracedValue> >& jsonHeap = heaps.beginDictionary(); \
+        jsonHeap.setString("name", #HeapType);                          \
+        m_heaps[HeapType##Heap]->snapshot(&jsonHeap, &info);            \
+        jsonHeap.endDictionary();                                       \
+    }
+    TracedArray<TracedValue>& heaps = json.beginArray("heaps");
+    SNAPSHOT_HEAP(General);
+    FOR_EACH_TYPED_HEAP(SNAPSHOT_HEAP);
+    heaps.endArray();
+#undef SNAPSHOT_HEAP
+
+    json.setInteger("allocatedSpace", m_stats.totalAllocatedSpace())
+        .setInteger("objectSpace", m_stats.totalObjectSpace())
+        .setInteger("liveSize", info.liveSize)
+        .setInteger("deadSize", info.deadSize)
+        .setInteger("freeSize", info.freeSize)
+        .setInteger("pageCount", info.freeSize);
+
+    Vector<String> classNameVector(info.classTags.size());
+    for (HashMap<const GCInfo*, size_t>::iterator it = info.classTags.begin(); it != info.classTags.end(); ++it)
+        classNameVector[it->value] = it->key->m_className;
+
+    TracedArray<TracedValue>& jsonClasses = json.beginArray("classes");
+    for (size_t i = 0; i < classNameVector.size(); ++i) {
+        TracedDictionary<TracedArray<TracedValue> >& jsonClass = jsonClasses.beginDictionary();
+        jsonClass
+            .setString("name", classNameVector[i])
+            .setInteger("liveCount", info.liveCount[i])
+            .setInteger("deadCount", info.deadCount[i]);
+        TracedArray<TracedDictionary<TracedArray<TracedValue> > >& jsonGens = jsonClass.beginArray("generations");
+        for (size_t j = 0; j < heapObjectGenerations; ++j)
+            jsonGens.pushInteger(info.generations[i][j]);
+        jsonGens.endArray();
+        jsonClass.endDictionary();
+    }
+    jsonClasses.endArray();
+
+    TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(GC_PROFILE_GROUP, "ThreadState", this, json.finish());
+}
+#endif
+
 void ThreadState::pushWeakObjectPointerCallback(void* object, WeakPointerCallback callback)
 {
     CallbackStack::Item* slot = m_weakCallbackStack->allocateEntry(&m_weakCallbackStack);
     *slot = CallbackStack::Item(object, callback);
 }
 
 bool ThreadState::popAndInvokeWeakPointerCallback(Visitor* visitor)
 {
     return m_weakCallbackStack->popAndInvokeCallback(&m_weakCallbackStack, visitor);
 }
@@ skipping 275 matching lines @@
     for (size_t i = 0; i < slotCount; ++i) {
         m_safePointStackCopy[i] = from[i];
     }
 }
 
 void ThreadState::performPendingSweep()
 {
     if (!sweepRequested())
         return;
 
-    TRACE_EVENT0("blink", "ThreadState::performPendingSweep");
+#if GC_PROFILE_HEAP
+    // 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(GC_PROFILE_GROUP, &gcTracingEnabled);
+    if (gcTracingEnabled && m_stats.totalObjectSpace() > 0)
+        snapshot();
+#endif
+
+    TRACE_EVENT0(GC_PROFILE_GROUP, "ThreadState::performPendingSweep");
     ScriptForbiddenScope forbiddenScope;
 
     double timeStamp = WTF::currentTimeMS();
     const char* samplingState = TRACE_EVENT_GET_SAMPLING_STATE();
     if (isMainThread())
-        TRACE_EVENT_SET_SAMPLING_STATE("blink", "BlinkGCSweeping");
+        TRACE_EVENT_SET_SAMPLING_STATE(GC_PROFILE_GROUP, "BlinkGCSweeping");
 
     m_sweepInProgress = true;
     // Disallow allocation during weak processing.
     enterNoAllocationScope();
     // Perform thread-specific weak processing.
     while (popAndInvokeWeakPointerCallback(Heap::s_markingVisitor)) { }
     leaveNoAllocationScope();
     // Perform sweeping and finalization.
     m_stats.clear(); // Sweeping will recalculate the stats
     for (int i = 0; i < NumberOfHeaps; i++)
@@ skipping 40 matching lines @@
     ASSERT(!state->isAtSafePoint());
     state->safePoint(HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
-#if ENABLE(GC_TRACING)
+#if GC_PROFILE_MARKING
 const GCInfo* ThreadState::findGCInfoFromAllThreads(Address address)
 {
     bool needLockForIteration = !isAnyThreadInGC();
     if (needLockForIteration)
         threadAttachMutex().lock();
 
     ThreadState::AttachedThreadStateSet& threads = attachedThreads();
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
         if (const GCInfo* gcInfo = (*it)->findGCInfo(address)) {
             if (needLockForIteration)
                 threadAttachMutex().unlock();
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
+
 }