Add partitionsOutOfMemoryUsingXXX to know Blink memory usage from crash...

Add partitionsOutOfMemoryUsingXXX to know Blink memory usage from crash reports when PartitionAlloc hits OOM.

To avoid linker optimization, copied alias.cc and alias.h from //base/debug to WTF.

BUG=

Review URL: https://codereview.chromium.org/1315113006

git-svn-id: svn://svn.chromium.org/blink/trunk@201791 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/wtf/Alias.cpp

+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "wtf/Alias.h"
+
+// TODO(tasak): This code is copied from //base/debug/alias.cc.
+// If Blink is allowed to use //base/debug, remove this code and use //base/debug.
+namespace WTF {
+
+#if COMPILER(MSVC)
+#pragma optimize("", off)
+#endif
+
+void alias(const void* var)
+{
+}
+
+#if COMPILER(MSVC)
+#pragma optimize("", on)
+#endif
+
+} // namespace WTF

third_party/WebKit/Source/wtf/Alias.h

+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef Alias_h
+#define Alias_h
+
+#include "wtf/WTFExport.h"
+
+namespace WTF {
+
+// Make the optimizer think that var is aliased. This is to prevent it from
+// optimizing out variables that would not otherwise be live at the point
+// of a potential crash.
+void WTF_EXPORT alias(const void* var);
+
+} // namespace WTF
+
+#endif // Alias_h

third_party/WebKit/Source/wtf/PartitionAlloc.cpp

@@ -59,6 +59,7 @@ int PartitionRootBase::gInitializedLock = 0;
 bool PartitionRootBase::gInitialized = false;
 PartitionPage PartitionRootBase::gSeedPage;
 PartitionBucket PartitionRootBase::gPagedBucket;
+void (*PartitionRootBase::gOomHandlingFunction)() = nullptr;
 
 static uint16_t partitionBucketNumSystemPages(size_t size)
 {
@@ -138,6 +139,12 @@ static void partitionBucketInitBase(PartitionBucket* bucket, PartitionRootBase*
     bucket->numSystemPagesPerSlotSpan = partitionBucketNumSystemPages(bucket->slotSize);
 }
 
+void partitionAllocGlobalInit(void (*oomHandlingFunction)())
+{
+    ASSERT(oomHandlingFunction);
+    PartitionRootBase::gOomHandlingFunction = oomHandlingFunction;
+}
+
 void partitionAllocInit(PartitionRoot* root, size_t numBuckets, size_t maxAllocation)
 {
     partitionAllocBaseInit(root);
@@ -308,6 +315,8 @@ static NEVER_INLINE void partitionOutOfMemory(const PartitionRootBase* root)
         partitionOutOfMemoryWithLotsOfUncommitedPages();
     }
 #endif
+    if (PartitionRootBase::gOomHandlingFunction)
+        (*PartitionRootBase::gOomHandlingFunction)();
     IMMEDIATE_CRASH();
 }
 

third_party/WebKit/Source/wtf/PartitionAlloc.h

@@ -316,6 +316,8 @@ struct WTF_EXPORT PartitionRootBase {
     // that.
     static PartitionPage gSeedPage;
     static PartitionBucket gPagedBucket;
+    // gOomHandlingFunction is invoked when ParitionAlloc hits OutOfMemory.
+    static void (*gOomHandlingFunction)();
 };
 
 // Never instantiate a PartitionRoot directly, instead use PartitionAlloc.
@@ -383,6 +385,7 @@ public:
     virtual void partitionsDumpBucketStats(const char* partitionName, const PartitionBucketMemoryStats*) = 0;
 };
 
+WTF_EXPORT void partitionAllocGlobalInit(void (*oomHandlingFunction)());
 WTF_EXPORT void partitionAllocInit(PartitionRoot*, size_t numBuckets, size_t maxAllocation);
 WTF_EXPORT bool partitionAllocShutdown(PartitionRoot*);
 WTF_EXPORT void partitionAllocGenericInit(PartitionRootGeneric*);

third_party/WebKit/Source/wtf/Partitions.cpp

