Hacer que std :: vector asigne memoria alineada

¿Es posible hacer que std::vector de estructuras personalizadas asignen memoria alineada para su posterior procesamiento con instrucciones SIMD? Si es posible hacerlo con Allocator , ¿alguien tiene ese asignador que podría compartir?

Editar: eliminé la herencia de std::allocator según lo sugerido por GManNickG e hice del parámetro de alineación una cosa de tiempo de comstackción.

Recientemente escribí este fragmento de código. No se ha probado tanto como me gustaría, así que continúa e informa los errores. 🙂

 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  class AlignedAllocator; template  class AlignedAllocator { public: typedef void* pointer; typedef const void* const_pointer; typedef void value_type; template  struct rebind { typedef AlignedAllocator other; }; }; template  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  struct rebind { typedef AlignedAllocator other; }; public: AlignedAllocator() noexcept {} template  AlignedAllocator(const AlignedAllocator&) 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::const_pointer = 0) { const size_type alignment = static_cast( Align ); void* ptr = detail::allocate_aligned_memory(alignment , n * sizeof(T)); if (ptr == nullptr) { throw std::bad_alloc(); } return reinterpret_cast(ptr); } void deallocate(pointer p, size_type) noexcept { return detail::deallocate_aligned_memory(p); } template  void construct(U* p, Args&&... args) { ::new(reinterpret_cast(p)) U(std::forward(args)...); } void destroy(pointer p) { p->~T(); } }; template  class AlignedAllocator { 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  struct rebind { typedef AlignedAllocator other; }; public: AlignedAllocator() noexcept {} template  AlignedAllocator(const AlignedAllocator&) 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::const_pointer = 0) { const size_type alignment = static_cast( Align ); void* ptr = detail::allocate_aligned_memory(alignment , n * sizeof(T)); if (ptr == nullptr) { throw std::bad_alloc(); } return reinterpret_cast(ptr); } void deallocate(pointer p, size_type) noexcept { return detail::deallocate_aligned_memory(p); } template  void construct(U* p, Args&&... args) { ::new(reinterpret_cast(p)) U(std::forward(args)...); } void destroy(pointer p) { p->~T(); } }; template  inline bool operator== (const AlignedAllocator&, const AlignedAllocator&) noexcept { return TAlign == UAlign; } template  inline bool operator!= (const AlignedAllocator&, const AlignedAllocator&) noexcept { return TAlign != UAlign; } 

La implementación para las llamadas de asignación reales es solo posix, pero puede ampliarlo fácilmente.

 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); } 

Necesita C ++ 11, por cierto.

En la próxima versión 1.56, la biblioteca de Boost incluirá Boost.Align. Entre otros ayudantes de alineación de memoria proporciona boost::alignment::aligned_allocator , que se puede usar como un reemplazo std::allocator para std::allocator y le permite especificar una alineación. Consulte la documentación en https://boostorg.github.io/align/

Sí, debería ser posible. Si hace esta pregunta en google, obtendrá un montón de código de muestra, a continuación se muestran algunos resultados prometedores:

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