Oilpan: Implement mark/sweep stats collection for free list profiler.

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 652 matching lines @@
             json->pushInteger(info.generations[i][j]);
         json->endArray();
         json->endDictionary();
     }
     json->endArray();
     json->setInteger("liveSize", liveSize);
     json->setInteger("deadSize", deadSize);
 
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID("blink_gc", "ThreadState", this, json.release());
 }
+
+void ThreadState::incrementMarkedObjectsAge()
+{
+    for (int i = 0; i < NumberOfHeaps; ++i)
+        m_heaps[i]->incrementMarkedObjectsAge();
+}
 #endif
 
 void ThreadState::pushWeakPointerCallback(void* object, WeakPointerCallback callback)
 {
     CallbackStack::Item* slot = m_weakCallbackStack->allocateEntry();
     *slot = CallbackStack::Item(object, callback);
 }
 
 bool ThreadState::popAndInvokeWeakPointerCallback(Visitor* visitor)
 {
@@ skipping 300 matching lines @@
     makeConsistentForSweeping();
     prepareRegionTree();
     flushHeapDoesNotContainCacheIfNeeded();
     if (isMainThread())
         m_allocatedObjectSizeBeforeGC = Heap::allocatedObjectSize() + Heap::markedObjectSize();
 }
 
 void ThreadState::postGC(GCType gcType)
 {
     ASSERT(isInGC());
+
+#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);
+
+        snapshot();
+        if (disabledByDefaultGCTracingEnabled)
+            collectAndReportMarkSweepStats();
+        incrementMarkedObjectsAge();
+    }
+#endif
+
     setGCState(gcType == GCWithSweep ? EagerSweepScheduled : LazySweepScheduled);
     for (int i = 0; i < NumberOfHeaps; i++)
         m_heaps[i]->prepareForSweep();
 }
 
 void ThreadState::prepareHeapForTermination()
 {
     checkThread();
     for (int i = 0; i < NumberOfHeaps; ++i)
         m_heaps[i]->prepareHeapForTermination();
@@ skipping 120 matching lines @@
 }
 
 void ThreadState::postGCProcessing()
 {
     checkThread();
     if (gcState() != EagerSweepScheduled && gcState() != LazySweepScheduled)
         return;
 
     m_didV8GCAfterLastGC = false;
 
-#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)
-        snapshot();
-#endif
-
     {
         if (isMainThread())
             ScriptForbiddenScope::enter();
 
         SweepForbiddenScope forbiddenScope(this);
         {
             // Disallow allocation during weak processing.
             NoAllocationScope noAllocationScope(this);
             {
                 TRACE_EVENT0("blink_gc", "ThreadState::threadLocalWeakProcessing");
@@ skipping 140 matching lines @@
     SNAPSHOT_FREE_LIST(VectorBacking);
     SNAPSHOT_FREE_LIST(InlineVectorBacking);
     SNAPSHOT_FREE_LIST(HashTableBacking);
     FOR_EACH_TYPED_HEAP(SNAPSHOT_FREE_LIST);
     json->endArray();
 
 #undef SNAPSHOT_FREE_LIST
 
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("blink_gc"), "FreeList", this, json.release());
 }
+
+void ThreadState::collectAndReportMarkSweepStats() const
+{
+    if (!isMainThread())

[haraken, 2015/02/06 06:39:20]

Why do we need to have the isMainThread check? ThreadState::postGC() is called
only by one GCing thread (which may not be the main thread), meaning that
collectAndReportMarkSweepStats() is called only by the thread. Thus we don't
need to worry about thread races.

[Yuta Kitamura, 2015/02/06 07:45:45]

The reason is that data from non-main thread makes
the graph look strange (many objects are marked/swept in
main threads, while almost zero objects are marked/swept
in non-main threads, making the graph look zig-zag).

In the long term, we could extend the data format and
keishi's dashboard to allow thread-specific counts, but
that's something that we don't have right now AFAIK.

[haraken, 2015/02/06 07:51:50]

Thanks, makes sense.

[keishi, 2015/02/06 08:21:07]

All records in the trace json file have tid fields and I did write code to
filter out non main thread records. If this makes a difference I think that
would be a bug in my viewer.

+        return;
+
+    ClassAgeCountsMap markingClassAgeCounts;
+    for (int i = 0; i < NumberOfHeaps; ++i)
+        m_heaps[i]->countMarkedObjects(markingClassAgeCounts);
+    reportMarkSweepStats("MarkingStats", markingClassAgeCounts);
+
+    ClassAgeCountsMap sweepingClassAgeCounts;
+    for (int i = 0; i < NumberOfHeaps; ++i)
+        m_heaps[i]->countObjectsToSweep(sweepingClassAgeCounts);
+    reportMarkSweepStats("SweepingStats", sweepingClassAgeCounts);
+}
+
+void ThreadState::reportMarkSweepStats(const char* statsName, const ClassAgeCountsMap& classAgeCounts) const
+{
+    RefPtr<TracedValue> json = TracedValue::create();
+    for (ClassAgeCountsMap::const_iterator it = classAgeCounts.begin(), end = classAgeCounts.end(); it != end; ++it) {
+        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