Problème d'alignement sur 128 bits

Version imprimable

05/07/2007, 10h24
progfou

Problème d'alignement sur 128 bits

Bonjour à tous !
Afin d'exploiter les instructions de type SSE2, j'ai besoin d'aligner mes données sur 128 bits.
Pour cela, j'utilise le mot clé __declspec(align(16)) comme ceci :

Code:

__declspec(align(16)) short mon_tab[720];

Ce tableau est déclaré en private dans une classe.

Lorsque je regarde l'adresse, il m'a aligné ce tableau sur 8 octets !
J'ai donc l'impression que ça ne sert à rien.
Y a-t-il quelque chose qui m'échappe ?

Merci d'avance !

PS: Je suis sous Visual, mais j'ai le même problème avec le même code sous gcc...
05/07/2007, 10h43
Charlemagne
J'ai jamais vérifié mais j'ai jamais remarqué de problème. Depuis le temps que je l'utilise avec ICL (j'utiilse que rarement VC) j'aurais probablement vu des problèmes.

Par contre je ne sais pas ce que GCC va faire de ce code, peut-être qu'il l'ignore parce que normalement pour GCC c'est "__attribute__((__aligned__(16)))"

Petit conseil, j'utilise une définition pour rendre le code plus facilement portable.
Code:

1 2 3 4 5 #if defined(__ICL) || defined(_MSC_VER) #define __aligned __declspec(align(16)) #elif defined(__GNUC__) #define __aligned __attribute__((__aligned__(16))) #endif
05/07/2007, 10h49
progfou

Effectivement, moi aussi j'utilise une définition :).
Donc, je ne comprends pas pourquoi il n'aligne pas sur 16...
Il peut pourtant !
05/07/2007, 10h52
Charlemagne

Attends, je vais essayer de vérifier...
05/07/2007, 11h16
progfou

En fait j'ai trouvé pourquoi...
A l'appel via l'accesseur, l'adresse retournée n'est pas l'adresse de base du tableau (qui est bien alignée sur 16 octets !) mais une adresse à 56 octets de plus.
Du coup, ce n'est plus aligné sur 16, forcément !
Merci quand même, ça me rassure quand à l'utilité du mot clé ;).
05/07/2007, 14h29
loufoque

GCC, par exemple, n'honore pas les alignements sur la pile supérieurs à l'alignement de la pile elle-même, qui se trouve être 8 octets sous Linux.
Même chose pour malloc/new.

Edit: s/Windows/Linux/
05/07/2007, 15h10
progfou

OK, en mode debug, il m'aligne comme je lui demande (c'est à dire sur 8), en release, il ne le fait plus...
Plus précisément, si le tableau est aligné en mémoire, il doit l'être, pour mon cas, sur une adresse de type 0x???????8.
Or, l'alignement forcé va aligner sur 0 ou 8...
Comment forcer le 8 ?
Si l'on peut ?
06/07/2007, 11h48
Médinoc

Comprend pas tes derniers posts.
Pourquoi es-tu passé de 16 à 8 ?
Et que veux-tu voir aligné, finalement ?
06/07/2007, 14h35
progfou

J'ai un tableau de int. Ce tableau est alloué dynamiquement (via new[]), et l'adresse de base de ce tableau est alignée sur une adresse qui, aujourd'hui, se termine par 8 (aligné sur 8 octets donc). Afin d'utiliser les instructions rapides de transfert 128 bits (SSE2) j'ai absolument besoin que l'adresse de base soit à une adresse se terminant par 0 (aligné sur 16 octets).
Comment en être certain ?

Merci d'avance !
06/07/2007, 14h39
Jean-Marc.Bourguet

Citation:

Envoyé par progfou

J'ai un tableau de int. Ce tableau est alloué dynamiquement (via new[]), et l'adresse de base de ce tableau est alignée sur une adresse qui, aujourd'hui, se termine par 8 (aligné sur 8 octets donc). Afin d'utiliser les instructions rapides de transfert 128 bits (SSE2) j'ai absolument besoin que l'adresse de base soit à une adresse se terminant par 0 (aligné sur 16 octets).
Comment en être certain ?

Tu alloues 15 octets de plus que necessaire et tu utilises la bonne place dans la zone alouee.
06/07/2007, 14h40
Médinoc

Citation:

une adresse qui, aujourd'hui, se termine par 8 (aligné sur 8 octets donc).

