Oilpan: Add free list profiler.

Source/platform/heap/Heap.h

 /*
  * 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 687 matching lines @@
 public:
     FreeList();
 
     void addToFreeList(Address, size_t);
     void clear();
 
     // Returns a bucket number for inserting a FreeListEntry of a given size.
     // All FreeListEntries in the given bucket, n, have size >= 2^n.
     static int bucketIndexForSize(size_t);
 
+#if ENABLE(GC_PROFILING)
+    struct PerBucketFreeListStats {
+        size_t entryCount;
+        size_t freeSize;
+    };
+
+    void getFreeSizeStats(PerBucketFreeListStats bucketStats[], size_t& totalSize) const;
+#endif
+
 private:
     int m_biggestFreeListIndex;
 
     // All FreeListEntries in the nth list have size >= 2^n.
     FreeListEntry* m_freeLists[blinkPageSizeLog2];
 
     friend class ThreadHeap;
 };
 
 // Thread heaps represent a part of the per-thread Blink heap.
@@ skipping 47 matching lines @@
     void completeSweep();
 
     void freePage(HeapPage*);
     void freeLargeObject(LargeObject*);
 
     void promptlyFreeObject(HeapObjectHeader*);
     bool expandObject(HeapObjectHeader*, size_t);
     void shrinkObject(HeapObjectHeader*, size_t);
     void decreasePromptlyFreedSize(size_t size) { m_promptlyFreedSize -= size; }
 
+#if ENABLE(GC_PROFILING)
+    void snapshotFreeList(TracedValue&);
+#endif
+
 private:
     Address outOfLineAllocate(size_t allocationSize, size_t gcInfoIndex);
     Address currentAllocationPoint() const { return m_currentAllocationPoint; }
     size_t remainingAllocationSize() const { return m_remainingAllocationSize; }
     bool hasCurrentAllocationArea() const { return currentAllocationPoint() && remainingAllocationSize(); }
     inline void setAllocationPoint(Address, size_t);
     void updateRemainingAllocationSize();
     Address allocateFromFreeList(size_t, size_t gcInfoIndex);
     Address lazySweepPages(size_t, size_t gcInfoIndex);
     bool lazySweepLargeObjects(size_t);
@@ skipping 22 matching lines @@
     ThreadState* m_threadState;
 
     FreeList m_freeList;
 
     // Index into the page pools.  This is used to ensure that the pages of the
     // same type go into the correct page pool and thus avoid type confusion.
     int m_index;
 
     // The size of promptly freed objects in the heap.
     size_t m_promptlyFreedSize;
+
+#if ENABLE(GC_PROFILING)
+    double m_cumulativeAllocationSize;

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

double => size_t ?

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

Done.

+    size_t m_allocationCount;
+    size_t m_inlineAllocationCount;
+#endif
 };
 
 // Mask an address down to the enclosing oilpan heap base page.  All oilpan heap
 // pages are aligned at blinkPageBase plus an OS page size.
 // FIXME: Remove PLATFORM_EXPORT once we get a proper public interface to our
 // typed heaps.  This is only exported to enable tests in HeapTest.cpp.
 PLATFORM_EXPORT inline BaseHeapPage* pageFromObject(const void* object)
 {
     Address address = reinterpret_cast<Address>(const_cast<void*>(object));
     BaseHeapPage* page = reinterpret_cast<BaseHeapPage*>(blinkPageAddress(address) + WTF::kSystemPageSize);
@@ skipping 498 matching lines @@
 
     // Add space for header.
     size_t allocationSize = size + sizeof(HeapObjectHeader);
     // Align size with allocation granularity.
     allocationSize = (allocationSize + allocationMask) & ~allocationMask;
     return allocationSize;
 }
 
 Address ThreadHeap::allocateObject(size_t allocationSize, size_t gcInfoIndex)
 {
+#if ENABLE(GC_PROFILING)
+    m_cumulativeAllocationSize += allocationSize;
+    ++m_allocationCount;
+#endif
+
     if (LIKELY(allocationSize <= m_remainingAllocationSize)) {
+#if ENABLE(GC_PROFILING)
+        ++m_inlineAllocationCount;
+#endif
         Address headerAddress = m_currentAllocationPoint;
         m_currentAllocationPoint += allocationSize;
         m_remainingAllocationSize -= allocationSize;
         ASSERT(gcInfoIndex > 0);
         new (NotNull, headerAddress) HeapObjectHeader(allocationSize, gcInfoIndex);
         Address result = headerAddress + sizeof(HeapObjectHeader);
         ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
 
         // Unpoison the memory used for the object (payload).
         ASAN_UNPOISON_MEMORY_REGION(result, allocationSize - sizeof(HeapObjectHeader));
@@ skipping 1076 matching lines @@
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity>> : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity>> : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V>> : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator>> { };
 
 } // namespace blink
 
 #endif // Heap_h