bmalloc: added some infrastructure for aligned allocation

https://bugs.webkit.org/show_bug.cgi?id=140572

Reviewed by Andreas Kling.

* bmalloc/Algorithm.h:
(bmalloc::isPowerOfTwo):
(bmalloc::roundUpToMultipleOf):
(bmalloc::roundDownToMultipleOf): Refactored some duplicate code to use our
isPowerOfTwo helper function.

* bmalloc/Allocator.cpp:
(bmalloc::Allocator::allocate):
* bmalloc/Allocator.h: Stubbed out an implementation of aligned allocation.
Doesn't do anything yet, but does correctly forward to system malloc
when bmalloc is disabled.

* bmalloc/Cache.cpp:
(bmalloc::Cache::allocateSlowCaseNullCache):
* bmalloc/Cache.h:
(bmalloc::Cache::allocate):
* bmalloc/bmalloc.h:
(bmalloc::api::memalign):
* bmalloc/mbmalloc.cpp: Stubbed out an API for aligned allocation.

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

diff --git a/Source/bmalloc/ChangeLog b/Source/bmalloc/ChangeLog
index 8adbd2a..c06f22f 100644 (file)
--- a/Source/bmalloc/ChangeLog
+++ b/Source/bmalloc/ChangeLog
@@ -1,3 +1,30 @@
+2015-01-16  Geoffrey Garen  <ggaren@apple.com>
+
+        bmalloc: added some infrastructure for aligned allocation
+        https://bugs.webkit.org/show_bug.cgi?id=140572
+
+        Reviewed by Andreas Kling.
+
+        * bmalloc/Algorithm.h:
+        (bmalloc::isPowerOfTwo):
+        (bmalloc::roundUpToMultipleOf):
+        (bmalloc::roundDownToMultipleOf): Refactored some duplicate code to use our
+        isPowerOfTwo helper function.
+
+        * bmalloc/Allocator.cpp:
+        (bmalloc::Allocator::allocate):
+        * bmalloc/Allocator.h: Stubbed out an implementation of aligned allocation.
+        Doesn't do anything yet, but does correctly forward to system malloc
+        when bmalloc is disabled.
+
+        * bmalloc/Cache.cpp:
+        (bmalloc::Cache::allocateSlowCaseNullCache):
+        * bmalloc/Cache.h:
+        (bmalloc::Cache::allocate):
+        * bmalloc/bmalloc.h:
+        (bmalloc::api::memalign):
+        * bmalloc/mbmalloc.cpp: Stubbed out an API for aligned allocation.
+
 2015-01-13  Geoffrey Garen  <ggaren@apple.com>
 
         Consider alignment when allocating from a SegregatedFreeList

diff --git a/Source/bmalloc/bmalloc/Algorithm.h b/Source/bmalloc/bmalloc/Algorithm.h
index f476634..41dbfc9 100644 (file)
--- a/Source/bmalloc/bmalloc/Algorithm.h
+++ b/Source/bmalloc/bmalloc/Algorithm.h
@@ -62,21 +62,26 @@ template<typename T> inline constexpr bool test(T value, uintptr_t mask)
     return !!(reinterpret_cast<uintptr_t>(value) & mask);
 }
 
+inline constexpr bool isPowerOfTwo(size_t size)
+{
+    return !(size & (size - 1));
+}
+
 template<typename T> inline T roundUpToMultipleOf(size_t divisor, T x)
 {
-    BASSERT(divisor && !(divisor & (divisor - 1)));
+    BASSERT(isPowerOfTwo(divisor));
     return reinterpret_cast<T>((reinterpret_cast<uintptr_t>(x) + (divisor - 1ul)) & ~(divisor - 1ul));
 }
 
 template<size_t divisor, typename T> inline constexpr T roundUpToMultipleOf(T x)
 {
-    static_assert(divisor && !(divisor & (divisor - 1)), "'divisor' must be a power of two.");
+    static_assert(isPowerOfTwo(divisor), "'divisor' must be a power of two.");
     return roundUpToMultipleOf(divisor, x);
 }
 
 template<size_t divisor, typename T> inline constexpr T roundDownToMultipleOf(T x)
 {
-    static_assert(divisor && !(divisor & (divisor - 1)), "'divisor' must be a power of two.");
+    static_assert(isPowerOfTwo(divisor), "'divisor' must be a power of two.");
     return reinterpret_cast<T>(mask(reinterpret_cast<uintptr_t>(x), ~(divisor - 1ul)));
 }
 
@@ -101,11 +106,6 @@ template<typename T> inline constexpr size_t bitCount()
     return sizeof(T) * 8;
 }
 
-inline constexpr bool isPowerOfTwo(size_t size)
-{
-    return !(size & (size - 1));
-}
-
 } // namespace bmalloc
 
 #endif // Algorithm_h

diff --git a/Source/bmalloc/bmalloc/Allocator.cpp b/Source/bmalloc/bmalloc/Allocator.cpp
index eaef370..9353029 100644 (file)
--- a/Source/bmalloc/bmalloc/Allocator.cpp
+++ b/Source/bmalloc/bmalloc/Allocator.cpp
@@ -51,6 +51,18 @@ Allocator::~Allocator()
     scavenge();
 }
 
