Oilpan: Make Oilpan crash at a never-inlined function when hitting OOM

Source/platform/heap/Heap.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 152 matching lines @@
     }
 
     Address base() const { return m_base; }
     size_t size() const { return m_size; }
 
 private:
     Address m_base;
     size_t m_size;
 };
 
+static NEVER_INLINE void blinkGCOutOfMemory()
+{
+    IMMEDIATE_CRASH();

[sof, 2015/03/30 08:06:33]

Could you mimic PartitionAlloc's partitionOutOfMemoryWithLotsOfUncommitedPages()
? It has some Windows smarts.

[haraken, 2015/03/30 09:24:13]

I investigated but it seems it's involved (we need to implement
Heap::s_committedSpace and Heap::s_uncommittedSpace). May I add a TODO at the
moment and address it in a follow-up?

In case of PartitionAlloc, it aggressively allocates new virtual address spaces
(freed pages are never reused for different size buckets, and there are tons of
buckets in PartitionAlloc), so the virtual address space OOM is a concern. On
the other hand, I don't think it's a serious concern in Oilpan, intuitively.

+}
+
 // A PageMemoryRegion represents a chunk of reserved virtual address
 // space containing a number of blink heap pages. On Windows, reserved
 // virtual address space can only be given back to the system as a
 // whole. The PageMemoryRegion allows us to do that by keeping track
 // of the number of pages using it in order to be able to release all
 // of the virtual address space when there are no more pages using it.
 class PageMemoryRegion : public MemoryRegion {
 public:
     ~PageMemoryRegion()
     {
@@ skipping 58 matching lines @@
         size_t offset = blinkPageAddress(address) - base();
         ASSERT(offset % blinkPageSize == 0);
         return offset / blinkPageSize;
     }
 
     static PageMemoryRegion* allocate(size_t size, unsigned numPages)
     {
         // Round size up to the allocation granularity.
         size = (size + WTF::kPageAllocationGranularityOffsetMask) & WTF::kPageAllocationGranularityBaseMask;
         Address base = static_cast<Address>(WTF::allocPages(nullptr, size, blinkPageSize));
-        RELEASE_ASSERT(base);
+        if (!base)
+            blinkGCOutOfMemory();
         WTF::setSystemPagesInaccessible(base, size);
         return new PageMemoryRegion(base, size, numPages);
     }
 
     bool m_isLargePage;
     bool m_inUse[blinkPagesPerRegion];
     unsigned m_numPages;
 };
 
 // Representation of the memory used for a Blink heap page.
@@ skipping 2565 matching lines @@
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 size_t Heap::s_externallyAllocatedBytes = 0;
 size_t Heap::s_externallyAllocatedBytesAlive = 0;
 unsigned Heap::s_requestedUrgentGC = false;
 double Heap::s_markingTimeInLastGC = 0.0;
 
 } // namespace blink