Implement aligned_alloc

5 files changed, 66 insertions, 14 deletions

diff --git a/vespamalloc/src/tests/test1/new_test.cpp b/vespamalloc/src/tests/test1/new_test.cpp
index dfa67f2aa7c..9ea4418aad5 100644
--- a/vespamalloc/src/tests/test1/new_test.cpp
+++ b/vespamalloc/src/tests/test1/new_test.cpp
@@ -1,6 +1,7 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #include <vespa/vespalib/testkit/testapp.h>
 #include <vespa/vespalib/util/size_literals.h>
+#include <vespa/vespalib/util/optimized.h>
 #include <vespa/log/log.h>
 #include <malloc.h>
 #include <dlfcn.h>
@@ -250,4 +251,43 @@ TEST("test realloc large buffers") {
     EXPECT_EQUAL(1, mallopt(M_MMAP_THRESHOLD, 1_Gi));
 }
 
+void verify_alignment(void * ptr, size_t align, size_t min_sz) {
+    EXPECT_NOT_EQUAL(ptr, nullptr);
+    EXPECT_EQUAL(0u, size_t(ptr) & (align-1));
+    assert(0ul == (size_t(ptr) & (align-1)));
+    EXPECT_GREATER_EQUAL(malloc_usable_size(ptr), min_sz);
+    free(ptr);
+}
+
+TEST("test memalign") {
+    verify_alignment(memalign(0, 0), 1, 1);
+    verify_alignment(memalign(0, 1), 1, 1);
+    verify_alignment(memalign(1, 0), 1, 1);
+
+    for (size_t align : {3,7,19}) {
+        // According to man pages these should fail, but it seems it rounds up and does best effort
+        verify_alignment(memalign(align, 73), 1ul << vespalib::Optimized::msbIdx(align), 73);
+    }
+    for (size_t align : {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536}) {
+        verify_alignment(memalign(align, 1), align, 1);
+    }
+}
+
+TEST("test aligned_alloc") {
+    verify_alignment(aligned_alloc(0, 0), 1, 1);
+    verify_alignment(aligned_alloc(0, 1), 1, 1);
+    verify_alignment(aligned_alloc(1, 0), 1, 1);
+    for (size_t align : {3,7,19}) {
+        // According to man pages these should fail, but it seems it rounds up and does best effort
+        verify_alignment(aligned_alloc(align, align*7), 1ul << vespalib::Optimized::msbIdx(align), align*7);
+    }
+    for (size_t align : {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536}) {
+        verify_alignment(aligned_alloc(align, align*7), align, align*7);
+    }
+    for (size_t sz : {31,33,63}) {
+        // According to man pages these should fail, but it seems it rounds up and does best effort
+        verify_alignment(aligned_alloc(32, sz), 32, sz);
+    }
+}
+
 TEST_MAIN() { TEST_RUN_ALL(); }
diff --git a/vespamalloc/src/vespamalloc/malloc/malloc.h b/vespamalloc/src/vespamalloc/malloc/malloc.h
index 0ecdb8c58e1..5867852db31 100644
--- a/vespamalloc/src/vespamalloc/malloc/malloc.h
+++ b/vespamalloc/src/vespamalloc/malloc/malloc.h
@@ -73,7 +73,7 @@ public:
     size_t getMinSizeForAlignment(size_t align, size_t sz) const { return MemBlockPtrT::getMinSizeForAlignment(align, sz); }
     size_t sizeClass(const void *ptr) const { return _segment.sizeClass(ptr); }
     size_t usable_size(void *ptr) const {
-        return MemBlockPtrT::usable_size(ptr, _segment.getMaxSize<MemBlockPtrT>(ptr));
+        return MemBlockPtrT::usable_size(ptr, _segment);
     }
 
     void * calloc(size_t nelm, size_t esz) {
diff --git a/vespamalloc/src/vespamalloc/malloc/memblock.h b/vespamalloc/src/vespamalloc/malloc/memblock.h
index f7b5923ecff..ee090de6f3d 100644
--- a/vespamalloc/src/vespamalloc/malloc/memblock.h
+++ b/vespamalloc/src/vespamalloc/malloc/memblock.h
@@ -18,7 +18,7 @@ public:
         SizeClassSpan = (MaxSizeClassMultiAllocC-MinSizeClassC)
     };
     MemBlockT() : _ptr(nullptr) { }
