aligned_allocator.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstddef>
#include <limits>
#include <new>
#include <type_traits>
 
namespace orrery::core {

inline constexpr std::size_t kCacheLineBytes = 64;

template<typename T> class AlignedAllocator {
public:
    using value_type = T;

    using propagate_on_container_move_assignment = std::true_type;

    using is_always_equal = std::true_type;
 
    static constexpr std::size_t kAlignment = kCacheLineBytes;
 
    static_assert(kAlignment >= alignof(T),
                  "The requested alignment is weaker than the type's own requirement");
 
    AlignedAllocator() noexcept = default;

    template<typename U>
    constexpr AlignedAllocator(const AlignedAllocator<U>& /*other*/) noexcept {}

    [[nodiscard]] static T* allocate(std::size_t count) {
        if (count > max_size()) {
            // The multiplication below would wrap, and a wrapped byte count
            // allocates a small block that is then handed back as though it
            // were large. That is a silent buffer overflow rather than a failed
            // allocation, so the overflow is turned into the failure it is.
            throw std::bad_array_new_length{};
        }
 
        // The aligned form of operator new rather than a hand-rolled
        // over-allocate-and-offset scheme: it is the standard's own answer to
        // this question, it is available on all three supported compilers, and
        // it needs no bookkeeping to recover the original pointer.
        return static_cast<T*>(::operator new(count * sizeof(T), std::align_val_t{kAlignment}));
    }
 
    static void deallocate(T* pointer, std::size_t /*count*/) noexcept {
        // The aligned form, matching the allocation above. An ordinary operator
        // delete would be undefined behaviour here, since the storage did not
        // come from an ordinary operator new.
        //
        // The sized overload is deliberately not used, although the count is to
        // hand. It saves the allocator a size lookup, but it is only declared
        // by compilers built with sized deallocation enabled, which is not the
        // default in every release this project supports. A hint worth that
        // little is not worth a portability condition.
        ::operator delete(pointer, std::align_val_t{kAlignment});
    }

    [[nodiscard]] static constexpr std::size_t max_size() noexcept {
        return std::numeric_limits<std::size_t>::max() / sizeof(T);
    }
};

template<typename T, typename U>
[[nodiscard]] constexpr bool operator==(const AlignedAllocator<T>& /*lhs*/,
                                        const AlignedAllocator<U>& /*rhs*/) noexcept {
    return true;
}
 
} // namespace orrery::core