bmalloc: tryFastMalloc shouldn't crash
authorggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 10 Mar 2015 04:10:15 +0000 (04:10 +0000)
committerggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 10 Mar 2015 04:10:15 +0000 (04:10 +0000)
https://bugs.webkit.org/show_bug.cgi?id=142443

Reviewed by Darin Adler.

Source/bmalloc:

Added support for tryMalloc.

We assume that non-x-large allocations always succeed, and we crash
otherwise, since normal allocation failure will just cause the next
non-try allocation or internal metadata allocation to fail, and it's
hard and not really useful to keep limping along after that. But
extra-large allocations can meaningfully fail, and we can recover.

* bmalloc/Heap.cpp:
(bmalloc::Heap::allocateXLarge):
(bmalloc::Heap::tryAllocateXLarge):
* bmalloc/Heap.h: Added support for non-crashy x-large allocation.

* bmalloc/VMAllocate.h:
(bmalloc::tryVMAllocate):
(bmalloc::vmAllocate): Added support for non-crashy VM allocation.

* bmalloc/bmalloc.h:
(bmalloc::api::tryMalloc):
(bmalloc::api::realloc):
(bmalloc::api::free): Tried to clarify our behavior with some comments.
Unfortunately, calling what we do "malloc" is still not quite right, since
malloc returns null on failure and we don't.

Source/WTF:

* wtf/FastMalloc.cpp:
(WTF::fastMalloc):
(WTF::fastRealloc):
(WTF::fastAlignedMalloc): Don't check for null. bmalloc automatically
crashes on allocation failure, and we'd rather not pay for an extra check.

(WTF::tryFastMalloc): Added an opt-out API to return null rather than
crashing, since some clients need this.

(WTF::tryFastRealloc): Deleted. Unused.

* wtf/FastMalloc.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@181307 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WTF/ChangeLog
Source/WTF/wtf/FastMalloc.cpp
Source/WTF/wtf/FastMalloc.h
Source/bmalloc/ChangeLog
Source/bmalloc/bmalloc/Heap.cpp
Source/bmalloc/bmalloc/Heap.h
Source/bmalloc/bmalloc/VMAllocate.h
Source/bmalloc/bmalloc/bmalloc.h

index fd610ad..828b7c9 100644 (file)
@@ -1,3 +1,23 @@
+2015-03-09  Geoffrey Garen  <ggaren@apple.com>
+
+        bmalloc: tryFastMalloc shouldn't crash
+        https://bugs.webkit.org/show_bug.cgi?id=142443
+
+        Reviewed by Darin Adler.
+
+        * wtf/FastMalloc.cpp:
+        (WTF::fastMalloc):
+        (WTF::fastRealloc):
+        (WTF::fastAlignedMalloc): Don't check for null. bmalloc automatically
+        crashes on allocation failure, and we'd rather not pay for an extra check.
+
+        (WTF::tryFastMalloc): Added an opt-out API to return null rather than
+        crashing, since some clients need this.
+
+        (WTF::tryFastRealloc): Deleted. Unused.
+
+        * wtf/FastMalloc.h:
+
 2015-03-09  Mark Lam  <mark.lam@apple.com>
 
         8-bit version of weakCompareAndSwap() can cause an infinite loop.
index 381951b..2e8186c 100644 (file)
@@ -150,11 +150,6 @@ void fastFree(void* p)
     free(p);
 }
 
