Profile FreeList

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 22 matching lines @@
 
 #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 "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
 #include "wtf/ThreadingPrimitives.h"
-#if ENABLE(GC_PROFILE_HEAP)
+#if ENABLE(GC_PROFILE_HEAP) || ENABLE(GC_PROFILE_FREE_LIST)
 #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
@@ skipping 558 matching lines @@
 const GCInfo* ThreadState::findGCInfo(Address address)
 {
     BaseHeapPage* page = pageFromAddress(address);
     if (page) {
         return page->findGCInfo(address);
     }
     return 0;
 }
 #endif
 
+#if ENABLE(GC_PROFILE_FREE_LIST)
+
+void ThreadState::snapshotFreeListIfNecessary()

[keishi, 2015/01/27 08:59:00]

Call when a snapshot could be recorded to the tracing json file.
Throttles to record only every 0.01 seconds.

+{
+    //bool gcTracingEnabled;
+    //TRACE_EVENT_CATEGORY_GROUP_ENABLED("blink_gc", &gcTracingEnabled);
+    //if (!gcTracingEnabled)
+    //    return;
+    const double kRecordInterval = 0.010; // seconds
+    static double nextRecordTime = monotonicallyIncreasingTime() + kRecordInterval;
+    if (monotonicallyIncreasingTime() > nextRecordTime) {
+        snapshotFreeList();
+        nextRecordTime = monotonicallyIncreasingTime() + kRecordInterval;
+    }
+}
+
+void ThreadState::snapshotFreeList()

[keishi, 2015/01/27 08:59:00]

Records the stats from the heap.

+{
+    RefPtr<TracedValue> json = TracedValue::create();
+
+#define SNAPSHOT_FREE_LIST(HeapType)                                       \
+    {                                                                      \
+        json->beginDictionary();                                           \
+        json->setString("name", #HeapType);                                \
+        m_heaps[HeapType##Heap]->snapshotFreeList(json.get());             \
+        json->endDictionary();                                             \
+        json->beginDictionary();                                           \
+        json->setString("name", #HeapType"NonFinalized");                  \
+        m_heaps[HeapType##HeapNonFinalized]->snapshotFreeList(json.get()); \
+        json->endDictionary();                                             \
+    }
+    json->beginArray("heaps");
+    SNAPSHOT_FREE_LIST(General1);
+    SNAPSHOT_FREE_LIST(General2);
+    SNAPSHOT_FREE_LIST(General3);
+    SNAPSHOT_FREE_LIST(General4);
+    SNAPSHOT_FREE_LIST(VectorBacking);
+    SNAPSHOT_FREE_LIST(HashTableBacking);
+    FOR_EACH_TYPED_HEAP(SNAPSHOT_FREE_LIST);
+    json->endArray();
+#undef SNAPSHOT_FREE_LIST
+
+    TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID("blink_gc", "FreeList", this, json.release());
+}
+
+#endif
+
 #if ENABLE(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);
         liveSize.append(0);
         deadSize.append(0);
         generations.append(Vector<int, 8>());
@@ skipping 376 matching lines @@
     m_safePointStackCopy.resize(slotCount);
     for (size_t i = 0; i < slotCount; ++i) {
         m_safePointStackCopy[i] = from[i];
     }
 }
 
 void ThreadState::performPendingSweep()
 {
     if (!sweepRequested())
         return;
-
+    Heap::reportSweepingStats();

[keishi, 2015/01/27 08:59:00]

Report stats on the objects that will be sweeped.

 #if ENABLE(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("blink_gc", &gcTracingEnabled);
     if (gcTracingEnabled)
         snapshot();
 #endif
 
@@ skipping 54 matching lines @@
         m_lowCollectionRate = Heap::markedObjectSize() > (allocatedObjectSizeBeforeSweeping / 2);
 
     if (Platform::current()) {
         Platform::current()->histogramCustomCounts("BlinkGC.PerformPendingSweep", WTF::currentTimeMS() - timeStamp, 0, 10 * 1000, 50);
     }
 
     if (isMainThread()) {
         TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(samplingState);
         ScriptForbiddenScope::exit();
     }
+#if ENABLE(GC_PROFILE_FREE_LIST)
+    snapshotFreeListIfNecessary();
+#endif
 }
 
 void ThreadState::addInterruptor(Interruptor* interruptor)
 {
     SafePointScope scope(HeapPointersOnStack, SafePointScope::AllowNesting);
 
     {
         MutexLocker locker(threadAttachMutex());
         m_interruptors.append(interruptor);
     }
@@ skipping 60 matching lines @@
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
 
 } // namespace blink