bmalloc: a little bit of cleanup
authorggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 20 Jan 2015 19:29:46 +0000 (19:29 +0000)
committerggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 20 Jan 2015 19:29:46 +0000 (19:29 +0000)
https://bugs.webkit.org/show_bug.cgi?id=140687

Reviewed by Anders Carlsson.

* bmalloc/Algorithm.h:
(bmalloc::isPowerOfTwo): Added a check for 0, since 0 would break a lot
of code.

* bmalloc/BoundaryTag.h:
* bmalloc/BoundaryTagInlines.h:
(bmalloc::BoundaryTag::mergeLeft):
(bmalloc::BoundaryTag::mergeRight):
(bmalloc::BoundaryTag::merge):
(bmalloc::BoundaryTag::deallocate):
(bmalloc::BoundaryTag::split):
(bmalloc::BoundaryTag::allocate):
(bmalloc::BoundaryTag::mergeLargeLeft): Deleted.
(bmalloc::BoundaryTag::mergeLargeRight): Deleted.
(bmalloc::BoundaryTag::mergeLarge): Deleted.
(bmalloc::BoundaryTag::splitLarge): Deleted. Removed the word "Large"
from all these functions, since boundary tags always pertain to large
objects, and putting the word "Large" everywhere wasn't helping to
explain that.

* bmalloc/Heap.cpp:
(bmalloc::Heap::allocateXLarge):
(bmalloc::Heap::findXLarge):
(bmalloc::Heap::deallocateXLarge):
* bmalloc/Heap.h:
* bmalloc/VMHeap.h:
(bmalloc::VMHeap::allocateXLarge): Deleted.
(bmalloc::VMHeap::findXLarge): Deleted.
(bmalloc::VMHeap::deallocateXLarge): Deleted. Moved XLarge allocation
from VMHeap to Heap. Since the purpose of the VMHeap is to cache VM
ranges, and the VMHeap never caches any XLarge ranges, it doesn't
really make sense for the VMHeap to be involved.

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

Source/bmalloc/ChangeLog
Source/bmalloc/bmalloc/Algorithm.h
Source/bmalloc/bmalloc/BoundaryTag.h
Source/bmalloc/bmalloc/BoundaryTagInlines.h
Source/bmalloc/bmalloc/Heap.cpp
Source/bmalloc/bmalloc/Heap.h
Source/bmalloc/bmalloc/VMHeap.h

index df6e056..9b59ca1 100644 (file)
@@ -1,3 +1,43 @@
+2015-01-20  Geoffrey Garen  <ggaren@apple.com>
+
+        bmalloc: a little bit of cleanup
+        https://bugs.webkit.org/show_bug.cgi?id=140687
+
+        Reviewed by Anders Carlsson.
+
+        * bmalloc/Algorithm.h:
+        (bmalloc::isPowerOfTwo): Added a check for 0, since 0 would break a lot
+        of code.
+
+        * bmalloc/BoundaryTag.h:
+        * bmalloc/BoundaryTagInlines.h:
+        (bmalloc::BoundaryTag::mergeLeft):
+        (bmalloc::BoundaryTag::mergeRight):
+        (bmalloc::BoundaryTag::merge):
+        (bmalloc::BoundaryTag::deallocate):
+        (bmalloc::BoundaryTag::split):
+        (bmalloc::BoundaryTag::allocate):
+        (bmalloc::BoundaryTag::mergeLargeLeft): Deleted.
+        (bmalloc::BoundaryTag::mergeLargeRight): Deleted.
+        (bmalloc::BoundaryTag::mergeLarge): Deleted.
+        (bmalloc::BoundaryTag::splitLarge): Deleted. Removed the word "Large"
+        from all these functions, since boundary tags always pertain to large
+        objects, and putting the word "Large" everywhere wasn't helping to
+        explain that.
+
+        * bmalloc/Heap.cpp:
+        (bmalloc::Heap::allocateXLarge):
+        (bmalloc::Heap::findXLarge):
+        (bmalloc::Heap::deallocateXLarge):
+        * bmalloc/Heap.h:
+        * bmalloc/VMHeap.h:
+        (bmalloc::VMHeap::allocateXLarge): Deleted.
+        (bmalloc::VMHeap::findXLarge): Deleted.
+        (bmalloc::VMHeap::deallocateXLarge): Deleted. Moved XLarge allocation
+        from VMHeap to Heap. Since the purpose of the VMHeap is to cache VM
+        ranges, and the VMHeap never caches any XLarge ranges, it doesn't
+        really make sense for the VMHeap to be involved.
+
 2015-01-16  Geoffrey Garen  <ggaren@apple.com>
 
         bmalloc: refactored XLarge allocation for better alignment