@@ -31,6 +31,7 @@
 #include "config.h"
 #include "wtf/Partitions.h"
 
+#include "wtf/Alias.h"
 #include "wtf/DefaultAllocator.h"
 #include "wtf/FastMalloc.h"
 #include "wtf/MainThread.h"
@@ -51,6 +52,7 @@ void Partitions::initialize()
     spinLockLock(&s_initializationLock);
 
     if (!s_initialized) {
+        partitionAllocGlobalInit(&Partitions::handleOutOfMemory);
         m_fastMallocAllocator.init();
         m_bufferAllocator.init();
         m_nodeAllocator.init();
@@ -122,4 +124,90 @@ void Partitions::dumpMemoryStats(bool isLightDump, PartitionStatsDumper* partiti
     partitionDumpStats(layoutPartition(), "layout_partition", isLightDump, partitionStatsDumper);
 }
 
+static NEVER_INLINE void partitionsOutOfMemoryUsing2G()
+{
+    size_t signature = 2UL * 1024 * 1024 * 1024;
+    alias(&signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionsOutOfMemoryUsing1G()
+{
+    size_t signature = 1UL * 1024 * 1024 * 1024;
+    alias(&signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionsOutOfMemoryUsing512M()
+{
+    size_t signature = 512 * 1024 * 1024;
+    alias(&signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionsOutOfMemoryUsing256M()
+{
+    size_t signature = 256 * 1024 * 1024;
+    alias(&signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionsOutOfMemoryUsing128M()
+{
+    size_t signature = 128 * 1024 * 1024;
+    alias(&signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionsOutOfMemoryUsing64M()
+{
+    size_t signature = 64 * 1024 * 1024;
+    alias(&signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionsOutOfMemoryUsing32M()
+{
+    size_t signature = 32 * 1024 * 1024;
+    alias(&signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionsOutOfMemoryUsing16M()
+{
+    size_t signature = 16 * 1024 * 1024;
+    alias(&signature);
+    IMMEDIATE_CRASH();
+}
+
+static NEVER_INLINE void partitionsOutOfMemoryUsingLessThan16M()
+{
+    size_t signature = 16 * 1024 * 1024 - 1;
+    alias(&signature);
+    IMMEDIATE_CRASH();
+}
+
+void Partitions::handleOutOfMemory()
+{
+    volatile size_t totalUsage = totalSizeOfCommittedPages();
+
+    if (totalUsage >= 2UL * 1024 * 1024 * 1024)
+        partitionsOutOfMemoryUsing2G();
+    if (totalUsage >= 1UL * 1024 * 1024 * 1024)
+        partitionsOutOfMemoryUsing1G();
+    if (totalUsage >= 512 * 1024 * 1024)
+        partitionsOutOfMemoryUsing512M();
+    if (totalUsage >= 256 * 1024 * 1024)
+        partitionsOutOfMemoryUsing256M();
+    if (totalUsage >= 128 * 1024 * 1024)
+        partitionsOutOfMemoryUsing128M();
+    if (totalUsage >= 64 * 1024 * 1024)
+        partitionsOutOfMemoryUsing64M();
+    if (totalUsage >= 32 * 1024 * 1024)
+        partitionsOutOfMemoryUsing32M();
+    if (totalUsage >= 16 * 1024 * 1024)
+        partitionsOutOfMemoryUsing16M();
+    partitionsOutOfMemoryUsingLessThan16M();
+}
+
 } // namespace WTF

third_party/WebKit/Source/wtf/Partitions.h

@@ -118,6 +118,8 @@ public:
         return partitionAllocActualSize(bufferPartition(), n);
     }
 
+    static void handleOutOfMemory();
+
 private:
     static int s_initializationLock;
     static bool s_initialized;

third_party/WebKit/Source/wtf/wtf.gypi

@@ -6,6 +6,8 @@
             'AddressSanitizer.h',
             'AddressSpaceRandomization.cpp',
             'AddressSpaceRandomization.h',
+            'Alias.cpp',
+            'Alias.h',
             'Alignment.h',
             'Allocator.h',
             'ArrayBuffer.cpp',