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 13 matching lines @@
  * 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/Alias.h"
+#include "wtf/Partitions.h"
+
 #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");
 static_assert(!(WTF::kSuperPageSize % WTF::kPartitionPageSize), "ok super page multiple");
 // Four system pages gives us room to hack out a still-guard-paged piece
 // of metadata in the middle of a guard partition page.
 static_assert(WTF::kSystemPageSize * 4 <= WTF::kPartitionPageSize, "ok partition page size");
 static_assert(!(WTF::kPartitionPageSize % WTF::kSystemPageSize), "ok partition page multiple");
 static_assert(sizeof(WTF::PartitionPage) <= WTF::kPageMetadataSize, "PartitionPage should not be too big");
 static_assert(sizeof(WTF::PartitionBucket) <= WTF::kPageMetadataSize, "PartitionBucket should not be too big");
 static_assert(sizeof(WTF::PartitionSuperPageExtentEntry) <= WTF::kPageMetadataSize, "PartitionSuperPageExtentEntry should not be too big");
 static_assert(WTF::kPageMetadataSize * WTF::kNumPartitionPagesPerSuperPage <= WTF::kSystemPageSize, "page metadata fits in hole");
 // Check that some of our zanier calculations worked out as expected.
 static_assert(WTF::kGenericSmallestBucket == 8, "generic smallest bucket");
 static_assert(WTF::kGenericMaxBucketed == 983040, "generic max bucketed");
 
 namespace WTF {
 
 int PartitionRootBase::gInitializedLock = 0;
 bool PartitionRootBase::gInitialized = false;
 PartitionPage PartitionRootBase::gSeedPage;
 PartitionBucket PartitionRootBase::gPagedBucket;
+size_t (*PartitionRootBase::gMemoryUsageReportFunction)() = nullptr;
 
 static uint16_t partitionBucketNumSystemPages(size_t size)
 {
     // This works out reasonably for the current bucket sizes of the generic
     // allocator, and the current values of partition page size and constants.
     // Specifically, we have enough room to always pack the slots perfectly into
     // some number of system pages. The only waste is the waste associated with
     // unfaulted pages (i.e. wasted address space).
     // TODO: we end up using a lot of system pages for very small sizes. For
     // example, we'll use 12 system pages for slot size 24. The slot size is
@@ skipping 59 matching lines @@
 
 static void partitionBucketInitBase(PartitionBucket* bucket, PartitionRootBase* root)
 {
     bucket->activePagesHead = &PartitionRootGeneric::gSeedPage;
     bucket->emptyPagesHead = 0;
     bucket->decommittedPagesHead = 0;
     bucket->numFullPages = 0;
     bucket->numSystemPagesPerSlotSpan = partitionBucketNumSystemPages(bucket->slotSize);
 }
 
+void partitionAllocGlobalInit(size_t (*memoryUsageReportFunc)())
+{
+    PartitionRootBase::gMemoryUsageReportFunction = memoryUsageReportFunc;
+}
+
 void partitionAllocInit(PartitionRoot* root, size_t numBuckets, size_t maxAllocation)
 {
     partitionAllocBaseInit(root);
 
     root->numBuckets = numBuckets;
     root->maxAllocation = maxAllocation;
     size_t i;
     for (i = 0; i < root->numBuckets; ++i) {
         PartitionBucket* bucket = &root->buckets()[i];
         if (!i)
@@ skipping 141 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 partitionOutOfMemoryUsing2G()
+{
+    const void* signature = (void*)&partitionOutOfMemoryUsing2G;
+    alias(signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionOutOfMemoryUsing1G()
+{
+    const void* signature = (void*)&partitionOutOfMemoryUsing1G;
+    alias(signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionOutOfMemoryUsing512M()
+{
+    const void* signature = (void*)&partitionOutOfMemoryUsing512M;
+    alias(signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionOutOfMemoryUsing256M()
+{
+    const void* signature = (void*)&partitionOutOfMemoryUsing256M;
+    alias(signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionOutOfMemoryUsing128M()
+{
+    const void* signature = (void*)&partitionOutOfMemoryUsing128M;
+    alias(signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionOutOfMemoryUsing64M()
+{
+    const void* signature = (void*)&partitionOutOfMemoryUsing64M;
+    alias(signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionOutOfMemoryUsing32M()
+{
+    const void* signature = (void*)&partitionOutOfMemoryUsing32M;
+    alias(signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionOutOfMemoryUsing16M()
+{
+    const void* signature = (void*)&partitionOutOfMemoryUsing16M;
+    alias(signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionOutOfMemoryUsingLessThan16M()
+{
+    const void* signature = (void*)&partitionOutOfMemoryUsingLessThan16M;
+    alias(signature);
+    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();
+    volatile size_t totalUsage = (*PartitionRootBase::gMemoryUsageReportFunction)();
+    if (totalUsage >= 2UL * 1024 * 1024 * 1024)
+        partitionOutOfMemoryUsing2G();
+    if (totalUsage >= 1UL * 1024 * 1024 * 1024)
+        partitionOutOfMemoryUsing1G();
+    if (totalUsage >= 512 * 1024 * 1024)
+        partitionOutOfMemoryUsing512M();
+    if (totalUsage >= 256 * 1024 * 1024)
+        partitionOutOfMemoryUsing256M();
+    if (totalUsage >= 128 * 1024 * 1024)
+        partitionOutOfMemoryUsing128M();
+    if (totalUsage >= 64 * 1024 * 1024)
+        partitionOutOfMemoryUsing64M();
+    if (totalUsage >= 32 * 1024 * 1024)
+        partitionOutOfMemoryUsing32M();
+    if (totalUsage >= 16 * 1024 * 1024)
+        partitionOutOfMemoryUsing16M();
+    partitionOutOfMemoryUsingLessThan16M();
 }
 
 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