index 41dbfc9..b0700dd 100644 (file)
@@ -64,7 +64,7 @@ template<typename T> inline constexpr bool test(T value, uintptr_t mask)
 
 inline constexpr bool isPowerOfTwo(size_t size)
 {
-    return !(size & (size - 1));
+    return size && !(size & (size - 1));
 }
 
 template<typename T> inline T roundUpToMultipleOf(size_t divisor, T x)
index dd8b3c6..8d1bd92 100644 (file)
@@ -72,10 +72,10 @@ private:
     static_assert((1 << compactBeginBits) - 1 >= largeMin / largeAlignment, "compactBegin must be encodable in a BoundaryTag.");
     static_assert((1 << sizeBits) - 1 >= largeMax, "largeMax must be encodable in a BoundaryTag.");
 
-    static void splitLarge(BeginTag*, size_t size, EndTag*& endTag, Range&, Range& leftover);
-    static void mergeLargeLeft(EndTag*& prev, BeginTag*& beginTag, Range&, bool& hasPhysicalPages);
-    static void mergeLargeRight(EndTag*&, BeginTag*& next, Range&, bool& hasPhysicalPages);
-    static void mergeLarge(BeginTag*&, EndTag*&, Range&);
+    static void split(BeginTag*, size_t, EndTag*&, Range&, Range& leftover);
+    static void mergeLeft(EndTag*& prev, BeginTag*&, Range&, bool& hasPhysicalPages);
+    static void mergeRight(EndTag*&, BeginTag*& next, Range&, bool& hasPhysicalPages);
+    static void merge(BeginTag*&, EndTag*&, Range&);
 
     bool m_isFree: 1;
     bool m_isEnd: 1;
index 89a16fd..a10cf78 100644 (file)
@@ -105,7 +105,7 @@ inline Range BoundaryTag::init(LargeChunk* chunk)
     return range;
 }
 
