Add partitionsOutOfMemoryUsingXXX to know Blink memory usage from OOM crash reports

Source/wtf/PartitionAlloc.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 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * 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/PartitionAlloc.h"
+#include "wtf/Partitions.h"

[haraken, 2015/09/03 10:53:43]

We don't want to add this dependency -- PartitionAlloc should be standalone.

Shall we define the OOM-handling function in Partitions.h (or somewhere) and
pass in the function pointer to PartitionAlloc.h?

[tasak, 2015/09/04 05:17:04]

Done.

 
 #include <string.h>
 
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 // Two partition pages are used as guard / metadata page so make sure the super
 // page size is bigger.
 static_assert(WTF::kPartitionPageSize * 4 <= WTF::kSuperPageSize, "ok super page size");
@@ skipping 249 matching lines @@
     return !foundLeak;
 }
 
 #if !CPU(64BIT)
 static NEVER_INLINE void partitionOutOfMemoryWithLotsOfUncommitedPages()
 {
     IMMEDIATE_CRASH();
 }
 #endif
 
-static NEVER_INLINE void partitionOutOfMemory(const PartitionRootBase* root)
+static NEVER_INLINE void parititionOutOfMemoryUsing2G()
+{
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void parititionOutOfMemoryUsing1G()
+{
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void parititionOutOfMemoryUsing512M()
+{
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void parititionOutOfMemoryUsing256M()
+{
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void parititionOutOfMemoryUsing128M()
+{
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void parititionOutOfMemoryUsing64M()
+{
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void parititionOutOfMemoryUsing32M()
+{
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void parititionOutOfMemoryUsing16M()
+{
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void parititionOutOfMemoryUsingLessThan16M()
+{
+    IMMEDIATE_CRASH();
+}
+
+static void partitionOutOfMemory(const PartitionRootBase* root)
 {
 #if !CPU(64BIT)
     // Check whether this OOM is due to a lot of super pages that are allocated
     // but not committed, probably due to http://crbug.com/421387.
     if (root->totalSizeOfSuperPages + root->totalSizeOfDirectMappedPages - root->totalSizeOfCommittedPages > kReasonableSizeOfUnusedPages) {
         partitionOutOfMemoryWithLotsOfUncommitedPages();
     }
 #endif
-    IMMEDIATE_CRASH();
+    size_t totalUsage = Partitions::totalSizeOfCommittedPages();
+    if (totalUsage > 2UL * 1024 * 1024 * 1024)
+        parititionOutOfMemoryUsing2G();
+    if (totalUsage > 1UL * 1024 * 1024 * 1024)
+        parititionOutOfMemoryUsing1G();
+    if (totalUsage > 512 * 1024 * 1024)
+        parititionOutOfMemoryUsing512M();
+    if (totalUsage > 256 * 1024 * 1024)
+        parititionOutOfMemoryUsing256M();
+    if (totalUsage > 128 * 1024 * 1024)
+        parititionOutOfMemoryUsing128M();
+    if (totalUsage > 64 * 1024 * 1024)
+        parititionOutOfMemoryUsing64M();
+    if (totalUsage > 32 * 1024 * 1024)
+        parititionOutOfMemoryUsing32M();
+    if (totalUsage > 16 * 1024 * 1024)
+        parititionOutOfMemoryUsing16M();
+    parititionOutOfMemoryUsingLessThan16M();
 }
 
 static NEVER_INLINE void partitionExcessiveAllocationSize()
 {
     IMMEDIATE_CRASH();
 }
 
 static NEVER_INLINE void partitionBucketFull()
 {
     IMMEDIATE_CRASH();
@@ skipping 1074 matching lines @@
             partitionStats.totalDiscardableBytes += memoryStats[i].discardableBytes;
             if (!isLightDump)
                 partitionStatsDumper->partitionsDumpBucketStats(partitionName, &memoryStats[i]);
         }
     }
     partitionStatsDumper->partitionDumpTotals(partitionName, &partitionStats);
 }
 
 } // namespace WTF