Problème d'alignement sur 128 bits

**progfou** · 05/07/2007, 10h24

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

__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...

**Charlemagne** · 05/07/2007, 10h43

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**progfou** · 05/07/2007, 10h49

Effectivement, moi aussi j'utilise une définition

.
Donc, je ne comprends pas pourquoi il n'aligne pas sur 16...
Il peut pourtant !

**Charlemagne** · 05/07/2007, 10h52

Attends, je vais essayer de vérifier...

**progfou** · 05/07/2007, 11h16

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é

.

**loufoque** · 05/07/2007, 14h29

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/

**progfou** · 05/07/2007, 15h10

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 ?

**Médinoc** · 06/07/2007, 11h48

Comprend pas tes derniers posts.
Pourquoi es-tu passé de 16 à 8 ?
Et que veux-tu voir aligné, finalement ?

**progfou** · 06/07/2007, 14h35

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 !

**Jean-Marc.Bourguet** · 06/07/2007, 14h39

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.

**Médinoc** · 06/07/2007, 14h40

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é...

**progfou** · 06/07/2007, 14h42

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.

**Médinoc** · 06/07/2007, 15h08

Tu peux peut-être modifier ton operator new pour le forcer à aligner sur 16 octets...

**progfou** · 06/07/2007, 15h13

En fait, il me suffit de faire quelque chose comme cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

**Jean-Marc.Bourguet** · 06/07/2007, 15h18

Presque. L'arithmetique sur les pointeurs ne fonctionne pas en byte mais d'apres le type pointe.

**progfou** · 06/07/2007, 15h21

Euh, c'est à dire

.

**Charlemagne** · 06/07/2007, 15h21

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**progfou** · 06/07/2007, 15h29

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 ?

**Charlemagne** · 06/07/2007, 15h33

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.

**progfou** · 06/07/2007, 15h39

Je ne maîtrise pas assez le concept pour comprendre ta réponse

. J'ai pourtant relu plusieurs fois...

Problème d'alignement sur 128 bits

C++

Discussions similaires

Partager

Partager