Oilpan: Add free list profiler.

Source/platform/heap/Heap.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 530 matching lines @@
     : m_currentAllocationPoint(nullptr)
     , m_remainingAllocationSize(0)
     , m_lastRemainingAllocationSize(0)
     , m_firstPage(nullptr)
     , m_firstLargeObject(nullptr)
     , m_firstUnsweptPage(nullptr)
     , m_firstUnsweptLargeObject(nullptr)
     , m_threadState(state)
     , m_index(index)
     , m_promptlyFreedSize(0)
+#if ENABLE(GC_PROFILING)
+    , m_totalAllocationSize(0.0)

[haraken, 2015/02/04 07:30:00]

Where is this used?

+    , m_allocationCount(0)

[haraken, 2015/02/04 07:30:00]

Ditto.

+    , m_inlineAllocationCount(0)

[haraken, 2015/02/04 07:30:00]

Ditto.

+    , m_allocationPointSizeSum(0)
+    , m_setAllocationPointCount(0)
+#endif
 {
     clearFreeLists();
 }
 
 FreeList::FreeList()
     : m_biggestFreeListIndex(0)
 {
 }
 
 ThreadHeap::~ThreadHeap()
@@ skipping 36 matching lines @@
 void ThreadHeap::setAllocationPoint(Address point, size_t size)
 {
 #if ENABLE(ASSERT)
     if (point) {
         ASSERT(size);
         BaseHeapPage* page = pageFromObject(point);
         ASSERT(!page->isLargeObject());
         ASSERT(size <= static_cast<HeapPage*>(page)->payloadSize());
     }
 #endif
+#if ENABLE(GC_PROFILING)
+    m_allocationPointSizeSum += size;
+    ++m_setAllocationPointCount;
+#endif
     if (hasCurrentAllocationArea())
         addToFreeList(currentAllocationPoint(), remainingAllocationSize());
     updateRemainingAllocationSize();
     m_currentAllocationPoint = point;
     m_lastRemainingAllocationSize = m_remainingAllocationSize = size;
 }
 
 Address ThreadHeap::outOfLineAllocate(size_t allocationSize, size_t gcInfoIndex)
 {
     ASSERT(allocationSize > remainingAllocationSize());
     ASSERT(allocationSize >= allocationGranularity);
 
+#if ENABLE(GC_PROFILING)
+    m_threadState->snapshotFreeListIfNecessary();
+#endif
+
     // 1. If this allocation is big enough, allocate a large object.
     if (allocationSize >= largeObjectSizeThreshold)
         return allocateLargeObject(allocationSize, gcInfoIndex);
 
     // 2. Check if we should trigger a GC.
     updateRemainingAllocationSize();
     threadState()->scheduleGCOrForceConservativeGCIfNeeded();
 
     // 3. Try to allocate from a free list.
     Address result = allocateFromFreeList(allocationSize, gcInfoIndex);
@@ skipping 857 matching lines @@
         m_firstUnsweptLargeObject = nullptr;
     }
     ASSERT(!m_firstUnsweptLargeObject);
 }
 
 void ThreadHeap::clearFreeLists()
 {
     m_freeList.clear();
 }
 
