Oilpan: Add 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 38 matching lines @@
 #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>
 #endif
 
+#if ENABLE(GC_PROFILING)
+#include <limits>
+#endif
+
 #if OS(FREEBSD)
 #include <pthread_np.h>
 #endif
 
 namespace blink {
 
 static void* getStackStart()
 {
 #if defined(__GLIBC__) || OS(ANDROID) || OS(FREEBSD)
     pthread_attr_t attr;
@@ skipping 236 matching lines @@
     , m_sweepForbidden(false)
     , m_noAllocationCount(0)
     , m_isTerminating(false)
     , m_shouldFlushHeapDoesNotContainCache(false)
     , m_collectionRate(1.0)
     , m_gcState(NoGCScheduled)
     , m_traceDOMWrappers(nullptr)
 #if defined(ADDRESS_SANITIZER)
     , m_asanFakeStack(__asan_get_current_fake_stack())
 #endif
+#if ENABLE(GC_PROFILING)
+    , m_nextFreeListSnapshotTime(-std::numeric_limits<double>::infinity())
+#endif
 {
     checkThread();
     ASSERT(!**s_threadSpecific);
     **s_threadSpecific = this;
 
     if (isMainThread()) {
         s_mainThreadStackStart = reinterpret_cast<uintptr_t>(m_startOfStack) - sizeof(void*);
         s_mainThreadUnderestimatedStackSize = getUnderestimatedStackSize() - sizeof(void*);
     }
 
@@ skipping 756 matching lines @@
     } else {
         // The default behavior is lazy sweeping.
         setGCState(Sweeping);
     }
 #else
     // FIXME: For now, we disable lazy sweeping in non-oilpan builds
     // to avoid unacceptable behavior regressions on trunk.
     setGCState(Sweeping);
     completeSweep();
 #endif
+
+#if ENABLE(GC_PROFILING)
+    snapshotFreeListIfNecessary();
+#endif
 }
 
 void ThreadState::addInterruptor(Interruptor* interruptor)
 {
     checkThread();
     SafePointScope scope(HeapPointersOnStack, SafePointScope::AllowNesting);
     {
         MutexLocker locker(threadAttachMutex());
         m_interruptors.append(interruptor);
     }
@@ skipping 58 matching lines @@
         if (const GCInfo* gcInfo = state->findGCInfo(address)) {
             if (needLockForIteration)
                 threadAttachMutex().unlock();
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return nullptr;
 }
+
+void ThreadState::snapshotFreeListIfNecessary()
+{
+    bool enabled;
+    TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("blink_gc"), &enabled);
+    if (!enabled)
+        return;
+
+    static const double recordIntervalSeconds = 0.010;

[haraken, 2015/02/04 14:14:57]

I'm not sure if 10 ms is a good interval for snapshotting free lists since the
result would become non-deterministic. Probably would it be better to snapshot
free lists every time we allocate a new page?

[Yuta Kitamura, 2015/02/05 04:13:41]

snapshotFreeListIfNecessary() is called at the end of
postGCProcessing() and at the beginnng of ThreadHeap::
outOfLineAllocate(). 10ms check is done after that, i.e.
free lists are recorded only when these events have
happened *and* 10ms has passed after the last recording.

I'm not sure which events (postGCProcessing+outOfLineAlloc
or page allocation) are appropriate for a trigger, though.

Is it okay to commit the patch as-is and fix the trigger
condition later if necessary?

[haraken, 2015/02/05 04:15:46]

Sure. Let's fix it in a follow-up if necessary.

I'm not concerned about the overhead but am just wondering if an interval-based
profiling might lead to flakiness of the profiled results.

+    double now = monotonicallyIncreasingTime();
+    if (now > m_nextFreeListSnapshotTime) {
+        snapshotFreeList();
+        m_nextFreeListSnapshotTime = now + recordIntervalSeconds;
+    }
+}
+
+void ThreadState::snapshotFreeList()
+{
+    RefPtr<TracedValue> json = TracedValue::create();
+
+#define SNAPSHOT_FREE_LIST(HeapType)                            \
+    {                                                           \
+        json->beginDictionary();                                \
+        json->setString("name", #HeapType);                     \
+        m_heaps[HeapType##Heap]->snapshotFreeList(*json);       \
+        json->endDictionary();                                  \
+    }
+
+    json->beginArray("heaps");
+    SNAPSHOT_FREE_LIST(General);
+    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());
+}
 #endif
 
 } // namespace blink