C de l'alignement de la structure de données de STL, l'algorithme de vectorisation

Question

Est-il possible de faire respecter l'alignement du conteneur STL à octet spécifique, en utilisant attribut ((alignés)) peut-être? les compilateurs cibles ne sont pas Microsoft Visual C ++.

Qu'est-ce que les bibliothèques, le cas échéant, fournir des modèles spécialisés d'algorithmes de STL qui ont vectorisation explicitement spécifiques, par exemple SSE. Mes compilateurs d'intérêt sont g ++, Intel et IBM XL.

Answer 1

Avec des conteneurs STL, vous pouvez fournir votre propre allocateur via un paramètre de modèle en option. Je ne recommanderais pas à écrire un allocateur à partir de zéro, mais vous pouvez écrire qui est juste une enveloppe autour new et delete mais assure que la mémoire de retour répond à vos besoins d'alignement. (Par exemple, si vous avez besoin d'octets n avec un alignement de 16 octets, on utilise new pour allouer des octets de n + 15 et renvoyer un pointeur vers la première adresse alignée de 16 octets dans ce bloc.)

Mais il est peut-être juste assez pour ajouter l'attribut d'alignement du type d'élément. C'est en dehors du champ d'application de la norme, de sorte que vous auriez à vérifier la documentation de votre compilateur et essayer.

Answer 2

Vous avez besoin d'un allocateur personnalisé passé. Vous pouvez construire un sur l'std::allocator assez facilement:

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

La seule chose qui manque ici est le aligned_malloc, aligned_realloc et aligned_free. Vous avez besoin soit de les appliquer vous-même (ne devrait pas être difficile), ou trouver des versions de ceux sur Internet (je l'ai vu au moins un dans OGRE moteur).

Answer 3

Vous avez déjà obtenu quelques bonnes réponses, mais il semble que cela vaut la peine d'ajouter que C ++ 0x comprend un std::align(), qui devrait faire des choses comme la mise en œuvre ce un peu plus facile.

Answer 4

Vous avez besoin d'un allocateur personnalisé qui retourne le stockage Alignés. Cela devrait résoudre votre problème.

Answer 5

Au lieu d'écrire votre propre allocateur, comme suggéré avant , vous pouvez utiliser boost::alignment::aligned_allocator .