Adding freelist statistics to blink gc dump provider.

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 638 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);
 
+    void takeSnapshot(const String& dumpBaseName);
 #if ENABLE(GC_PROFILING)
     struct PerBucketFreeListStats {
         size_t entryCount;
         size_t freeSize;
 
         PerBucketFreeListStats() : entryCount(0), freeSize(0) { }
     };
 
     void getFreeSizeStats(PerBucketFreeListStats bucketStats[], size_t& totalSize) const;
 #endif
@@ skipping 17 matching lines @@
 class PLATFORM_EXPORT BaseHeap {
 public:
     BaseHeap(ThreadState*, int);
     virtual ~BaseHeap();
     void cleanupPages();
 
     void takeSnapshot(const String& dumpBaseName);
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     BasePage* findPageFromAddress(Address);
 #endif
+    virtual void takeFreelistSnapshot(String dumpBaseName) { };
 #if ENABLE(GC_PROFILING)
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
     virtual void snapshotFreeList(TracedValue&) { };
 
     void countMarkedObjects(ClassAgeCountsMap&) const;
     void countObjectsToSweep(ClassAgeCountsMap&) const;
     void incrementMarkedObjectsAge();
 #endif
 
     virtual void clearFreeLists() { }
@@ skipping 39 matching lines @@
     {
         ASSERT(findPageFromAddress(address));
         ASSERT(findPageFromAddress(address + size - 1));
         m_freeList.addToFreeList(address, size);
     }
     virtual void clearFreeLists() override;
 #if ENABLE(ASSERT)
     virtual bool isConsistentForGC() override;
     bool pagesToBeSweptContains(Address);
 #endif
+    void takeFreelistSnapshot(String dumpBaseName) override;
 #if ENABLE(GC_PROFILING)
     void snapshotFreeList(TracedValue&) override;
 #endif
 
     Address allocateObject(size_t allocationSize, size_t gcInfoIndex);
 
     void freePage(NormalPage*);
 
     bool coalesce();
     void promptlyFreeObject(HeapObjectHeader*);
@@ skipping 13 matching lines @@
     Address allocateFromFreeList(size_t, size_t gcInfoIndex);
 
     FreeList m_freeList;
     Address m_currentAllocationPoint;
     size_t m_remainingAllocationSize;
     size_t m_lastRemainingAllocationSize;
 
     // The size of promptly freed objects in the heap.
     size_t m_promptlyFreedSize;
 
-#if ENABLE(GC_PROFILING)
     size_t m_cumulativeAllocationSize;
     size_t m_allocationCount;
     size_t m_inlineAllocationCount;
-#endif
 };
 
 class LargeObjectHeap final : public BaseHeap {
 public:
     LargeObjectHeap(ThreadState*, int);
     Address allocateLargeObjectPage(size_t, size_t gcInfoIndex);
     void freeLargeObjectPage(LargeObjectPage*);
 #if ENABLE(ASSERT)
     virtual bool isConsistentForGC() override { return true; }
 #endif
@@ skipping 500 matching lines @@
 NO_SANITIZE_ADDRESS inline
 void HeapObjectHeader::markDead()
 {
     checkHeader();
     ASSERT(!isMarked());
     m_encoded |= headerDeadBitMask;
 }
 
 inline Address NormalPageHeap::allocateObject(size_t allocationSize, size_t gcInfoIndex)
 {
-#if ENABLE(GC_PROFILING)

[haraken, 2015/06/23 05:38:58]

This function is performance-sensitive and we don't want to add extra overhead.
Shall we drop this change at least from this change? i.e., we want to keep these
variables only in GC_PROFILING.

[ssid, 2015/06/23 06:03:39]

This means that these values will never be added to trace. Should I have
GC_PROFILING macro in the dumper also, so that these will be added when the flag
is enabled? primiano@ WDYT?

[haraken, 2015/06/23 06:24:24]

Yeah, it's a bit unfortunate we can't have the values in the trace, but I'd
suggest revisiting the issue later. We need to study performance to add the
values. IMO, these values are not that important to understand Oilpan's
workload.

GC_PROFILING builds are super heavy, so it's not an option to enable it on trunk
:-/

[ssid, 2015/06/23 07:39:56]

Okay, removing it.

     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 57 matching lines @@
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
 } // namespace blink
 
 #endif // Heap_h