Made bmalloc more #include friendly
authorggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 8 Apr 2014 20:36:07 +0000 (20:36 +0000)
committerggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 8 Apr 2014 20:36:07 +0000 (20:36 +0000)
https://bugs.webkit.org/show_bug.cgi?id=131386

Reviewed by Andreas Kling.

Marked a bunch of headers private so they can be used from client code
that #includes bmalloc.h.

Renamed ASSERT macros to BASSERT. This matches their header, which already
had to be renamed, and fixes conflicts with WTF's ASSERT macros.

* bmalloc.xcodeproj/project.pbxproj:
* bmalloc/Allocator.cpp:
(bmalloc::Allocator::allocateSlowCase):
* bmalloc/AsyncTask.h:
(bmalloc::Function>::runSlowCase):
* bmalloc/BAssert.h:
* bmalloc/BoundaryTag.h:
(bmalloc::BoundaryTag::setSize):
* bmalloc/BoundaryTagInlines.h:
(bmalloc::validate):
(bmalloc::BoundaryTag::init):
(bmalloc::BoundaryTag::deallocate):
(bmalloc::BoundaryTag::splitLarge):
(bmalloc::BoundaryTag::allocate):
* bmalloc/Chunk.h:
* bmalloc/Deallocator.cpp:
(bmalloc::Deallocator::processObjectLog):
(bmalloc::Deallocator::deallocateSlowCase):
* bmalloc/Deallocator.h:
(bmalloc::Deallocator::deallocateFastCase):
* bmalloc/FixedVector.h:
(bmalloc::Capacity>::operator):
(bmalloc::Capacity>::push):
(bmalloc::Capacity>::pop):
(bmalloc::Capacity>::shrink):
* bmalloc/Heap.cpp:
(bmalloc::Heap::allocateLarge):
* bmalloc/LargeChunk.h:
(bmalloc::LargeChunk::get):
(bmalloc::LargeChunk::endTag):
* bmalloc/Line.h:
(bmalloc::Line<Traits>::concurrentRef):
(bmalloc::Line<Traits>::deref):
* bmalloc/MediumAllocator.h:
(bmalloc::MediumAllocator::allocate):
* bmalloc/ObjectType.h:
(bmalloc::isSmall):
* bmalloc/Page.h:
(bmalloc::Page<Traits>::ref):
(bmalloc::Page<Traits>::deref):
* bmalloc/PerThread.h:
(bmalloc::PerThread<T>::getSlowCase):
* bmalloc/SegregatedFreeList.cpp:
(bmalloc::SegregatedFreeList::SegregatedFreeList):
(bmalloc::SegregatedFreeList::insert):
* bmalloc/SmallAllocator.h:
(bmalloc::SmallAllocator::allocate):
(bmalloc::SmallAllocator::refill):
* bmalloc/Syscall.h:
* bmalloc/VMAllocate.h:
(bmalloc::vmValidate):
(bmalloc::vmAllocate):
(bmalloc::vmDeallocatePhysicalPagesSloppy):
* bmalloc/Vector.h:
(bmalloc::Vector<T>::operator):
(bmalloc::Vector<T>::pop):
(bmalloc::Vector<T>::shrink):
* bmalloc/XLargeChunk.h:
(bmalloc::XLargeChunk::range):
(bmalloc::XLargeChunk::size):

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

24 files changed:
Source/bmalloc/ChangeLog
Source/bmalloc/bmalloc.xcodeproj/project.pbxproj
Source/bmalloc/bmalloc/Allocator.cpp
Source/bmalloc/bmalloc/AsyncTask.h
Source/bmalloc/bmalloc/BAssert.h
Source/bmalloc/bmalloc/BoundaryTag.h
Source/bmalloc/bmalloc/BoundaryTagInlines.h
Source/bmalloc/bmalloc/Chunk.h
Source/bmalloc/bmalloc/Deallocator.cpp
Source/bmalloc/bmalloc/Deallocator.h
Source/bmalloc/bmalloc/FixedVector.h
Source/bmalloc/bmalloc/Heap.cpp
Source/bmalloc/bmalloc/LargeChunk.h
Source/bmalloc/bmalloc/Line.h
Source/bmalloc/bmalloc/MediumAllocator.h
Source/bmalloc/bmalloc/ObjectType.h
Source/bmalloc/bmalloc/Page.h
Source/bmalloc/bmalloc/PerThread.h
Source/bmalloc/bmalloc/SegregatedFreeList.cpp
Source/bmalloc/bmalloc/SmallAllocator.h
Source/bmalloc/bmalloc/Syscall.h
Source/bmalloc/bmalloc/VMAllocate.h
Source/bmalloc/bmalloc/Vector.h
Source/bmalloc/bmalloc/XLargeChunk.h

index 161bdf8..c21ebf8 100644 (file)
@@ -1,5 +1,79 @@
 2014-04-08  Geoffrey Garen  <ggaren@apple.com>
 
