让std :: vector分配对齐的内存

Question

是否有可能让std::vector的自定义结构分配对齐内存以便进一步处理SIMD指令？如果可以使用Allocator，有没有人碰巧拥有这样一个分配器，他可以分享？

Answer 1

编辑：我按照GManNickG的建议去除了std::allocator的继承，并将alignment参数设置为编译时间的东西。

我最近写了这段代码。它没有像我想要的那样测试，所以继续并报告错误。 :-)

enum class Alignment : size_t 
{ 
    Normal = sizeof(void*), 
    SSE = 16, 
    AVX = 32, 
}; 


namespace detail { 
    void* allocate_aligned_memory(size_t align, size_t size); 
    void deallocate_aligned_memory(void* ptr) noexcept; 
} 


template <typename T, Alignment Align = Alignment::AVX> 
class AlignedAllocator; 


template <Alignment Align> 
class AlignedAllocator<void, Align> 
{ 
public: 
    typedef void*    pointer; 
    typedef const void*  const_pointer; 
    typedef void    value_type; 

    template <class U> struct rebind { typedef AlignedAllocator<U, Align> other; }; 
}; 


template <typename T, Alignment Align> 
class AlignedAllocator 
{ 
public: 
    typedef T   value_type; 
    typedef T*  pointer; 
    typedef const T* const_pointer; 
    typedef T&  reference; 
    typedef const T& const_reference; 
    typedef size_t size_type; 
    typedef ptrdiff_t difference_type; 

    typedef std::true_type propagate_on_container_move_assignment; 

    template <class U> 
    struct rebind { typedef AlignedAllocator<U, Align> other; }; 

public: 
    AlignedAllocator() noexcept 
    {} 

    template <class U> 
    AlignedAllocator(const AlignedAllocator<U, Align>&) noexcept 
    {} 

    size_type 
    max_size() const noexcept 
    { return (size_type(~0) - size_type(Align))/sizeof(T); } 

    pointer 
    address(reference x) const noexcept 
    { return std::addressof(x); } 

    const_pointer 
    address(const_reference x) const noexcept 
    { return std::addressof(x); } 

    pointer 
    allocate(size_type n, typename AlignedAllocator<void, Align>::const_pointer = 0) 
    { 
     const size_type alignment = static_cast<size_type>(Align); 
     void* ptr = detail::allocate_aligned_memory(alignment , n * sizeof(T)); 
     if (ptr == nullptr) { 
      throw std::bad_alloc(); 
     } 

     return reinterpret_cast<pointer>(ptr); 
    } 

    void 
    deallocate(pointer p, size_type) noexcept 
    { return detail::deallocate_aligned_memory(p); } 

    template <class U, class ...Args> 
    void 
    construct(U* p, Args&&... args) 
    { ::new(reinterpret_cast<void*>(p)) U(std::forward<Args>(args)...); } 

    void 
    destroy(pointer p) 
    { p->~T(); } 
}; 


template <typename T, Alignment Align> 
class AlignedAllocator<const T, Align> 
{ 
public: 
    typedef T   value_type; 
    typedef const T* pointer; 
    typedef const T* const_pointer; 
    typedef const T& reference; 
    typedef const T& const_reference; 
    typedef size_t size_type; 
    typedef ptrdiff_t difference_type; 

    typedef std::true_type propagate_on_container_move_assignment; 

    template <class U> 
    struct rebind { typedef AlignedAllocator<U, Align> other; }; 

public: 
    AlignedAllocator() noexcept 
    {} 

    template <class U> 
    AlignedAllocator(const AlignedAllocator<U, Align>&) noexcept 
    {} 

    size_type 
    max_size() const noexcept 
    { return (size_type(~0) - size_type(Align))/sizeof(T); } 

    const_pointer 
    address(const_reference x) const noexcept 
    { return std::addressof(x); } 

    pointer 
    allocate(size_type n, typename AlignedAllocator<void, Align>::const_pointer = 0) 
    { 
     const size_type alignment = static_cast<size_type>(Align); 
     void* ptr = detail::allocate_aligned_memory(alignment , n * sizeof(T)); 
     if (ptr == nullptr) { 
      throw std::bad_alloc(); 
     } 

     return reinterpret_cast<pointer>(ptr); 
    } 

    void 
    deallocate(pointer p, size_type) noexcept 
    { return detail::deallocate_aligned_memory(p); } 

    template <class U, class ...Args> 
    void 
    construct(U* p, Args&&... args) 
    { ::new(reinterpret_cast<void*>(p)) U(std::forward<Args>(args)...); } 

    void 
    destroy(pointer p) 
    { p->~T(); } 
}; 

template <typename T, Alignment TAlign, typename U, Alignment UAlign> 
inline 
bool 
operator== (const AlignedAllocator<T,TAlign>&, const AlignedAllocator<U, UAlign>&) noexcept 
{ return TAlign == UAlign; } 

template <typename T, Alignment TAlign, typename U, Alignment UAlign> 
inline 
bool 
operator!= (const AlignedAllocator<T,TAlign>&, const AlignedAllocator<U, UAlign>&) noexcept 
{ return TAlign != UAlign; } 

实际分配呼叫的实施只有posix，但您可以轻松扩展。

void* 
detail::allocate_aligned_memory(size_t align, size_t size) 
{ 
    assert(align >= sizeof(void*)); 
    assert(nail::is_power_of_two(align)); 

    if (size == 0) { 
     return nullptr; 
    } 

    void* ptr = nullptr; 
    int rc = posix_memalign(&ptr, align, size); 

    if (rc != 0) { 
     return nullptr; 
    } 

    return ptr; 
} 


void 
detail::deallocate_aligned_memory(void *ptr) noexcept 
{ 
    return free(ptr); 
} 

需要C++ 11，顺便说一句。

Answer 2

是的，应该是可以的。如果你把谷歌这个问题，那么你将获得大量的示例代码，下面是一些令人鼓舞的结果：

https://bitbucket.org/marten/alignedallocator/wiki/Home

http://code.google.com/p/mastermind-strategy/source/browse/trunk/src/util/aligned_allocator.hpp?r=167

https://gist.github.com/1471329

Answer 3

在即将到来的版本1.56，Boost库将包括Boost.Align。在其他内存对齐帮助程序中，它提供boost::alignment::aligned_allocator，它可以用于std::allocator的直接替换，并允许您指定对齐方式。请参阅https://boostorg.github.io/align/