aligned_allocator.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2022, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2022, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <limits>
#include <memory>
#include <type_traits>
 
#include <seqan3/core/platform.hpp>
 
// __cpp_aligned_new is a C++17 feature that we use in this allocator and we require it.
#if __cpp_aligned_new < 201606
#    pragma GCC warning "Non-C++17 compliant compiler! Please open an issue with your compiler and platform!"
#endif // __cpp_aligned_new < 201606
 
namespace seqan3
{
 
template <typename value_t, size_t alignment_v = __STDCPP_DEFAULT_NEW_ALIGNMENT__>
class aligned_allocator
{
public:
    static constexpr size_t alignment = alignment_v;
 
    using value_type = value_t;
    using pointer = value_type *;
    using difference_type = typename std::pointer_traits<pointer>::difference_type;
    using size_type = std::make_unsigned_t<difference_type>;
 
    using is_always_equal = std::true_type;
 
    aligned_allocator() = default;                                      
    aligned_allocator(aligned_allocator const &) = default;             
    aligned_allocator(aligned_allocator &&) = default;                  
    aligned_allocator & operator=(aligned_allocator const &) = default; 
    aligned_allocator & operator=(aligned_allocator &&) = default;      
    ~aligned_allocator() = default;                                     
 
    template <class other_value_type, size_t other_alignment>
    constexpr aligned_allocator(aligned_allocator<other_value_type, other_alignment> const &) noexcept
    {}
 
    [[nodiscard]] pointer allocate(size_type const n) const
    {
        constexpr size_type max_size = std::numeric_limits<size_type>::max() / sizeof(value_type);
        if (n > max_size)
            throw std::bad_alloc{};
 
        size_t bytes_to_allocate = n * sizeof(value_type);
        if constexpr (alignment <= __STDCPP_DEFAULT_NEW_ALIGNMENT__)
            return static_cast<pointer>(::operator new(bytes_to_allocate));
        else // Use alignment aware allocator function.
            return static_cast<pointer>(::operator new(bytes_to_allocate, static_cast<std::align_val_t>(alignment)));
    }
 
    void deallocate(pointer const p, size_type const n) const noexcept
    {
        size_t bytes_to_deallocate = n * sizeof(value_type);
 
        // Clang doesn't have __cpp_sized_deallocation defined by default even though this is a C++14! feature
        // > In Clang 3.7 and later, sized deallocation is only enabled if the user passes the `-fsized-deallocation`
        // > flag.
        // see also https://clang.llvm.org/cxx_status.html#n3778
#if __cpp_sized_deallocation >= 201309
        // gcc
        if constexpr (alignment <= __STDCPP_DEFAULT_NEW_ALIGNMENT__)
            ::operator delete(p, bytes_to_deallocate);
        else // Use alignment aware deallocator function.
            ::operator delete(p, bytes_to_deallocate, static_cast<std::align_val_t>(alignment));
#else  /*__cpp_sized_deallocation >= 201309*/
        // e.g. clang++
        if constexpr (alignment <= __STDCPP_DEFAULT_NEW_ALIGNMENT__)
            ::operator delete(p);
        else // Use alignment aware deallocator function.
            ::operator delete(p, static_cast<std::align_val_t>(alignment));
#endif // __cpp_sized_deallocation >= 201309
    }
 
    template <typename new_value_type>
    struct rebind
    {
        static constexpr size_t other_alignment = std::max(alignof(new_value_type), alignment);
        using other = aligned_allocator<new_value_type, other_alignment>;
    };
 
    template <class value_type2, size_t alignment2>
    constexpr bool operator==(aligned_allocator<value_type2, alignment2> const &) noexcept
    {
        return alignment == alignment2;
    }
 
    template <class value_type2, size_t alignment2>
    constexpr bool operator!=(aligned_allocator<value_type2, alignment2> const &) noexcept
    {
        return alignment != alignment2;
    }
};
 
} // namespace seqan3