boost/align/aligned_allocator.hpp
/* Copyright (c) 2014 Glen Joseph Fernandes glenfe at live dot com Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt) */ #ifndef BOOST_ALIGN_ALIGNED_ALLOCATOR_HPP #define BOOST_ALIGN_ALIGNED_ALLOCATOR_HPP /** Class template aligned_allocator. @file @author Glen Fernandes */ #include <boost/config.hpp> #include <boost/static_assert.hpp> #include <boost/throw_exception.hpp> #include <boost/align/aligned_alloc.hpp> #include <boost/align/aligned_allocator_forward.hpp> #include <boost/align/alignment_of.hpp> #include <boost/align/detail/addressof.hpp> #include <boost/align/detail/is_alignment_const.hpp> #include <boost/align/detail/max_align.hpp> #include <boost/align/detail/max_count_of.hpp> #include <new> #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) #include <utility> #endif /** Boost namespace. */ namespace boost { /** Alignment namespace. */ namespace alignment { /** Class template aligned_allocator. @tparam Alignment Is the minimum alignment to specify for allocations, if it is larger than the alignment of the value type. It shall be a power of two. @remark **Note:** Except for the destructor, member functions of the aligned allocator shall not introduce data races as a result of concurrent calls to those member functions from different threads. Calls to these functions that allocate or deallocate a particular unit of storage shall occur in a single total order, and each such deallocation call shall happen before the next allocation (if any) in this order. @note Specifying minimum alignment is generally only suitable for containers such as vector and undesirable with other, node-based, containers. For node-based containers, such as list, the node object would have the minimum alignment specified instead of the value type object. */ template<class T, std::size_t Alignment> class aligned_allocator { /** @cond */ BOOST_STATIC_ASSERT(detail:: is_alignment_const<Alignment>::value); /** @endcond */ public: typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef void* void_pointer; typedef const void* const_void_pointer; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef T& reference; typedef const T& const_reference; private: enum { TypeAlign = alignment_of<value_type>::value, MaxAlign = detail:: max_align<Alignment, TypeAlign>::value }; public: /** Rebind allocator. */ template<class U> struct rebind { typedef aligned_allocator<U, Alignment> other; }; #if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) aligned_allocator() BOOST_NOEXCEPT = default; #else aligned_allocator() BOOST_NOEXCEPT { } #endif template<class U> aligned_allocator(const aligned_allocator<U, Alignment>&) BOOST_NOEXCEPT { } /** @return The actual address of the object referenced by `value`, even in the presence of an overloaded operator&. */ pointer address(reference value) const BOOST_NOEXCEPT { return detail::addressof(value); } /** @return The actual address of the object referenced by `value`, even in the presence of an overloaded operator&. */ const_pointer address(const_reference value) const BOOST_NOEXCEPT { return detail::addressof(value); } /** @return A pointer to the initial element of an array of storage of size `n * sizeof(T)`, aligned on the maximum of the minimum alignment specified and the alignment of objects of type `T`. @remark **Throw:** Throws `std::bad_alloc` if the storage cannot be obtained. @remark **Note:** The storage is obtained by calling `aligned_alloc(std::size_t, std::size_t)`. */ pointer allocate(size_type size, const_void_pointer = 0) { void* p = aligned_alloc(MaxAlign, sizeof(T) * size); if (!p && size > 0) { boost::throw_exception(std::bad_alloc()); } return static_cast<T*>(p); } /** Deallocates the storage referenced by `ptr`. @param ptr Shall be a pointer value obtained from `allocate()`. @remark **Note:** Uses `alignment::aligned_free(void*)`. */ void deallocate(pointer ptr, size_type) { alignment::aligned_free(ptr); } /** @return The largest value `N` for which the call `allocate(N)` might succeed. */ BOOST_CONSTEXPR size_type max_size() const BOOST_NOEXCEPT { return detail::max_count_of<T>::value; } #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) /** Calls global `new((void*)ptr) U(std::forward<Args>(args)...)`. */ template<class U, class... Args> void construct(U* ptr, Args&&... args) { void* p = ptr; ::new(p) U(std::forward<Args>(args)...); } #else /** Calls global `new((void*)ptr) U(std::forward<V>(value))`. */ template<class U, class V> void construct(U* ptr, V&& value) { void* p = ptr; ::new(p) U(std::forward<V>(value)); } #endif #else /** Calls global `new((void*)ptr) U(value)`. */ template<class U, class V> void construct(U* ptr, const V& value) { void* p = ptr; ::new(p) U(value); } #endif /** Calls global `new((void*)ptr) U()`. */ template<class U> void construct(U* ptr) { void* p = ptr; ::new(p) U(); } /** Calls `ptr->~U()`. */ template<class U> void destroy(U* ptr) { (void)ptr; ptr->~U(); } }; /** Class template aligned_allocator specialization. */ template<std::size_t Alignment> class aligned_allocator<void, Alignment> { /** @cond */ BOOST_STATIC_ASSERT(detail:: is_alignment_const<Alignment>::value); /** @endcond */ public: typedef void value_type; typedef void* pointer; typedef const void* const_pointer; /** Rebind allocator. */ template<class U> struct rebind { typedef aligned_allocator<U, Alignment> other; }; }; /** @return `true`. */ template<class T1, class T2, std::size_t Alignment> inline bool operator==(const aligned_allocator<T1, Alignment>&, const aligned_allocator<T2, Alignment>&) BOOST_NOEXCEPT { return true; } /** @return `false`. */ template<class T1, class T2, std::size_t Alignment> inline bool operator!=(const aligned_allocator<T1, Alignment>&, const aligned_allocator<T2, Alignment>&) BOOST_NOEXCEPT { return false; } } } #endif