-TryMallocReturnValue tryFastRealloc(void* p, size_t n)
-{
-    return realloc(p, n);
-}
-
 void* fastRealloc(void* p, size_t n)
 {
     void* result = realloc(p, n);
@@ -194,10 +189,7 @@ namespace WTF {
 
 void* fastMalloc(size_t size)
 {
-    void* result = bmalloc::api::malloc(size);
-    if (!result)
-        CRASH();
-    return result;
+    return bmalloc::api::malloc(size);
 }
 
 void* fastCalloc(size_t numElements, size_t elementSize)
@@ -212,10 +204,7 @@ void* fastCalloc(size_t numElements, size_t elementSize)
 
 void* fastRealloc(void* object, size_t size)
 {
-    void* result = bmalloc::api::realloc(object, size);
-    if (!result)
-        CRASH();
-    return result;
+    return bmalloc::api::realloc(object, size);
 }
 
 void fastFree(void* object)
@@ -239,10 +228,7 @@ size_t fastMallocGoodSize(size_t size)
 
 void* fastAlignedMalloc(size_t alignment, size_t size) 
 {
-    void* result = bmalloc::api::memalign(alignment, size);
-    if (!result)
-        CRASH();
-    return result;
+    return bmalloc::api::memalign(alignment, size);
 }
 
 void fastAlignedFree(void* p) 
@@ -252,12 +238,7 @@ void fastAlignedFree(void* p)
 
 TryMallocReturnValue tryFastMalloc(size_t size)
 {
-    return bmalloc::api::malloc(size);
-}
-    
-TryMallocReturnValue tryFastRealloc(void* object, size_t size)
-{
-    return bmalloc::api::realloc(object, size);
+    return bmalloc::api::tryMalloc(size);
 }
     
 TryMallocReturnValue tryFastCalloc(size_t numElements, size_t elementSize)
index d099245..7151771 100644 (file)
@@ -48,7 +48,6 @@ WTF_EXPORT_PRIVATE char* fastStrDup(const char*);
 WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastMalloc(size_t);
 TryMallocReturnValue tryFastZeroedMalloc(size_t);
 WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastCalloc(size_t numElements, size_t elementSize);
-WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastRealloc(void*, size_t);
 
 WTF_EXPORT_PRIVATE void fastFree(void*);
 
@@ -108,7 +107,6 @@ using WTF::fastStrDup;
 using WTF::fastZeroedMalloc;
 using WTF::tryFastCalloc;
 using WTF::tryFastMalloc;
-using WTF::tryFastRealloc;
 using WTF::tryFastZeroedMalloc;
 using WTF::fastAlignedMalloc;
 using WTF::fastAlignedFree;
index 3f9e23a..363d493 100644 (file)
@@ -1,3 +1,34 @@
+2015-03-09  Geoffrey Garen  <ggaren@apple.com>
+
+        bmalloc: tryFastMalloc shouldn't crash
+        https://bugs.webkit.org/show_bug.cgi?id=142443
+
+        Reviewed by Darin Adler.
+
+        Added support for tryMalloc.
+
+        We assume that non-x-large allocations always succeed, and we crash
+        otherwise, since normal allocation failure will just cause the next
+        non-try allocation or internal metadata allocation to fail, and it's
+        hard and not really useful to keep limping along after that. But
+        extra-large allocations can meaningfully fail, and we can recover.
+
+        * bmalloc/Heap.cpp:
+        (bmalloc::Heap::allocateXLarge):
+        (bmalloc::Heap::tryAllocateXLarge):
+        * bmalloc/Heap.h: Added support for non-crashy x-large allocation.
+
+        * bmalloc/VMAllocate.h:
+        (bmalloc::tryVMAllocate):
+        (bmalloc::vmAllocate): Added support for non-crashy VM allocation.
+
+        * bmalloc/bmalloc.h:
+        (bmalloc::api::tryMalloc):
+        (bmalloc::api::realloc):
+        (bmalloc::api::free): Tried to clarify our behavior with some comments.
+        Unfortunately, calling what we do "malloc" is still not quite right, since
+        malloc returns null on failure and we don't.
+
 2015-03-03  Geoffrey Garen  <ggaren@apple.com>
 
         bmalloc: Don't branch when setting the owner of a large object
index 6502a74..ae7d709 100644 (file)
@@ -281,14 +281,10 @@ void Heap::deallocateMediumLine(std::lock_guard<StaticMutex>& lock, MediumLine*
     }
 }
 
-void* Heap::allocateXLarge(std::lock_guard<StaticMutex>&, size_t alignment, size_t size)
+void* Heap::allocateXLarge(std::lock_guard<StaticMutex>& lock, size_t alignment, size_t size)
 {
-    BASSERT(isPowerOfTwo(alignment));
-    BASSERT(alignment >= xLargeAlignment);
-    BASSERT(size == roundUpToMultipleOf<xLargeAlignment>(size));
-
-    void* result = vmAllocate(alignment, size);
-    m_xLargeObjects.push(Range(result, size));
+    void* result = tryAllocateXLarge(lock, alignment, size);
+    RELEASE_BASSERT(result);
     return result;
 }
 
@@ -297,6 +293,19 @@ void* Heap::allocateXLarge(std::lock_guard<StaticMutex>& lock, size_t size)
     return allocateXLarge(lock, superChunkSize, size);
 }
 
