Comment est un vecteur de données alignées?

Vous devez utiliser un allocateur personnalisé avec std:: récipients, tels que des vector. Ne me souviens pas qui a écrit le suivant, mais je l'ai utilisé pendant un certain temps et il semble fonctionner (vous pourriez avoir à changer _aligned_malloc à _mm_malloc, selon compilateur/plate-forme):

#ifndef ALIGNMENT_ALLOCATOR_H
#define ALIGNMENT_ALLOCATOR_H
#include <stdlib.h>
#include <malloc.h>
template <typename T, std::size_t N = 16>
class AlignmentAllocator {
public:
typedef T value_type;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef T * pointer;
typedef const T * const_pointer;
typedef T & reference;
typedef const T & const_reference;
public:
inline AlignmentAllocator () throw () { }
template <typename T2>
inline AlignmentAllocator (const AlignmentAllocator<T2, N> &) throw () { }
inline ~AlignmentAllocator () throw () { }
inline pointer adress (reference r) {
return &r;
}
inline const_pointer adress (const_reference r) const {
return &r;
}
inline pointer allocate (size_type n) {
return (pointer)_aligned_malloc(n*sizeof(value_type), N);
}
inline void deallocate (pointer p, size_type) {
_aligned_free (p);
}
inline void construct (pointer p, const value_type & wert) {
new (p) value_type (wert);
}
inline void destroy (pointer p) {
p->~value_type ();
}
inline size_type max_size () const throw () {
return size_type (-1) / sizeof (value_type);
}
template <typename T2>
struct rebind {
typedef AlignmentAllocator<T2, N> other;
};
bool operator!=(const AlignmentAllocator<T,N>& other) const  {
return !(*this == other);
}
//Returns true if and only if storage allocated from *this
//can be deallocated from other, and vice versa.
//Always returns true for stateless allocators.
bool operator==(const AlignmentAllocator<T,N>& other) const {
return true;
}
};
#endif

L'utiliser comme ceci (modifier le 16 à l'autre de l'alignement, si nécessaire):

std::vector<T, AlignmentAllocator<T, 16> > bla;

Ceci, cependant, ne permet de s'assurer que le bloc de mémoire std::vector utilise est de 16 octets alignés. Si sizeof(T) n'est pas un multiple de 16, certaines de vos éléments ne seront pas alignés. En fonction de votre type de données, cela pourrait être un non-problème. Si T est int (4 octets), charge uniquement les éléments dont l'index est un multiple de 4. Si c'est double (8 octets), seuls les multiples de 2, etc.

La vraie question est de savoir si vous utilisez des classes comme T, dans ce cas, vous devrez spécifier votre alignement exigences de la classe elle-même (encore une fois, selon le compilateur, ce pourrait être différent; l'exemple est pour GCC):

class __attribute__ ((aligned (16))) Foo {
__attribute__ ((aligned (16))) double u[2];
};

Nous avons presque terminé! Si vous utilisez Visual C++ (au moins, la version de 2010), vous ne serez pas en mesure d'utiliser un std::vector avec des classes dont le tracé que vous avez spécifié, en raison de std::vector::resize.

Lors de la compilation, si vous obtenez l'erreur suivante:

C:\Program Files\Microsoft Visual Studio 10.0\VC\include\vector(870):
error C2719: '_Val': formal parameter with __declspec(align('16')) won't be aligned

Vous devrez pirater votre stl::vector header fichier:

1. Recherchez le vector fichier d'en-tête [C:\Program Files\Microsoft Visual Studio 10.0\VC\include\vecteur]
2. Recherchez le void resize( _Ty _Val ) méthode [en ligne de 870 sur VC2010]
3. Changer de void resize( const _Ty& _Val ).

OriginalL'auteur user1071136

Écrire votre propre allocateur. allocate et deallocate sont les plus importantes. Voici un exemple:

pointer allocate( size_type size, const void * pBuff = 0 )
{
char * p;
int difference;
if( size > ( INT_MAX - 16 ) )
return NULL;
p = (char*)malloc( size + 16 );
if( !p )
return NULL;
difference = ( (-(int)p - 1 ) & 15 ) + 1;
p += difference;
p[ -1 ] = (char)difference;
return (T*)p;
}
void deallocate( pointer p, size_type num )
{
char * pBuffer = (char*)p;
free( (void*)(((char*)p) - pBuffer[ -1 ] ) );
}

OriginalL'auteur moose

Utilisation declspec(align(x,y)) comme expliqué dans la vectorisation tutoriel pour Intel, http://d3f8ykwhia686p.cloudfront.net/1live/intel/CompilerAutovectorizationGuide.pdf

OriginalL'auteur octoback

La Norme mandats que new et new[] renvoyer des données alignées pour tout type de données, qui devrait inclure l'ESS. Si oui ou non MSVC suit effectivement que la règle est une autre question.

OriginalL'auteur Puppy