aligned_allocator.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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>

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>
    constexpr aligned_allocator(aligned_allocator<other_value_type, alignment> const &) noexcept
    {}

    [[nodiscard]]
    pointer allocate(size_type n)
    {
        constexpr size_type max_size = std::numeric_limits<size_type>::max() / sizeof(value_type);
        if (n > max_size)
            throw std::bad_alloc();

        // NOTE: On macOS glibc does not implement aligned_alloc, so we need to fallback to posix_memalign instead.
#if defined(__APPLE__) && (!defined(_GLIBCXX_HAVE_ALIGNED_ALLOC) && !defined(_ISOC11_SOURCE))
        void * p{};
        if (int res = posix_memalign(&p, alignment, n * sizeof(value_type)); res == 0 && p != nullptr)
            return static_cast<pointer>(p);
#else
        // NOTE:
        // Allocate size bytes of uninitialized storage whose alignment is
        // specified by alignment. The size parameter must be an integral
        // multiple of alignment.
        //
        // Passing a size which is not an integral multiple of alignment or an
        // alignment which is not valid or not supported by the implementation
        // causes the function to fail and return a null pointer (C11, as
        // published, specified undefined behavior in this case, this was
        // corrected by DR 460).
        // http://en.cppreference.com/w/cpp/memory/c/aligned_alloc
        if (auto p = static_cast<pointer>(std::aligned_alloc(alignment, n * sizeof(value_type))))
            return p;
#endif

        throw std::bad_alloc();
    }

    void deallocate(pointer p, size_type) noexcept
    {
        std::free(p);
    }

    template<typename new_value_type>
    struct rebind
    {
        using other = aligned_allocator<new_value_type, 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