288 lines
8.3 KiB
C++
288 lines
8.3 KiB
C++
/*
|
|
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
|