-inline void BoundaryTag::mergeLargeLeft(EndTag*& prev, BeginTag*& beginTag, Range& range, bool& hasPhysicalPages)
+inline void BoundaryTag::mergeLeft(EndTag*& prev, BeginTag*& beginTag, Range& range, bool& hasPhysicalPages)
 {
     Range left(range.begin() - prev->size(), prev->size());
 
@@ -119,7 +119,7 @@ inline void BoundaryTag::mergeLargeLeft(EndTag*& prev, BeginTag*& beginTag, Rang
     beginTag = LargeChunk::beginTag(range.begin());
 }
 
-inline void BoundaryTag::mergeLargeRight(EndTag*& endTag, BeginTag*& next, Range& range, bool& hasPhysicalPages)
+inline void BoundaryTag::mergeRight(EndTag*& endTag, BeginTag*& next, Range& range, bool& hasPhysicalPages)
 {
     Range right(range.end(), next->size());
 
@@ -133,7 +133,7 @@ inline void BoundaryTag::mergeLargeRight(EndTag*& endTag, BeginTag*& next, Range
     endTag = LargeChunk::endTag(range.begin(), range.size());
 }
 
-INLINE void BoundaryTag::mergeLarge(BeginTag*& beginTag, EndTag*& endTag, Range& range)
+INLINE void BoundaryTag::merge(BeginTag*& beginTag, EndTag*& endTag, Range& range)
 {
     EndTag* prev = beginTag->prev();
     BeginTag* next = endTag->next();
@@ -142,10 +142,10 @@ INLINE void BoundaryTag::mergeLarge(BeginTag*& beginTag, EndTag*& endTag, Range&
     validate(prev, range, next);
 
     if (prev->isFree())
-        mergeLargeLeft(prev, beginTag, range, hasPhysicalPages);
+        mergeLeft(prev, beginTag, range, hasPhysicalPages);
 
     if (next->isFree())
-        mergeLargeRight(endTag, next, range, hasPhysicalPages);
+        mergeRight(endTag, next, range, hasPhysicalPages);
 
     beginTag->setRange(range);
     beginTag->setFree(true);
@@ -164,12 +164,12 @@ inline Range BoundaryTag::deallocate(void* object)
 
     Range range(object, beginTag->size());
     EndTag* endTag = LargeChunk::endTag(range.begin(), range.size());
-    mergeLarge(beginTag, endTag, range);
+    merge(beginTag, endTag, range);
     
     return range;
 }
 
-INLINE void BoundaryTag::splitLarge(BeginTag* beginTag, size_t size, EndTag*& endTag, Range& range, Range& leftover)
+INLINE void BoundaryTag::split(BeginTag* beginTag, size_t size, EndTag*& endTag, Range& range, Range& leftover)
 {
     leftover = Range(range.begin() + size, range.size() - size);
     range = Range(range.begin(), size);
@@ -203,7 +203,7 @@ INLINE void BoundaryTag::allocate(size_t size, Range& range, Range& leftover, bo
     validate(beginTag->prev(), range, endTag->next());
 
     if (range.size() - size > largeMin)
-        splitLarge(beginTag, size, endTag, range, leftover);
+        split(beginTag, size, endTag, range, leftover);
 
     hasPhysicalPages = beginTag->hasPhysicalPages();
 
index 5a5dc3a..df8c4d3 100644 (file)
@@ -319,23 +319,40 @@ void Heap::deallocateMediumLine(std::lock_guard<StaticMutex>& lock, MediumLine*
     }
 }
 
-Range Heap::findXLarge(std::lock_guard<StaticMutex>&, void* object)
-{
-    return m_vmHeap.findXLarge(object);
-}
-
 void* Heap::allocateXLarge(std::lock_guard<StaticMutex>&, size_t size)
 {
     m_isAllocatingPages = true;
 
-    void* result = m_vmHeap.allocateXLarge(size);
-    vmAllocatePhysicalPagesSloppy(result, size);
+    void* result = vmAllocate(size, superChunkSize);
+    m_xLargeRanges.push(Range(result, size));
     return result;
 }
 
+Range Heap::findXLarge(std::lock_guard<StaticMutex>&, void* object)
+{
+    for (auto& range : m_xLargeRanges) {
+        if (range.begin() != object)
+            continue;
+        return range;
+    }
+
+    return Range();
+}
+
 void Heap::deallocateXLarge(std::unique_lock<StaticMutex>& lock, void* object)
 {
-    m_vmHeap.deallocateXLarge(lock, object);
+    for (auto& range : m_xLargeRanges) {
+        if (range.begin() != object)
+            continue;
+
+        Range toDeallocate = m_xLargeRanges.pop(&range);
+
+        lock.unlock();
+        vmDeallocate(toDeallocate.begin(), toDeallocate.size());
+        lock.lock();
+        
+        break;
+    }
 }
 
 void* Heap::allocateLarge(std::lock_guard<StaticMutex>&, size_t size)
index 6b78255..6dfedd8 100644 (file)
@@ -102,6 +102,7 @@ private:
     Vector<MediumPage*> m_mediumPages;
 
     SegregatedFreeList m_largeRanges;
+    Vector<Range> m_xLargeRanges;
 
     bool m_isAllocatingPages;
 
index 1f01862..99f1a24 100644 (file)
@@ -48,14 +48,10 @@ public:
     SmallPage* allocateSmallPage();
     MediumPage* allocateMediumPage();
     Range allocateLargeRange(size_t);
-    void* allocateXLarge(size_t);
-
-    Range findXLarge(void*);
 
     void deallocateSmallPage(std::unique_lock<StaticMutex>&, SmallPage*);
     void deallocateMediumPage(std::unique_lock<StaticMutex>&, MediumPage*);
     void deallocateLargeRange(std::unique_lock<StaticMutex>&, Range);
-    void deallocateXLarge(std::unique_lock<StaticMutex>&, void*);
 
 private:
     void allocateSuperChunk();
@@ -63,7 +59,6 @@ private:
     Vector<SmallPage*> m_smallPages;
     Vector<MediumPage*> m_mediumPages;
     SegregatedFreeList m_largeRanges;
-    Vector<Range> m_xLargeRanges;
 };
 
 inline SmallPage* VMHeap::allocateSmallPage()
@@ -93,24 +88,6 @@ inline Range VMHeap::allocateLargeRange(size_t size)
     return range;
 }
 
-inline void* VMHeap::allocateXLarge(size_t size)
-{
-    void* result = vmAllocate(size, superChunkSize);
-    m_xLargeRanges.push(Range(result, size));
-    return result;
-}
-
-inline Range VMHeap::findXLarge(void* object)
-{
-    for (auto& range : m_xLargeRanges) {
-        if (range.begin() != object)
-            continue;
-        return range;
-    }
-
-    return Range();
-}
-
 inline void VMHeap::deallocateSmallPage(std::unique_lock<StaticMutex>& lock, SmallPage* page)
 {
     lock.unlock();
@@ -152,23 +129,6 @@ inline void VMHeap::deallocateLargeRange(std::unique_lock<StaticMutex>& lock, Ra
     m_largeRanges.insert(range);
 }
 
-inline void VMHeap::deallocateXLarge(std::unique_lock<StaticMutex>& lock, void* object)
-{
-    for (size_t i = 0; i < m_xLargeRanges.size(); ++i) {
-        Range range = m_xLargeRanges[i];
-        if (range.begin() != object)
-            continue;
-
-        m_xLargeRanges.pop(i);
-
-        lock.unlock();
-        vmDeallocate(range.begin(), range.size());
-        lock.lock();
-        
-        break;
-    }
-}
-
 } // namespace bmalloc
 
 #endif // VMHeap_h