+#if ENABLE(GC_PROFILING)
+void ThreadHeap::snapshotFreeList(TracedValue& json)
+{
+    json.setDouble("totalAllocationSize", m_totalAllocationSize);

[keishi, 2015/02/04 06:58:26]

nit: I think this could be renamed to cummulativeAllocationSize to make the
distinction from s_allocatedObjectSize clearer.

[Yuta Kitamura, 2015/02/04 09:45:42]

Fixed. Can you fix your dashboard code, too?

[keishi, 2015/02/04 11:05:39]

Done.

+    json.setDouble("inlineAllocationRate", static_cast<double>(m_inlineAllocationCount) / m_allocationCount);
+    json.setInteger("inlineAllocationCount", m_inlineAllocationCount);
+    json.setInteger("allocationCount", m_allocationCount);
+    if (m_setAllocationPointCount > 0)
+        json.setDouble("averageAllocationPointSize", static_cast<double>(m_allocationPointSizeSum) / m_setAllocationPointCount);

[keishi, 2015/02/04 06:58:26]

averageAllocationPointSize hasn't been a useful metric so far so I think we
should remove it.

[haraken, 2015/02/04 07:30:00]

Agreed. Also I'm not sure how helpful m_setAllocationPointCount is.

[Yuta Kitamura, 2015/02/04 09:45:42]

Done, m_allocationPointSizeSum and m_setAllocationPointCount are
removed too.

+    m_allocationPointSizeSum = 0;
+    m_setAllocationPointCount = 0;
+    size_t pageCount = 0;
+    size_t totalPageSize = 0;
+    for (HeapPage* page = m_firstPage; page; page = page->next()) {
+        ++pageCount;
+        totalPageSize += page->payloadSize();
+    }
+    json.setInteger("pageCount", pageCount);
+    json.setInteger("totalPageSize", totalPageSize);
+    size_t bucketSizes[blinkPageSizeLog2];
+    size_t bucketTotalSizes[blinkPageSizeLog2];

[keishi, 2015/02/04 06:58:26]

I'm sorry. bucketSizes and bucketTotalSizes were horrible names. Hard to
understand the difference between them. bucketSizes should be something like
entryCountPerBucket. And bucketTotalSizes should be something like
totalFreeSizePerBucket.

[Yuta Kitamura, 2015/02/04 09:45:42]

Fixed, can you take another look at this version?
I've introduced struct PerBucketFreeListStats so people
can understand what each value means...

Metrics names renamed:
"bucketSizes" -> "perBucketEntryCount"
"bucketTotalSizes" -> "perBucketFreeSize"

If this looks okay to you, can you apply the change
to your dashboard?

[keishi, 2015/02/04 11:05:39]

Thanks, this is much better. Done.

+    size_t freeSize;
+    m_freeList.countBucketSizes(bucketSizes, bucketTotalSizes, freeSize);
+    json.setInteger("freeSize", freeSize);
+
+    json.beginArray("bucketSizes");
+    for (size_t i = 0; i < blinkPageSizeLog2; ++i)
+        json.pushInteger(bucketSizes[i]);
+    json.endArray();
+
+    json.beginArray("bucketTotalSizes");
+    for (size_t i = 0; i < blinkPageSizeLog2; ++i)
+        json.pushInteger(bucketTotalSizes[i]);
+    json.endArray();
+}
+#endif
+
 void FreeList::clear()
 {
     m_biggestFreeListIndex = 0;
     for (size_t i = 0; i < blinkPageSizeLog2; ++i)
         m_freeLists[i] = nullptr;
 }
 
 int FreeList::bucketIndexForSize(size_t size)
 {
     ASSERT(size > 0);
     int index = -1;
     while (size) {
         size >>= 1;
         index++;
     }
     return index;
 }
 
+#if ENABLE(GC_PROFILING)
+void FreeList::countBucketSizes(size_t sizes[], size_t totalSizes[], size_t& freeSize) const
+{
+    freeSize = 0;
+    for (size_t i = 0; i < blinkPageSizeLog2; i++) {
+        sizes[i] = 0;
+        totalSizes[i] = 0;
+        for (FreeListEntry* entry = m_freeLists[i]; entry; entry = entry->next()) {
+            ++sizes[i];
+            freeSize += entry->size();
+            totalSizes[i] += entry->size();
+        }
+    }
+}
+#endif
+
 HeapPage::HeapPage(PageMemory* storage, ThreadHeap* heap)
     : BaseHeapPage(storage, heap)
     , m_next(nullptr)
 {
     m_objectStartBitMapComputed = false;
     ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
 }
 
 size_t HeapPage::objectPayloadSizeForTesting()
 {
@@ skipping 1190 matching lines @@
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = nullptr;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 } // namespace blink