Add a UseCounter that measures the amount of memory used in PartitionAlloc

Source/wtf/Partitions.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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "wtf/Partitions.h"
 
 #include "wtf/DefaultAllocator.h"
 #include "wtf/FastMalloc.h"
+#include "wtf/MainThread.h"
 
 namespace WTF {
 
 bool Partitions::s_initialized;
 
 PartitionAllocatorGeneric Partitions::m_fastMallocAllocator;
 PartitionAllocatorGeneric Partitions::m_bufferAllocator;
 SizeSpecificPartitionAllocator<3328> Partitions::m_objectModelAllocator;
 SizeSpecificPartitionAllocator<1024> Partitions::m_renderingAllocator;
+HistogramEnumerationFunction Partitions::m_histogramEnumeration = nullptr;
 
-void Partitions::initialize()
+void Partitions::initialize(HistogramEnumerationFunction histogramEnumeration)
 {
     static int lock = 0;
     // Guard against two threads hitting here in parallel.
     spinLockLock(&lock);
     if (!s_initialized) {
-        m_fastMallocAllocator.init();
-        m_bufferAllocator.init();
-        m_objectModelAllocator.init();
-        m_renderingAllocator.init();
+        m_fastMallocAllocator.init(Partitions::notifyCommittedMemoryChanged);
+        m_bufferAllocator.init(Partitions::notifyCommittedMemoryChanged);
+        m_objectModelAllocator.init(Partitions::notifyCommittedMemoryChanged);
+        m_renderingAllocator.init(Partitions::notifyCommittedMemoryChanged);
+        m_histogramEnumeration = histogramEnumeration;
         s_initialized = true;
     }
     spinLockUnlock(&lock);
 }
 
 void Partitions::shutdown()
 {
     // We could ASSERT here for a memory leak within the partition, but it leads
     // to very hard to diagnose ASSERTs, so it's best to leave leak checking for
     // the valgrind and heapcheck bots, which run without partitions.
     (void) m_renderingAllocator.shutdown();
     (void) m_objectModelAllocator.shutdown();
     (void) m_bufferAllocator.shutdown();
     (void) m_fastMallocAllocator.shutdown();
 }
 
+void Partitions::notifyCommittedMemoryChanged()
+{
+    static size_t supportedMaxSizeInMB = 4 * 1024;
+    static size_t observedMaxSizeInMB = 0;
+
+    if (!m_histogramEnumeration)
+        return;
+    // We only report the memory in the main thread.
+    if (!isMainThread())
+        return;
+    // +1 is for rounding up the sizeInMB.
+    size_t sizeInMB = Partitions::totalSizeOfCommittedPages() / 1024 / 1024 + 1;
+    if (sizeInMB >= supportedMaxSizeInMB)
+        sizeInMB = supportedMaxSizeInMB - 1;
+    if (sizeInMB > observedMaxSizeInMB) {
+        // Send a UseCounter only when we see the highest memory usage
+        // we've ever seen.
+        m_histogramEnumeration("PartitionAlloc.CommittedSize", sizeInMB, supportedMaxSizeInMB);

[Chris Evans, 2015/04/06 04:39:53]

Hmm! Can we be sure that this histogram enumeration function will never itself
try and call PartitionAlloc? Re-entrancy here would be illegal.

[haraken, 2015/04/06 06:14:14]

It can potentially be re-entered, but is it really concerning? Even if that
happens, it will just reports two UseCounters for the same CommittedSize.

I can add a thread-safe flag to histogramEnumerationFunction() in WebKit.cpp to
prevent the re-entrancy, but I'm not sure if we really need this. As far as I
look at the implementation of histogramEnumeration, it looks like
re-entrant-safe.

+        observedMaxSizeInMB = sizeInMB;
+    }
+}
+
 } // namespace WTF