+void* Heap::tryAllocateXLarge(std::lock_guard<StaticMutex>&, size_t alignment, size_t size)
+{
+    BASSERT(isPowerOfTwo(alignment));
+    BASSERT(alignment >= superChunkSize);
+    BASSERT(size == roundUpToMultipleOf<xLargeAlignment>(size));
+
+    void* result = tryVMAllocate(alignment, size);
+    if (!result)
+        return nullptr;
+    m_xLargeObjects.push(Range(result, size));
+    return result;
+}
+
 Range Heap::findXLarge(std::lock_guard<StaticMutex>&, void* object)
 {
     for (auto& range : m_xLargeObjects) {
index b3a80c0..3f61462 100644 (file)
@@ -65,6 +65,7 @@ public:
 
     void* allocateXLarge(std::lock_guard<StaticMutex>&, size_t);
     void* allocateXLarge(std::lock_guard<StaticMutex>&, size_t alignment, size_t);
+    void* tryAllocateXLarge(std::lock_guard<StaticMutex>&, size_t alignment, size_t);
     Range findXLarge(std::lock_guard<StaticMutex>&, void*);
     void deallocateXLarge(std::unique_lock<StaticMutex>&, void*);
 
index 31f79b4..d9d0a9c 100644 (file)
@@ -73,11 +73,19 @@ inline void vmValidate(void* p, size_t vmSize)
     BASSERT(p == mask(p, ~(getpagesize() - 1)));
 }
 
-inline void* vmAllocate(size_t vmSize)
+inline void* tryVMAllocate(size_t vmSize)
 {
     vmValidate(vmSize);
     void* result = mmap(0, vmSize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, BMALLOC_VM_TAG, 0);
-    RELEASE_BASSERT(result != MAP_FAILED);
+    if (result == MAP_FAILED)
+        return nullptr;
+    return result;
+}
+
+inline void* vmAllocate(size_t vmSize)
+{
+    void* result = tryVMAllocate(vmSize);
+    RELEASE_BASSERT(result);
     return result;
 }
 
@@ -90,13 +98,15 @@ inline void vmDeallocate(void* p, size_t vmSize)
 // Allocates vmSize bytes at a specified power-of-two alignment.
 // Use this function to create maskable memory regions.
 
-inline void* vmAllocate(size_t vmAlignment, size_t vmSize)
+inline void* tryVMAllocate(size_t vmAlignment, size_t vmSize)
 {
     vmValidate(vmSize);
     vmValidate(vmAlignment);
 
     size_t mappedSize = std::max(vmSize, vmAlignment) + vmAlignment;
-    char* mapped = static_cast<char*>(vmAllocate(mappedSize));
+    char* mapped = static_cast<char*>(tryVMAllocate(mappedSize));
+    if (!mapped)
+        return nullptr;
     char* mappedEnd = mapped + mappedSize;
 
     char* aligned = roundUpToMultipleOf(vmAlignment, mapped);
@@ -111,6 +121,13 @@ inline void* vmAllocate(size_t vmAlignment, size_t vmSize)
     return aligned;
 }
 
+inline void* vmAllocate(size_t vmAlignment, size_t vmSize)
+{
+    void* result = tryVMAllocate(vmAlignment, vmSize);
+    RELEASE_BASSERT(result);
+    return result;
+}
+
 inline void vmDeallocatePhysicalPages(void* p, size_t vmSize)
 {
     vmValidate(p, vmSize);
index e2861c1..d8c9bf9 100644 (file)
 namespace bmalloc {
 namespace api {
 
+// Returns null on failure.
+inline void* tryMalloc(size_t size)
+{
+    if (size <= largeMax)
+        return Cache::allocate(size);
+
+    std::lock_guard<StaticMutex> lock(PerProcess<Heap>::mutex());
+    return PerProcess<Heap>::get()->tryAllocateXLarge(lock, superChunkSize, roundUpToMultipleOf<xLargeAlignment>(size));
+}
+
+// Crashes on failure.
 inline void* malloc(size_t size)
 {
     return Cache::allocate(size);
 }
 
+// Crashes on failure.
 inline void* memalign(size_t alignment, size_t size)
 {
     return Cache::allocate(alignment, size);
 }
 
-inline void free(void* object)
+// Crashes on failure.
+inline void* realloc(void* object, size_t newSize)
 {
-    Cache::deallocate(object);
+    return Cache::reallocate(object, newSize);
 }
 
-inline void* realloc(void* object, size_t newSize)
+inline void free(void* object)
 {
-    return Cache::reallocate(object, newSize);
+    Cache::deallocate(object);
 }
 
 inline void scavengeThisThread()