-    MemBlockT(void * p) : _ptr(p) { }
+    explicit MemBlockT(void * p) : _ptr(p) { }
     MemBlockT(void * p, size_t /*sz*/) : _ptr(p) { }
     MemBlockT(void * p, size_t, bool) : _ptr(p) { }
     template<typename T>
@@ -34,8 +34,9 @@ public:
     void setThreadId(uint32_t ) { }
     void free()               { }
     size_t size()       const { return 0; }
-    static size_t usable_size(void *, size_t classSize) {
-        return classSize;
+    template<typename T>
+    static size_t usable_size(void * ptr, const T & segment) {
+        return segment.template getMaxSize<MemBlockT>(ptr);
     }
     bool allocated()    const { return false; }
     uint32_t threadId()      const { return 0; }
diff --git a/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h b/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h
index 9d46dbce378..67b98701d8e 100644
--- a/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h
+++ b/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h
@@ -103,8 +103,11 @@ public:
             && ((p[3] == ALLOC_MAGIC) || (p[3] == FREE_MAGIC))
             && *(reinterpret_cast<const unsigned *> ((const char*)_ptr + size() + alignment() + StackTraceLen*sizeof(void *))) == TAIL_MAGIC;
     }
-    static size_t usable_size(void *ptr, size_t ) {
-        return MemBlockBoundsCheckBaseT(ptr).size();
+    template<typename T>
+    static size_t usable_size(void *ptr, const T & segment) {
+        MemBlockBoundsCheckBaseT mem(ptr);
+        mem.readjustAlignment(segment);
+        return mem.size();
     }
     bool validAlloc1() const {
         unsigned *p((unsigned*)_ptr);
diff --git a/vespamalloc/src/vespamalloc/malloc/overload.h b/vespamalloc/src/vespamalloc/malloc/overload.h
index 6650f107ca9..e209d1b6df5 100644
--- a/vespamalloc/src/vespamalloc/malloc/overload.h
+++ b/vespamalloc/src/vespamalloc/malloc/overload.h
@@ -1,8 +1,9 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #pragma once
 
+#include "common.h"
 #include <dlfcn.h>
-#include <errno.h>
+#include <cerrno>
 #include <new>
 #include <cstdlib>
 #include <malloc.h>
@@ -174,15 +175,22 @@ void * reallocarray(void * ptr, size_t nemb, size_t elemSize) __THROW
 }
 
 void* memalign(size_t align, size_t sz) __THROW __attribute__((visibility ("default")));
-void* memalign(size_t align, size_t sz) __THROW
+void* memalign(size_t align_in, size_t sz) __THROW
 {
-    void *ptr(nullptr);
+    size_t align = (align_in == 0) ? 1 : 1ul << vespamalloc::msbIdx(align_in*2 - 1);
     size_t align_1(align - 1);
-    if ((align & (align_1)) == 0) {
-        ptr = vespamalloc::_GmemP->malloc(vespamalloc::_GmemP->getMinSizeForAlignment(align, sz));
-        ptr = (void *) ((size_t(ptr) + align_1) & ~align_1);
-    }
-    return ptr;
+    void * ptr = vespamalloc::_GmemP->malloc(vespamalloc::_GmemP->getMinSizeForAlignment(align, sz));
+    return (void *) ((size_t(ptr) + align_1) & ~align_1);
+}
+
+void *aligned_alloc (size_t align, size_t sz) __THROW __attribute__((visibility ("default")));
+void *aligned_alloc (size_t align_in, size_t sz_in) __THROW
+{
+    size_t align = (align_in == 0) ? 1 : 1ul << vespamalloc::msbIdx(align_in*2 - 1);
+    size_t align_1(align - 1);
+    size_t sz = ((sz_in - 1) + align) & ~align_1;
+    void * ptr = vespamalloc::_GmemP->malloc(vespamalloc::_GmemP->getMinSizeForAlignment(align, sz));
+    return (void *) ((size_t(ptr) + align_1) & ~align_1);
 }
 
 int posix_memalign(void** ptr, size_t align, size_t sz) __THROW __nonnull((1)) __attribute__((visibility ("default")));