+        Made bmalloc more #include friendly
+        https://bugs.webkit.org/show_bug.cgi?id=131386
+
+        Reviewed by Andreas Kling.
+
+        Marked a bunch of headers private so they can be used from client code
+        that #includes bmalloc.h.
+
+        Renamed ASSERT macros to BASSERT. This matches their header, which already
+        had to be renamed, and fixes conflicts with WTF's ASSERT macros.
+
+        * bmalloc.xcodeproj/project.pbxproj:
+        * bmalloc/Allocator.cpp:
+        (bmalloc::Allocator::allocateSlowCase):
+        * bmalloc/AsyncTask.h:
+        (bmalloc::Function>::runSlowCase):
+        * bmalloc/BAssert.h:
+        * bmalloc/BoundaryTag.h:
+        (bmalloc::BoundaryTag::setSize):
+        * bmalloc/BoundaryTagInlines.h:
+        (bmalloc::validate):
+        (bmalloc::BoundaryTag::init):
+        (bmalloc::BoundaryTag::deallocate):
+        (bmalloc::BoundaryTag::splitLarge):
+        (bmalloc::BoundaryTag::allocate):
+        * bmalloc/Chunk.h:
+        * bmalloc/Deallocator.cpp:
+        (bmalloc::Deallocator::processObjectLog):
+        (bmalloc::Deallocator::deallocateSlowCase):
+        * bmalloc/Deallocator.h:
+        (bmalloc::Deallocator::deallocateFastCase):
+        * bmalloc/FixedVector.h:
+        (bmalloc::Capacity>::operator):
+        (bmalloc::Capacity>::push):
+        (bmalloc::Capacity>::pop):
+        (bmalloc::Capacity>::shrink):
+        * bmalloc/Heap.cpp:
+        (bmalloc::Heap::allocateLarge):
+        * bmalloc/LargeChunk.h:
+        (bmalloc::LargeChunk::get):
+        (bmalloc::LargeChunk::endTag):
+        * bmalloc/Line.h:
+        (bmalloc::Line<Traits>::concurrentRef):
+        (bmalloc::Line<Traits>::deref):
+        * bmalloc/MediumAllocator.h:
+        (bmalloc::MediumAllocator::allocate):
+        * bmalloc/ObjectType.h:
+        (bmalloc::isSmall):
+        * bmalloc/Page.h:
+        (bmalloc::Page<Traits>::ref):
+        (bmalloc::Page<Traits>::deref):
+        * bmalloc/PerThread.h:
+        (bmalloc::PerThread<T>::getSlowCase):
+        * bmalloc/SegregatedFreeList.cpp:
+        (bmalloc::SegregatedFreeList::SegregatedFreeList):
+        (bmalloc::SegregatedFreeList::insert):
+        * bmalloc/SmallAllocator.h:
+        (bmalloc::SmallAllocator::allocate):
+        (bmalloc::SmallAllocator::refill):
+        * bmalloc/Syscall.h:
+        * bmalloc/VMAllocate.h:
+        (bmalloc::vmValidate):
+        (bmalloc::vmAllocate):
+        (bmalloc::vmDeallocatePhysicalPagesSloppy):
+        * bmalloc/Vector.h:
+        (bmalloc::Vector<T>::operator):
+        (bmalloc::Vector<T>::pop):
+        (bmalloc::Vector<T>::shrink):
+        * bmalloc/XLargeChunk.h:
+        (bmalloc::XLargeChunk::range):
+        (bmalloc::XLargeChunk::size):
+
+2014-04-08  Geoffrey Garen  <ggaren@apple.com>
+
         Removed an unused file.
 
         Unreviewed.
index ea4cb4a..a5b3858 100644 (file)
                1448C30018F3754600502839 /* mbmalloc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1448C2FF18F3754300502839 /* mbmalloc.cpp */; };
                1448C30118F3754C00502839 /* bmalloc.h in Headers */ = {isa = PBXBuildFile; fileRef = 1448C2FE18F3754300502839 /* bmalloc.h */; settings = {ATTRIBUTES = (Private, ); }; };
                14CC394C18EA8858004AFE34 /* libbmalloc.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 14F271BE18EA3963008C152F /* libbmalloc.a */; };