+void* Allocator::allocate(size_t alignment, size_t size)
+{
+    if (!m_isBmallocEnabled) {
+        void* result = nullptr;
+        posix_memalign(&result, alignment, size);
+        return result;
+    }
+    
+    BASSERT(isPowerOfTwo(alignment));
+    return nullptr;
+}
+
 void* Allocator::reallocate(void* object, size_t newSize)
 {
     if (!m_isBmallocEnabled)

diff --git a/Source/bmalloc/bmalloc/Allocator.h b/Source/bmalloc/bmalloc/Allocator.h
index 705d364..daea0c7 100644 (file)
--- a/Source/bmalloc/bmalloc/Allocator.h
+++ b/Source/bmalloc/bmalloc/Allocator.h
@@ -42,6 +42,7 @@ public:
     ~Allocator();
 
     void* allocate(size_t);
+    void* allocate(size_t alignment, size_t);
     void* reallocate(void*, size_t);
 
     void scavenge();

diff --git a/Source/bmalloc/bmalloc/Cache.cpp b/Source/bmalloc/bmalloc/Cache.cpp
index 1c703ee..e3e92cd 100644 (file)
--- a/Source/bmalloc/bmalloc/Cache.cpp
+++ b/Source/bmalloc/bmalloc/Cache.cpp
@@ -64,6 +64,11 @@ NO_INLINE void* Cache::allocateSlowCaseNullCache(size_t size)
     return PerThread<Cache>::getSlowCase()->allocator().allocate(size);
 }
 
+NO_INLINE void* Cache::allocateSlowCaseNullCache(size_t alignment, size_t size)
+{
+    return PerThread<Cache>::getSlowCase()->allocator().allocate(alignment, size);
+}
+
 NO_INLINE void Cache::deallocateSlowCaseNullCache(void* object)
 {
     PerThread<Cache>::getSlowCase()->deallocator().deallocate(object);

diff --git a/Source/bmalloc/bmalloc/Cache.h b/Source/bmalloc/bmalloc/Cache.h
index 2bfa704..472c5df 100644 (file)
--- a/Source/bmalloc/bmalloc/Cache.h
+++ b/Source/bmalloc/bmalloc/Cache.h
@@ -40,6 +40,7 @@ public:
     void operator delete(void*, size_t);
 
     static void* allocate(size_t);
+    static void* allocate(size_t alignment, size_t);
     static void deallocate(void*);
     static void* reallocate(void*, size_t);
     static void scavenge();
@@ -51,6 +52,7 @@ public:
 
 private:
     static void* allocateSlowCaseNullCache(size_t);
+    static void* allocateSlowCaseNullCache(size_t alignment, size_t);
     static void deallocateSlowCaseNullCache(void*);
     static void* reallocateSlowCaseNullCache(void*, size_t);
 
@@ -66,6 +68,14 @@ inline void* Cache::allocate(size_t size)
     return cache->allocator().allocate(size);
 }
 
+inline void* Cache::allocate(size_t alignment, size_t size)
+{
+    Cache* cache = PerThread<Cache>::getFastCase();
+    if (!cache)
+        return allocateSlowCaseNullCache(alignment, size);
+    return cache->allocator().allocate(alignment, size);
+}
+
 inline void Cache::deallocate(void* object)
 {
     Cache* cache = PerThread<Cache>::getFastCase();

diff --git a/Source/bmalloc/bmalloc/bmalloc.h b/Source/bmalloc/bmalloc/bmalloc.h
index 54ca191..6d944c9 100644 (file)
--- a/Source/bmalloc/bmalloc/bmalloc.h
+++ b/Source/bmalloc/bmalloc/bmalloc.h
@@ -33,6 +33,11 @@ inline void* malloc(size_t size)
     return Cache::allocate(size);
 }
 
+inline void* memalign(size_t alignment, size_t size)
+{
+    return Cache::allocate(alignment, size);
+}
+
 inline void free(void* object)
 {
     Cache::deallocate(object);

diff --git a/Source/bmalloc/bmalloc/mbmalloc.cpp b/Source/bmalloc/bmalloc/mbmalloc.cpp
index 43ad4a4..f31a80d 100644 (file)
--- a/Source/bmalloc/bmalloc/mbmalloc.cpp
+++ b/Source/bmalloc/bmalloc/mbmalloc.cpp
@@ -30,6 +30,7 @@
 extern "C" {
 
 EXPORT void* mbmalloc(size_t);
+EXPORT void* mbmemalign(size_t, size_t);
 EXPORT void mbfree(void*, size_t);
 EXPORT void* mbrealloc(void*, size_t, size_t);
 EXPORT void mbscavenge();
@@ -39,6 +40,11 @@ void* mbmalloc(size_t size)
     return bmalloc::api::malloc(size);
 }
 
+void* mbmemalign(size_t alignment, size_t size)
+{
+    return bmalloc::api::memalign(alignment, size);
+}
+
 void mbfree(void* p, size_t)
 {
     bmalloc::api::free(p);