sur huit octets maximum. Cela pourrait aussi bien être quatre (même si je crois savoir que c'est huit).

Si aucune fonction Microsoft ne te permet de t'assurer de l'alignement sur 16 octets de l'allocation, tu peux choisir de le faire toi-même en allouant 15 (ou plus) octets supplémentaires et faire toi-même l'ajustement du pointeur retourné...

Edit: Argh, grillé...
06/07/2007, 14h42
progfou

Pour le moment Microsoft, mais il faudrait que ce soit portable, donc il me faut un truc simple (je ne dois pas avoir à modifier des centaines de lignes) et efficace.

J'ai bien pensé à faire un new après un décalage, etc. mais je ne vois pas trop comment m'en sortir.
06/07/2007, 15h08
Médinoc

Tu peux peut-être modifier ton operator new pour le forcer à aligner sur 16 octets...
06/07/2007, 15h13
progfou
En fait, il me suffit de faire quelque chose comme cela :
Code:

1 2 3 int *pTmp = new[Size + 15]; int ipTmp = reinterpret_cast<int>pTmp; int *pBufferAligned = pTmp + (ipTmp&0x0F);
Du coup, pBufferAligned sera forcément aligné, non ?

Ca signifie qu'il faut bien sûr faire un delete[] sur pTmp...
06/07/2007, 15h18
Jean-Marc.Bourguet

Presque. L'arithmetique sur les pointeurs ne fonctionne pas en byte mais d'apres le type pointe.
06/07/2007, 15h21
progfou

Euh, c'est à dire :).

C'est quoi ces conseils?! Pas la peine d'allouer 15 octets en plus. (et d'avoir pleins de problèmes pour se rappeler de l'adresse initiale pour la désallocation)

Y'a des fonctions qui font ça pour chaque compilo.
J'en ai fait un allocateur pour mes besoins persos,pour rendre tout automatique.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#if (defined(__ICL) || defined(_MSC_VER) || defined(__ICC))
  #include <fvec.h>
  inline void *aligned_malloc (size_t size, size_t align=16)  {  return _mm_malloc(size,align);  }
  inline void  aligned_free   (void *p)                       {  return _mm_free(p); }
#elif defined (__CYGWIN__)
  #include <xmmintrin.h>
  inline void *aligned_malloc (size_t size, size_t align=16)  {  return _mm_malloc(size,align);  }
  inline void  aligned_free   (void *p)                       {  return _mm_free(p); }
#elif defined(__MINGW32__)
  #include <malloc.h>
  inline void *aligned_malloc (size_t size, size_t align=16)  {  return __mingw_aligned_malloc(size,align);  }
  inline void  aligned_free   (void *p)                       {  return __mingw_aligned_free(p);             }
#elif defined(__FreeBSD__)
  #include <stdlib.h>
  inline void* aligned_malloc (size_t size, size_t align=16) {  return malloc(size); }
  inline void  aligned_free   (void *p)                      {  return free(p); }
#else 
  #include <malloc.h>
  inline void* aligned_malloc (size_t size, size_t align=16) {  return memalign(align,size); }
  inline void  aligned_free   (void *p)                      {  return free(p); }
#endif
 
 
template<class T, int N=16> class alignment_allocator
{
  public:
    typedef T value_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
 
    typedef T* pointer;
    typedef const T* const_pointer;
 
    typedef T& reference;
    typedef const T& const_reference;
 
  public:
    inline alignment_allocator() throw() {}
    template <class T2> inline alignment_allocator(const alignment_allocator<T2,N>&) throw() {}
 
    inline ~alignment_allocator() throw() {}
 
    inline pointer       address(reference       r)       { return &r; }
    inline const_pointer address(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& val)  { new (p) value_type(val); }
    inline void destroy   (pointer p                      )  { p->~value_type();         }
 
    inline size_type max_size() const throw() { return size_type(-1)/sizeof(value_type); }
 
    template<class T2> struct rebind { typedef alignment_allocator<T2,N> other; };
};

06/07/2007, 15h29
progfou

Autant pour la définition des fonctions, je comprends bien, autant pour le template, je ne vois pas comment tu t'en sert.
Un cas d'école, pour aider à la compréhension ?
06/07/2007, 15h33
Charlemagne

Tout bon allocateur doit prendre un paramètre template. (Un allocateur c'est le dernier paramètre template des containers de la STL...)
J'ai juste rajouté un paramètre pour définir l'alignement.
06/07/2007, 15h39
progfou

Je ne maîtrise pas assez le concept pour comprendre ta réponse :aie: . J'ai pourtant relu plusieurs fois... :koi:
06/07/2007, 15h45
Charlemagne

Faut lire un bouquin sur la STL

un exemple:

Code:

std::vector<int,allocator<int> > X(1000);
06/07/2007, 15h53
progfou

J'utilise new[], pas les vector...
Et oui, il faut que je songe à lire ce genre de bouquin, mais le temps me manque...
06/07/2007, 15h59
Laurent Gomila

Dans ce cas tu peux créer une surcharge de new qui prend en paramètre supplémentaire l'alignement, et qui appelle les fonctions données par Charlemagne.
06/07/2007, 16h04
progfou

OK, ça fonctionne bien.
Merci beaucoup !
06/07/2007, 16h15
Jean-Marc.Bourguet

Citation:

Envoyé par Laurent Gomila

Dans ce cas tu peux créer une surcharge de new qui prend en paramètre supplémentaire l'alignement, et qui appelle les fonctions données par Charlemagne.

J'ai du mal avoir comment utiliser une surcharge de new[] qui va garantir l'alignement. Generalement new[] alloue plus que necessaire pour pouvoir stocker le nombre la taille du tableau (cette derniere devant etre connue de delete[]) et effectue ensuite un ajustement, qui risque de detruire l'alignement desire. On peut eventuellement compenser, mais ca va dependre de l'implementation et donc etre assez fragile.