+               14DD788C18F48CAE00950702 /* LargeChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 147AAA8818CD17CE002201E4 /* LargeChunk.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD788D18F48CC600950702 /* BeginTag.h in Headers */ = {isa = PBXBuildFile; fileRef = 1417F64518B54A700076FA3F /* BeginTag.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD788E18F48CCD00950702 /* BoundaryTag.h in Headers */ = {isa = PBXBuildFile; fileRef = 1485655E18A43AF900ED6942 /* BoundaryTag.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD789018F48CEB00950702 /* Sizes.h in Headers */ = {isa = PBXBuildFile; fileRef = 145F6874179DF84100D65598 /* Sizes.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD789218F48CFC00950702 /* EndTag.h in Headers */ = {isa = PBXBuildFile; fileRef = 1417F64618B54A700076FA3F /* EndTag.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD789318F48D0F00950702 /* ObjectType.h in Headers */ = {isa = PBXBuildFile; fileRef = 1485656018A43DBA00ED6942 /* ObjectType.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD789818F48D4A00950702 /* Allocator.h in Headers */ = {isa = PBXBuildFile; fileRef = 145F6856179DC8CA00D65598 /* Allocator.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD789918F48D4A00950702 /* Cache.h in Headers */ = {isa = PBXBuildFile; fileRef = 144469E517A46BFE00F9EA1D /* Cache.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD789A18F48D4A00950702 /* Deallocator.h in Headers */ = {isa = PBXBuildFile; fileRef = 145F685A179DC90200D65598 /* Deallocator.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD789B18F48D4A00950702 /* MediumAllocator.h in Headers */ = {isa = PBXBuildFile; fileRef = 1413E47018A0661700546D68 /* MediumAllocator.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD789C18F48D4A00950702 /* SmallAllocator.h in Headers */ = {isa = PBXBuildFile; fileRef = 1413E462189DE1CD00546D68 /* SmallAllocator.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78B418F48D6B00950702 /* Chunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 147AAA9418CE5CA6002201E4 /* Chunk.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78B518F48D6B00950702 /* Line.h in Headers */ = {isa = PBXBuildFile; fileRef = 14DA32071885F9E6007269E0 /* Line.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78B618F48D6B00950702 /* MediumChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 147AAA8E18CD89E3002201E4 /* MediumChunk.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78B718F48D6B00950702 /* MediumLine.h in Headers */ = {isa = PBXBuildFile; fileRef = 1452478518BC757C00F80098 /* MediumLine.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78B818F48D6B00950702 /* MediumPage.h in Headers */ = {isa = PBXBuildFile; fileRef = 143E29E918CAE8BE00FE8A0F /* MediumPage.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78B918F48D6B00950702 /* MediumTraits.h in Headers */ = {isa = PBXBuildFile; fileRef = 147AAA9618CE5FB6002201E4 /* MediumTraits.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78BA18F48D6B00950702 /* Page.h in Headers */ = {isa = PBXBuildFile; fileRef = 146BEE2318C980D60002D5A2 /* Page.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78BB18F48D6B00950702 /* SmallChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 147AAA8C18CD36A7002201E4 /* SmallChunk.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78BC18F48D6B00950702 /* SmallLine.h in Headers */ = {isa = PBXBuildFile; fileRef = 1452478618BC757C00F80098 /* SmallLine.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78BD18F48D6B00950702 /* SmallPage.h in Headers */ = {isa = PBXBuildFile; fileRef = 143E29ED18CAE90500FE8A0F /* SmallPage.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78BE18F48D6B00950702 /* SmallTraits.h in Headers */ = {isa = PBXBuildFile; fileRef = 147AAA9718CE5FB6002201E4 /* SmallTraits.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78C518F48D7500950702 /* Algorithm.h in Headers */ = {isa = PBXBuildFile; fileRef = 1421A87718EE462A00B4DD68 /* Algorithm.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78C618F48D7500950702 /* AsyncTask.h in Headers */ = {isa = PBXBuildFile; fileRef = 1417F65218BA88A00076FA3F /* AsyncTask.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78C718F48D7500950702 /* BAssert.h in Headers */ = {isa = PBXBuildFile; fileRef = 1413E468189EEDE400546D68 /* BAssert.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78C818F48D7500950702 /* FixedVector.h in Headers */ = {isa = PBXBuildFile; fileRef = 14D9DB4517F2447100EAAB79 /* FixedVector.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78C918F48D7500950702 /* Inline.h in Headers */ = {isa = PBXBuildFile; fileRef = 1413E460189DCE1E00546D68 /* Inline.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78CA18F48D7500950702 /* Mutex.h in Headers */ = {isa = PBXBuildFile; fileRef = 144DCED617A649D90093B2F2 /* Mutex.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78CB18F48D7500950702 /* PerProcess.h in Headers */ = {isa = PBXBuildFile; fileRef = 14446A0717A61FA400F9EA1D /* PerProcess.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78CC18F48D7500950702 /* PerThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 144469FD17A61F1F00F9EA1D /* PerThread.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78CD18F48D7500950702 /* Range.h in Headers */ = {isa = PBXBuildFile; fileRef = 145F6878179E3A4400D65598 /* Range.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78CE18F48D7500950702 /* Syscall.h in Headers */ = {isa = PBXBuildFile; fileRef = 1417F64F18B7280C0076FA3F /* Syscall.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78CF18F48D7500950702 /* Vector.h in Headers */ = {isa = PBXBuildFile; fileRef = 1479E21217A1A255006D4E9D /* Vector.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78D018F48D7500950702 /* VMAllocate.h in Headers */ = {isa = PBXBuildFile; fileRef = 1479E21417A1A63E006D4E9D /* VMAllocate.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               14DD78D118F48EC600950702 /* XLargeChunk.h in Headers */ = {isa = PBXBuildFile; fileRef = 147AAA8918CD17CE002201E4 /* XLargeChunk.h */; settings = {ATTRIBUTES = (Private, ); }; };
                14F271C318EA3978008C152F /* Allocator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 145F6855179DC8CA00D65598 /* Allocator.cpp */; };
                14F271C418EA397B008C152F /* Cache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 144469E417A46BFE00F9EA1D /* Cache.cpp */; };
                14F271C518EA397E008C152F /* Deallocator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 145F6859179DC90200D65598 /* Deallocator.cpp */; };
                        isa = PBXHeadersBuildPhase;
                        buildActionMask = 2147483647;
                        files = (
+                               14DD78B518F48D6B00950702 /* Line.h in Headers */,
+                               14DD78CF18F48D7500950702 /* Vector.h in Headers */,
+                               14DD788C18F48CAE00950702 /* LargeChunk.h in Headers */,
+                               14DD789218F48CFC00950702 /* EndTag.h in Headers */,
+                               14DD78CC18F48D7500950702 /* PerThread.h in Headers */,
+                               14DD78B418F48D6B00950702 /* Chunk.h in Headers */,
+                               14DD78CA18F48D7500950702 /* Mutex.h in Headers */,
+                               14DD78D118F48EC600950702 /* XLargeChunk.h in Headers */,
+                               14DD78B918F48D6B00950702 /* MediumTraits.h in Headers */,
                                1448C30118F3754C00502839 /* bmalloc.h in Headers */,
+                               14DD789A18F48D4A00950702 /* Deallocator.h in Headers */,
+                               14DD788D18F48CC600950702 /* BeginTag.h in Headers */,
+                               14DD78CD18F48D7500950702 /* Range.h in Headers */,
+                               14DD789C18F48D4A00950702 /* SmallAllocator.h in Headers */,
+                               14DD789918F48D4A00950702 /* Cache.h in Headers */,
+                               14DD789B18F48D4A00950702 /* MediumAllocator.h in Headers */,
+                               14DD78BE18F48D6B00950702 /* SmallTraits.h in Headers */,
+                               14DD789018F48CEB00950702 /* Sizes.h in Headers */,
+                               14DD78C718F48D7500950702 /* BAssert.h in Headers */,
+                               14DD78D018F48D7500950702 /* VMAllocate.h in Headers */,
+                               14DD78CE18F48D7500950702 /* Syscall.h in Headers */,
+                               14DD78C618F48D7500950702 /* AsyncTask.h in Headers */,
+                               14DD78BA18F48D6B00950702 /* Page.h in Headers */,
+                               14DD78BB18F48D6B00950702 /* SmallChunk.h in Headers */,
+                               14DD78C918F48D7500950702 /* Inline.h in Headers */,
+                               14DD78B818F48D6B00950702 /* MediumPage.h in Headers */,
+                               14DD78C518F48D7500950702 /* Algorithm.h in Headers */,
+                               14DD78BD18F48D6B00950702 /* SmallPage.h in Headers */,
+                               14DD788E18F48CCD00950702 /* BoundaryTag.h in Headers */,
+                               14DD78C818F48D7500950702 /* FixedVector.h in Headers */,
+                               14DD78B718F48D6B00950702 /* MediumLine.h in Headers */,
+                               14DD78B618F48D6B00950702 /* MediumChunk.h in Headers */,
+                               14DD78BC18F48D6B00950702 /* SmallLine.h in Headers */,
+                               14DD789818F48D4A00950702 /* Allocator.h in Headers */,
+                               14DD78CB18F48D7500950702 /* PerProcess.h in Headers */,
+                               14DD789318F48D0F00950702 /* ObjectType.h in Headers */,
                        );
                        runOnlyForDeploymentPostprocessing = 0;
                };
index 60708fe..59d5cf8 100644 (file)
@@ -137,7 +137,7 @@ void* Allocator::allocateSlowCase(size_t size)
 {
 IF_DEBUG(
     void* dummy;
-    ASSERT(!allocateFastCase(size, dummy));
+    BASSERT(!allocateFastCase(size, dummy));
 )
     if (size <= smallMax) {
         SmallAllocator& allocator = smallAllocatorFor(size);
index b8c8bf8..e7cb952 100644 (file)
@@ -109,7 +109,7 @@ NO_INLINE void AsyncTask<Object, Function>::runSlowCase()
         return;
     }
 
-    ASSERT(oldState == Exited);
+    BASSERT(oldState == Exited);
     pthread_create(&m_thread, nullptr, &pthreadEntryPoint, this);
     pthread_detach(m_thread);
 }
index 92a627f..f58a2af 100644 (file)
 #ifndef BAssert_h
 #define BAssert_h
 
-#define ASSERT_IMPL(x) do { \
+#define BASSERT_IMPL(x) do { \
     if (!(x)) \
         *(int*)0xbbadbeef = 0; \
 } while(0);
 
-#define RELEASE_ASSERT(x) ASSERT_IMPL(x)
+#define RELEASE_BASSERT(x) BASSERT_IMPL(x)
 
 #define UNUSED(x) (void)x
 
@@ -39,7 +39,7 @@
 
 #if defined(NDEBUG)
 
-#define ASSERT(x)
+#define BASSERT(x)
 
 #define IF_DEBUG(x...)
 
@@ -50,7 +50,7 @@
 
 #if !defined(NDEBUG)
 
-#define ASSERT(x) ASSERT_IMPL(x)
+#define BASSERT(x) BASSERT_IMPL(x)
 
 #define IF_DEBUG(x...) x
 
index 9f46b33..0b251b2 100644 (file)
@@ -85,8 +85,8 @@ private:
 inline void BoundaryTag::setSize(size_t size)
 {
     m_size = static_cast<unsigned>(size);
-    ASSERT(this->size() == size);
-    ASSERT(!isXLarge());
+    BASSERT(this->size() == size);
+    BASSERT(!isXLarge());
 }
 
 inline EndTag* BoundaryTag::prev()
index 2561c9f..4686a8a 100644 (file)
@@ -41,18 +41,18 @@ IF_DEBUG(
     BeginTag* beginTag = LargeChunk::beginTag(range.begin());
     EndTag* endTag = LargeChunk::endTag(range.begin(), range.size());
 
-    ASSERT(!beginTag->isEnd());
+    BASSERT(!beginTag->isEnd());
     if (beginTag->isXLarge())
         return;
 )
-    ASSERT(range.size() >= largeMin);
-    ASSERT(beginTag->size() == range.size());
-
-    ASSERT(beginTag->size() == endTag->size());
-    ASSERT(beginTag->isFree() == endTag->isFree());
-    ASSERT(beginTag->hasPhysicalPages() == endTag->hasPhysicalPages());
-    ASSERT(beginTag->isXLarge() == endTag->isXLarge());
-    ASSERT(static_cast<BoundaryTag*>(endTag) == static_cast<BoundaryTag*>(beginTag) || endTag->isEnd());
+    BASSERT(range.size() >= largeMin);
+    BASSERT(beginTag->size() == range.size());
+
+    BASSERT(beginTag->size() == endTag->size());
+    BASSERT(beginTag->isFree() == endTag->isFree());
+    BASSERT(beginTag->hasPhysicalPages() == endTag->hasPhysicalPages());
+    BASSERT(beginTag->isXLarge() == endTag->isXLarge());
+    BASSERT(static_cast<BoundaryTag*>(endTag) == static_cast<BoundaryTag*>(beginTag) || endTag->isEnd());
 }
 
 static inline void validatePrev(EndTag* prev, void* object)
@@ -96,12 +96,12 @@ inline Range BoundaryTag::init(LargeChunk* chunk)
     // special-case checks.
     
     EndTag* leftSentinel = beginTag->prev();
-    ASSERT(leftSentinel >= static_cast<void*>(chunk));
+    BASSERT(leftSentinel >= static_cast<void*>(chunk));
     leftSentinel->setSize(largeMin);
     leftSentinel->setFree(false);
 
     BeginTag* rightSentinel = endTag->next();
-    ASSERT(rightSentinel < static_cast<void*>(range.begin()));
+    BASSERT(rightSentinel < static_cast<void*>(range.begin()));
     rightSentinel->setSize(largeMin);
     rightSentinel->setFree(false);
     
@@ -163,8 +163,8 @@ INLINE void BoundaryTag::mergeLarge(BeginTag*& beginTag, EndTag*& endTag, Range&
 inline Range BoundaryTag::deallocate(void* object)
 {
     BeginTag* beginTag = LargeChunk::beginTag(object);
-    ASSERT(!beginTag->isFree());
-    ASSERT(!beginTag->isXLarge())
+    BASSERT(!beginTag->isFree());
+    BASSERT(!beginTag->isXLarge())
 
     Range range(object, beginTag->size());
     EndTag* endTag = LargeChunk::endTag(range.begin(), range.size());
@@ -182,7 +182,7 @@ INLINE void BoundaryTag::splitLarge(BeginTag* beginTag, size_t size, EndTag*& en
         *splitEndTag = *beginTag;
 
     leftover = Range(range.begin() + size, range.size() - size);
-    ASSERT(leftover.size() >= largeMin);
+    BASSERT(leftover.size() >= largeMin);
     BeginTag* leftoverBeginTag = LargeChunk::beginTag(leftover.begin());
     *leftoverBeginTag = *beginTag;
     leftoverBeginTag->setSize(leftover.size());
@@ -202,7 +202,7 @@ INLINE void BoundaryTag::allocate(size_t size, Range& range, Range& leftover, bo
     BeginTag* beginTag = LargeChunk::beginTag(range.begin());
     EndTag* endTag = LargeChunk::endTag(range.begin(), range.size());
 
-    ASSERT(beginTag->isFree());
+    BASSERT(beginTag->isFree());
     validate(beginTag->prev(), range, endTag->next());
 
     if (range.size() - size > largeMin)
index c1202d7..b05c5ce 100644 (file)
@@ -77,7 +77,7 @@ inline auto Chunk<Traits>::create() -> Chunk*
 template<class Traits>
 inline auto Chunk<Traits>::get(void* object) -> Chunk*
 {
-    ASSERT(isSmallOrMedium(object));
+    BASSERT(isSmallOrMedium(object));
     return static_cast<Chunk*>(mask(object, chunkMask));
 }
 
index ff511b6..2e7cbf9 100644 (file)
@@ -81,7 +81,7 @@ void Deallocator::processObjectLog()
                 continue;
             deallocateSmallLine(lock, line);
         } else {
-            ASSERT(isSmallOrMedium(object));
+            BASSERT(isSmallOrMedium(object));
             MediumLine* line = MediumLine::get(object);
             if (!line->deref(lock))
                 continue;
@@ -94,7 +94,7 @@ void Deallocator::processObjectLog()
 
 void Deallocator::deallocateSlowCase(void* object)
 {
-    ASSERT(!deallocateFastCase(object));
+    BASSERT(!deallocateFastCase(object));
 
     if (!object)
         return;
index 6f55de6..e01685f 100644 (file)
@@ -65,7 +65,7 @@ inline bool Deallocator::deallocateFastCase(void* object)
     if (!isSmallOrMedium(object))
         return false;
 
-    ASSERT(object);
+    BASSERT(object);
 
     if (m_objectLog.size() == m_objectLog.capacity())
         return false;
index b6ef049..d42e151 100644 (file)
@@ -76,14 +76,14 @@ inline FixedVector<T, Capacity>::FixedVector()
 template<typename T, size_t Capacity>
 inline T& FixedVector<T, Capacity>::operator[](size_t i)
 {
-    ASSERT(i < m_size);
+    BASSERT(i < m_size);
     return m_buffer[i];
 }
 
 template<typename T, size_t Capacity>
 inline void FixedVector<T, Capacity>::push(const T& value)
 {
-    ASSERT(m_size < Capacity);
+    BASSERT(m_size < Capacity);
     m_buffer[m_size++] = value;
 }
 
@@ -97,14 +97,14 @@ inline void FixedVector<T, Capacity>::push(const T* begin, const T* end)
 template<typename T, size_t Capacity>
 inline T FixedVector<T, Capacity>::pop()
 {
-    ASSERT(m_size);
+    BASSERT(m_size);
     return m_buffer[--m_size];
 }
 
 template<typename T, size_t Capacity>
 inline void FixedVector<T, Capacity>::shrink(size_t size)
 {
-    ASSERT(size <= m_size);
+    BASSERT(size <= m_size);
     m_size = size;
 }
 
index a3646bb..6923ee4 100644 (file)
@@ -170,8 +170,8 @@ void Heap::deallocateXLarge(std::lock_guard<Mutex>&, void* object)
 
 void* Heap::allocateLarge(std::lock_guard<Mutex>&, size_t size)
 {
-    ASSERT(size <= largeMax);
-    ASSERT(size >= largeMin);
+    BASSERT(size <= largeMax);
+    BASSERT(size >= largeMin);
     
     m_isAllocatingPages = true;
 
index 4b01d1a..c011e76 100644 (file)
@@ -76,7 +76,7 @@ inline LargeChunk* LargeChunk::create()
 
 inline LargeChunk* LargeChunk::get(void* object)
 {
-    ASSERT(!isSmallOrMedium(object));
+    BASSERT(!isSmallOrMedium(object));
     return static_cast<LargeChunk*>(mask(object, largeChunkMask));
 }
 
@@ -89,7 +89,7 @@ inline BeginTag* LargeChunk::beginTag(void* object)
 
 inline EndTag* LargeChunk::endTag(void* object, size_t size)
 {
-    ASSERT(!isSmallOrMedium(object));
+    BASSERT(!isSmallOrMedium(object));
 
     LargeChunk* chunk = get(object);
     char* end = static_cast<char*>(object) + size;
index 84e003c..2145edd 100644 (file)
@@ -58,7 +58,7 @@ private:
 template<class Traits>
 inline auto Line<Traits>::get(void* object) -> Line*
 {
-    ASSERT(isSmallOrMedium(object));
+    BASSERT(isSmallOrMedium(object));
     Chunk* chunk = Chunk::get(object);
     size_t lineNumber = (reinterpret_cast<char*>(object) - reinterpret_cast<char*>(chunk)) / lineSize;
     return &chunk->lines()[lineNumber];
@@ -82,15 +82,15 @@ inline char* Line<Traits>::end()
 template<class Traits>
 inline void Line<Traits>::concurrentRef(unsigned char count)
 {
-    ASSERT(!m_refCount); // Up-ref from zero can be lock-free because there are no other clients.
-    ASSERT(count <= maxRefCount);
+    BASSERT(!m_refCount); // Up-ref from zero can be lock-free because there are no other clients.
+    BASSERT(count <= maxRefCount);
     m_refCount = count;
 }
 
 template<class Traits>
 inline bool Line<Traits>::deref(std::lock_guard<Mutex>&, unsigned char count)
 {
-    ASSERT(count <= m_refCount);
+    BASSERT(count <= m_refCount);
     m_refCount -= count;
     return !m_refCount;
 }
index a47b1ed..a4bf938 100644 (file)
@@ -67,13 +67,13 @@ inline MediumLine* MediumAllocator::line()
 
 inline void* MediumAllocator::allocate(size_t size)
 {
-    ASSERT(size <= m_remaining);
-    ASSERT(size == roundUpToMultipleOf<alignment>(size));
-    ASSERT(size >= MediumLine::minimumObjectSize);
+    BASSERT(size <= m_remaining);
+    BASSERT(size == roundUpToMultipleOf<alignment>(size));
+    BASSERT(size >= MediumLine::minimumObjectSize);
 
     m_remaining -= size;
     void* object = m_end - m_remaining - size;
-    ASSERT(isSmallOrMedium(object) && !isSmall(object));
+    BASSERT(isSmallOrMedium(object) && !isSmall(object));
 
     ++m_objectCount;
     return object;
index bce8aee..6558da1 100644 (file)
@@ -42,7 +42,7 @@ inline bool isSmallOrMedium(void* object)
 
 inline bool isSmall(void* smallOrMedium)
 {
-    ASSERT(isSmallOrMedium(smallOrMedium));
+    BASSERT(isSmallOrMedium(smallOrMedium));
     return test(smallOrMedium, smallOrMediumSmallTypeMask);
 }
 
index 981a8e7..4a0211f 100644 (file)
@@ -59,14 +59,14 @@ private:
 template<typename Traits>
 inline void Page<Traits>::ref(std::lock_guard<Mutex>&)
 {
-    ASSERT(m_refCount < maxRefCount);
+    BASSERT(m_refCount < maxRefCount);
     ++m_refCount;
 }
 
 template<typename Traits>
 inline bool Page<Traits>::deref(std::lock_guard<Mutex>&)
 {
-    ASSERT(m_refCount);
+    BASSERT(m_refCount);
     --m_refCount;
     return !m_refCount;
 }
index 7079fd1..f203320 100644 (file)
@@ -117,7 +117,7 @@ void PerThread<T>::destructor(void* p)
 template<typename T>
 T* PerThread<T>::getSlowCase()
 {
-    ASSERT(!getFastCase());
+    BASSERT(!getFastCase());
     T* t = new T;
     PerThreadStorage<T>::init(t, destructor);
     return t;
index faf9250..b8fc6fd 100644 (file)
@@ -32,14 +32,14 @@ namespace bmalloc {
 
 SegregatedFreeList::SegregatedFreeList()
 {
-    ASSERT(static_cast<size_t>(&select(largeMax) - m_lists.begin()) == m_lists.size() - 1);
+    BASSERT(static_cast<size_t>(&select(largeMax) - m_lists.begin()) == m_lists.size() - 1);
 }
 
 void SegregatedFreeList::insert(const Range& range)
 {
 IF_DEBUG(
     BeginTag* beginTag = LargeChunk::beginTag(range.begin());
-    ASSERT(beginTag->isInFreeList(range.size()));
+    BASSERT(beginTag->isInFreeList(range.size()));
 )
 
     auto& list = select(range.size());
index ccd2abb..842bf05 100644 (file)
@@ -79,13 +79,13 @@ inline SmallLine* SmallAllocator::line()
 
 inline void* SmallAllocator::allocate()
 {
-    ASSERT(m_remaining);
-    ASSERT(m_size >= SmallLine::minimumObjectSize);
+    BASSERT(m_remaining);
+    BASSERT(m_size >= SmallLine::minimumObjectSize);
 
     --m_remaining;
     char* result = m_ptr;
     m_ptr += m_size;
-    ASSERT(isSmall(result));
+    BASSERT(isSmall(result));
     return result;
 }
 
@@ -101,7 +101,7 @@ inline unsigned char SmallAllocator::derefCount()
 
 inline void SmallAllocator::refill(SmallLine* line)
 {
-    ASSERT(!canAllocate());
+    BASSERT(!canAllocate());
     line->concurrentRef(SmallLine::maxRefCount);
     m_ptr = line->begin();
     m_remaining = m_maxObjectCount;
index 6462bfb..f239ed2 100644 (file)
@@ -30,7 +30,7 @@
 
 #define SYSCALL(x) do { \
     while ((x) == -1) \
-        RELEASE_ASSERT(errno == EAGAIN); \
+        RELEASE_BASSERT(errno == EAGAIN); \
 } while (0);
 
 #endif // Syscall_h
index 84e4489..231ea25 100644 (file)
@@ -50,8 +50,8 @@ inline size_t vmSize(size_t size)
 inline void vmValidate(size_t vmSize)
 {
     UNUSED(vmSize);
-    ASSERT(vmSize);
-    ASSERT(vmSize == bmalloc::vmSize(vmSize));
+    BASSERT(vmSize);
+    BASSERT(vmSize == bmalloc::vmSize(vmSize));
 }
 
 inline void vmValidate(void* p, size_t vmSize)
@@ -61,8 +61,8 @@ inline void vmValidate(void* p, size_t vmSize)
     // We use getpagesize() here instead of vmPageSize because vmPageSize is
     // allowed to be larger than the OS's true page size.
     UNUSED(p);
-    ASSERT(p);
-    ASSERT(p == mask(p, ~(getpagesize() - 1)));
+    BASSERT(p);
+    BASSERT(p == mask(p, ~(getpagesize() - 1)));
 }
 
 inline void* vmAllocate(size_t vmSize)
@@ -83,7 +83,7 @@ inline void vmDeallocate(void* p, size_t vmSize)
 inline std::pair<void*, Range> vmAllocate(size_t vmSize, size_t alignment, size_t offset)
 {
     vmValidate(vmSize);
-    ASSERT(isPowerOfTwo(alignment));
+    BASSERT(isPowerOfTwo(alignment));
 
     size_t mappedSize = std::max(vmSize, alignment) + alignment;
     char* mapped = static_cast<char*>(vmAllocate(mappedSize));
@@ -118,7 +118,7 @@ inline void vmAllocatePhysicalPages(void* p, size_t vmSize)
 // Trims requests that are un-page-aligned. NOTE: size must be at least a page.
 inline void vmDeallocatePhysicalPagesSloppy(void* p, size_t size)
 {
-    ASSERT(size >= vmPageSize);
+    BASSERT(size >= vmPageSize);
 
     char* begin = roundUpToMultipleOf<vmPageSize>(static_cast<char*>(p));
     char* end = roundDownToMultipleOf<vmPageSize>(static_cast<char*>(p) + size);
index a3d1666..ebcf94d 100644 (file)
@@ -94,7 +94,7 @@ Vector<T>::~Vector()
 template<typename T>
 inline T& Vector<T>::operator[](size_t i)
 {
-    ASSERT(i < m_size);
+    BASSERT(i < m_size);
     return m_buffer[i];
 }
 
@@ -119,7 +119,7 @@ void Vector<T>::push(const T* begin, const T* end)
 template<typename T>
 inline T Vector<T>::pop()
 {
-    ASSERT(m_size);
+    BASSERT(m_size);
     T value = m_buffer[m_size - 1];
     shrink(m_size - 1);
     return value;
@@ -128,7 +128,7 @@ inline T Vector<T>::pop()
 template<typename T>
 inline T Vector<T>::pop(size_t i)
 {
-    ASSERT(i < m_size);
+    BASSERT(i < m_size);
     std::swap(m_buffer[i], last());
     return pop();
 }
@@ -136,7 +136,7 @@ inline T Vector<T>::pop(size_t i)
 template<typename T>
 inline void Vector<T>::shrink(size_t size)
 {
-    ASSERT(size <= m_size);
+    BASSERT(size <= m_size);
     m_size = size;
     if (m_capacity > initialCapacity && m_size < m_capacity / shrinkFactor)
         shrinkCapacity();
index a56877f..878b2a0 100644 (file)
@@ -71,7 +71,7 @@ inline Range& XLargeChunk::range()
     // Since we hold only one object, we only use our first BoundaryTag. So, we
     // can stuff our range into the remaining metadata.
     Range& result = *reinterpret_cast<Range*>(roundUpToMultipleOf<alignment>(LargeChunk::beginTag(begin()) + 1));
-    ASSERT(static_cast<void*>(&result) < static_cast<void*>(begin()));
+    BASSERT(static_cast<void*>(&result) < static_cast<void*>(begin()));
     return result;
 }
 
@@ -80,7 +80,7 @@ inline size_t& XLargeChunk::size()
     // Since we hold only one object, we only use our first BoundaryTag. So, we
     // can stuff our size into the remaining metadata.
     size_t& result = *reinterpret_cast<size_t*>(roundUpToMultipleOf<alignment>(&range() + 1));
-    ASSERT(static_cast<void*>(&result) < static_cast<void*>(begin()));
+    BASSERT(static_cast<void*>(&result) < static_cast<void*>(begin()));
     return result;
 }