cross-platform stdlib-only aligned allocator in C++14

Question

I'm writing a program which uses OpenCL, and the OpenCL types are mostly over-aligned. Sometimes when using stl containers with these types, I'd get segfaults, so I tried to write my own aligned allocator which I could use instead of the standard allocator.

I've done a bit of testing in valgrind etc. and so far everything looks OK, but I don't know whether I might have written something which will bite me in the future. I'm especially worried about some reinterpret_casts in my allocate and deallocate methods.

Any feedback appreciated.

Here's the code:

namespace mem {

template <typename T, std::size_t N = alignof(T)>
class aligned_allocator {
    //  helper type with the alignment we want
    using aligned_type = std::aligned_storage_t<sizeof(T), N>;

public:
    //  type to allocate
    using value_type = T;

    //  ensure basic special class methods are enabled
    aligned_allocator()                                         = default;
    aligned_allocator(const aligned_allocator&)                 = default;
    aligned_allocator& operator=(const aligned_allocator&)      = default;
    aligned_allocator(aligned_allocator&&) noexcept             = default;
    aligned_allocator& operator=(aligned_allocator&&) noexcept  = default;

    //  allow construction from an allocator for another type
    //  (with the same alignment)
    template <typename U>
    aligned_allocator(const aligned_allocator<U>&) {}

    //  implementations may derive from the allocator polymorphically
    virtual ~aligned_allocator() noexcept = default;

    //  rebinding the allocator for another type should respect the alignment
    //  of that other type
    template <typename U>
    struct rebind {
        using other = aligned_allocator<U>;
    };

    //  allocate a type that we know will have the correct alignment
    //  then reinterpret the pointer
    T* allocate(std::size_t n) {
        return reinterpret_cast<T*>(new aligned_type[n]);
    }

    //  deallocate previously allocated memory
    void deallocate(T* p, std::size_t) {  //  don't care about size here
        delete[] reinterpret_cast<aligned_type*>(p);
    }
};

template <typename T, typename U, std::size_t N>
constexpr bool operator==(const aligned_allocator<T, N>&,
                          const aligned_allocator<U, N>&) {
    return true;
}

template <typename T, typename U, std::size_t N>
constexpr bool operator!=(const aligned_allocator<T, N>&,
                          const aligned_allocator<U, N>&) {
    return false;
}

}  //  namespace mem

Welcome to Code Review, nice question. Have you checked it for performance? — pacmaninbw
– pacmaninbw ♦, Commented Jul 20, 2016 at 18:04

Toby Speight · Accepted Answer · 2024-09-23 17:00:26Z

This code doesn't match the comment:

//  allow construction from an allocator for another type
//  (with the same alignment)
template <typename U>
aligned_allocator(const aligned_allocator<U>&) {}

I'm pretty sure we need to write the argument as const aligned_allocator<U,N>& if the alignment must be the same. But maybe it's the comment that should be deleted instead?

If we're concerned about the validity of the cast, it might be sufficient to static_assert(sizeof (T) == sizeof (aligned_type)).

A possible danger case that we should eliminate is when an alignment larger than the object size is specified, as demonstrated by this failing assertion:

#include <type_traits>

using char4 = std::aligned_storage_t<1, 4>;

char4 s[10];

static_assert(sizeof s == 10);

This would break pointer arithmetic (such as indexing) on the returned T*. We could prohibit such uses via static_assert or by constraints.

It's not stated in the comments here, but std::aligned_storage_t imposes a requirement on N that it must be the same as an actual type's alignment - anything else is UB. Perhaps worth mentioning in usage guidance?

One possible enhancement to consider is to allow specifying an underlying allocator template to use rather than naked new[] and delete[], which may be useful for GPU objects. This would be instantiated with aligned_type as template argument. A sensible default for this would be std::allocator<>.

If we do have another allocator as member, we must remember to specialise std::allocator_traits to forward the underlying allocator's is_always_equal trait, as the default (std::is_empty_t<aligned_allocator>) is no longer true.

Stack Exchange Network

cross-platform stdlib-only aligned allocator in C++14

1 Answer 1

You must log in to answer this question.

Hot Network Questions

cross-platform stdlib-only aligned allocator in C++14

1 Answer 1

You must log in to answer this question.

Related

Hot Network Questions