PartitionAlloc: Distinguish OOMs where a lot of super pages are not committed

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 278 matching lines @@
     size_t i;
     for (i = 0; i < kGenericNumBucketedOrders * kGenericNumBucketsPerOrder; ++i) {
         PartitionBucket* bucket = &root->buckets[i];
         if (!partitionAllocShutdownBucket(bucket))
             noLeaks = false;
     }
     partitionAllocBaseShutdown(root);
     return noLeaks;
 }
 
-static NEVER_INLINE void partitionOutOfMemory()
+static NEVER_INLINE void partitionOutOfMemory(const PartitionRootBase* root)
 {
+    if ((uint64_t)root->totalSizeOfCommittedPages + 1000000000 < (uint64_t)root->totalSizeOfSuperPages) {

[kouhei (in TOK), 2014/10/29 09:34:32]

1000000000 should be named as "static const size_t kReasonableSizeOfUnusedPages"
if (r->totalSizeOfSuperPages - r->totalSizeOfCommittedPages >
kReasonableSizeOfUnusedPages)

[hiroshige, 2014/11/06 10:59:13]

Done.

+        // OOMs where a lot of super pages are allocated but not committed,
+        // probably due to http://crbug.com/421387.
+        // Crash at a special address (0x9b)
+        // to be easily distinguished on crash reports.
+        ((void(*)())0x0000009b)();
+    }
+    // Ordinary OOMs (where super pages are consumed and mostly committed).
     IMMEDIATE_CRASH();
 }
 
 static ALWAYS_INLINE void partitionDecommitSystemPages(PartitionRootBase* root, void* addr, size_t len)
 {
     decommitSystemPages(addr, len);
     ASSERT(root->totalSizeOfCommittedPages > len);
     root->totalSizeOfCommittedPages -= len;
 }
 
@@ skipping 383 matching lines @@
         newPage = partitionPointerToPageNoAlignmentCheck(rawNewPage);
     }
 
     partitionPageReset(newPage, bucket);
     bucket->activePagesHead = newPage;
     return partitionPageAllocAndFillFreelist(newPage);
 
 partitionAllocSlowPathFailed:
     if (returnNull)
         return nullptr;
-    partitionOutOfMemory();
+    partitionOutOfMemory(root);
     return nullptr;
 }
 
 static ALWAYS_INLINE void partitionFreePage(PartitionRootBase* root, PartitionPage* page)
 {
     ASSERT(page->freelistHead);
     ASSERT(!page->numAllocatedSlots);
     partitionUnusePage(root, page);
     // We actually leave the freed page in the active list. We'll sweep it on
     // to the free page list when we next walk the active page list. Pulling
@@ skipping 258 matching lines @@
     printf("total live: %zu bytes\n", totalLive);
     printf("total resident: %zu bytes\n", totalResident);
     printf("total freeable: %zu bytes\n", totalFreeable);
     fflush(stdout);
 }
 
 #endif // !NDEBUG
 
 } // namespace WTF