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_cumulativeAllocationSize(0)
+    , m_allocationCount(0)
+    , m_inlineAllocationCount(0)
+#endif
 {
     clearFreeLists();
 }
 
 FreeList::FreeList()
     : m_biggestFreeListIndex(0)
 {
 }
 
 ThreadHeap::~ThreadHeap()
@@ skipping 48 matching lines @@
     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.setInteger("cumulativeAllocationSize", m_cumulativeAllocationSize);
+    json.setDouble("inlineAllocationRate", static_cast<double>(m_inlineAllocationCount) / m_allocationCount);
+    json.setInteger("inlineAllocationCount", m_inlineAllocationCount);
+    json.setInteger("allocationCount", m_allocationCount);
+    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);
+
+    FreeList::PerBucketFreeListStats bucketStats[blinkPageSizeLog2];
+    size_t totalFreeSize;
+    m_freeList.getFreeSizeStats(bucketStats, totalFreeSize);
+    json.setInteger("totalFreeSize", totalFreeSize);
+
+    json.beginArray("perBucketEntryCount");
+    for (size_t i = 0; i < blinkPageSizeLog2; ++i)
+        json.pushInteger(bucketStats[i].entryCount);
+    json.endArray();
+
+    json.beginArray("perBucketFreeSize");
+    for (size_t i = 0; i < blinkPageSizeLog2; ++i)
+        json.pushInteger(bucketStats[i].freeSize);
+    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::getFreeSizeStats(PerBucketFreeListStats bucketStats[], size_t& totalFreeSize) const
+{
+    totalFreeSize = 0;
+    for (size_t i = 0; i < blinkPageSizeLog2; i++) {
+        size_t& entryCount = bucketStats[i].entryCount;
+        size_t& freeSize = bucketStats[i].freeSize;
+        for (FreeListEntry* entry = m_freeLists[i]; entry; entry = entry->next()) {
+            ++entryCount;
+            freeSize += entry->size();
+        }
+        totalFreeSize += freeSize;
+    }
+}
+#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