C ++ alineación de la estructura de datos STL, vectorización algoritmo

Question

¿Hay una manera de hacer cumplir la alineación de contenedores STL a byte específico, usando atributo ((alineados)), tal vez? los compiladores de destino no son Microsoft Visual C ++.

¿Qué bibliotecas, en su caso, proporcionan plantillas especializadas de algoritmos STL que tienen vectorización explícita específica, por ejemplo, SSE. Mis compiladores de interés son g ++, Intel e IBM XL.

Answer 1

Con contenedores STL, puede proporcionar su propio asignador a través de un parámetro de plantilla opcional. No recomendaría escribir un asignador todo desde cero, pero se podría escribir una que es sólo una envoltura alrededor de new y delete pero asegura que la memoria devuelta cumple con su requisito de alineación. (Por ejemplo, si necesita bytes n con la alineación de 16 bytes, se utiliza para asignar bytes new n + 15 y devolver un puntero a la primera dirección de 16 bytes alineados en ese bloque.)

Pero podría ser suficiente con añadir el atributo de alineación para el tipo de elemento. Eso es fuera del alcance de la norma, por lo que tendría que consultar la documentación del compilador y probarlo.

Answer 2

Es necesario un asignador de costumbre pasado. Se puede construir una sobre la std::allocator con bastante facilidad:

template <typename T, size_t TALIGN=16, size_t TBLOCK=8>
class aligned_allocator : public std::allocator<T>
{
public:
     aligned_allocator() {}
     aligned_allocator& operator=(const aligned_allocator &rhs){
         std::allocator<T>::operator=(rhs);
         return *this;
     }

     pointer allocate(size_type n, const void *hint){
         pointer p = NULL;
         size_t count = sizeof(T) * n;
         size_t count_left = count % TBLOCK;
         if( count_left != 0 )
         {
             count += TBLOCK - count_left;
         }
         if ( !hint )
         {
             p = reinterpret_cast<pointer>(aligned_malloc(count,TALIGN));
         }else{
             p = reinterpret_cast<pointer>(aligned_realloc((void*)hint,count,TALIGN));
         }
         return p;
     }

     void deallocate(pointer p, size_type n){
         aligned_free(p);
     }

     void construct(pointer p, const T &val){
         new(p) T(val);
     }

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

Lo único que falta aquí es la aligned_malloc, aligned_realloc y aligned_free. Tiene que poner en práctica su propia cuenta (no debería ser tan difícil), o encontrar versiones de que están en Internet (he visto al menos uno de cada OGRE motor).

Answer 3

si ya recibió algunas buenas respuestas, pero parece que vale la pena añadir que el C ++ 0x incluye un std::align(), lo que debería hacer cosas como esta aplicación un poco más fácil.

Answer 4

Se necesita un asignador personalizado que devuelve el almacenamiento Alineados. Eso debería resolver su problema.

Answer 5

En lugar de escribir su propio asignador, como sugirió antes , puede utilizar boost::alignment::aligned_allocator .