Discussion :

[Bakura]

Bonsoir à tous !

J'ai besoin que ma mémoire soit aligné, et pour ceci j'utilisais _mm_malloc et _mm_free. Toutefois, après avoir cherché pendant pas mal de temps ce qui causait un problème dans mon problème, je me suis rendu compte que malloc et free n'appelaient pas le constructeur et... ben c'est pareil pour _mm_malloc et _mm_free.

J'ai essayé d'utiliser le code ici (http://www.swedishcoding.com/2008/08...out-of-memory/), que je recopie ici :

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
class Align
{
	public:
		explicit Align (std::size_t value_)
			: value (value_)
		{
		}
 
		std::size_t GetValue () const
		{
			return value;
		}
 
	private:
		std::size_t value;
};
 
 
// Surcharge de l'opérateur new (normal)
static void * operator new (std::size_t size_)
{
	return malloc (size_);
}
 
 
// Surcharge de l'opérateur delete (normal)
static void operator delete (void * memory_)
{
	free (memory_);
}
 
 
// Surcharge de l'opérateur new pour les tableaux (normal)
static void * operator new [] (std::size_t size_)
{
	return malloc (size_);
}
 
 
// Surcharge de l'opérateur delete pour les tableaux (normal)
static void operator delete [] (void * memory_)
{
	free (memory_);
}
 
 
// Surcharge de l'opérateur new (aligné)
static void * operator new (std::size_t size_, Align alignment_)
{
	return _mm_malloc (size_, alignment_.GetValue());
}
 
 
// Surcharge de l'opérateur delete (aligné)
static void operator delete (void * memory_, Align alignment_)
{
	_mm_free (memory_);
}
 
 
// Surcharge de l'opérateur new pour les tableaux (aligné)
static void * operator new [] (std::size_t size_, Align alignment_)
{
	return _mm_malloc (size_, alignment_.GetValue());
}
 
 
// Surcharge de l'opérateur delete pour les tableaux (aligné)
static void operator delete [] (void * memory_, Align alignment_)
{
	_mm_free (memory_);
}

Pour les versions "normales", ça marche bien, mais pour les versions alignées, problème.

La mémoire est correctement allouée, en faisant soit :

Code :

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

1
2
Foo * foo = new (Align(8)) Foo; // Un seul élément
Foo * foo = new (Align(8)) Foo [4]; // Tableau

Par contre, cela pose un soucis pour la libération de la mémoire. Car si j'écris delete (Align(16)) foo; ou delete[] (Align(16)) foo; ceci ne fonctionne pas...

J'ai également essayé operator delete [] (foo, Align(16)), et la bonne fonction est bien appelée mais j'obtiens un crash (Damage before 0x00083E58 which was allocated by aligned routine), comme si la mauvaise adresse était passée....

Si quelqu'un a un moyen de résoudre ce soucis je prends !!


Et j'ai une autre petite question ! Par exemple, si j'écris :

Code :

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

Foo * foo = new (Align(16)) Foo[4];

La bonne fonction est bien appelée :

Code :

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

1
2
3
4
static void * operator new [] (std::size_t size_, Align alignment_)
{
	return _mm_malloc (size_, alignment_.GetValue());
}

Par contre j'ai remarqué que size_ est plus grand que prévu. Exemple, si sizeof (Foo) = 8 octets, j'obtiens size == 40 octets au lieu de 8. Est-ce que le compilo alloue 4 octets pour quelque chose de spécial (la taille j'imagine ?).

Mirci !

[Nogane]

Bonsoir,
Pour ton erreur sur le delete, je ne crois pas qu'il faille appeler delete avec Align. Le delete par placement n'appelle pas le destructeur, donc un delete avec des arguments en plus ne le fait peut-être pas non-plus. Dans tout les cas, un delete ordinaire semble suffire.
(Les delete avec Align n'existe que pour le cas ou le new générerai une exception. Dans ce cas le compilateur appel un delete qui a les meme argument que le new.)

Pour ta question sur les 4 octet en plus. Je pense que cela dépend du compilateur mais je dirait qu'il doit y avoir 4 octets en plus pour savoir le nombre d'objet alloué. Pour pouvoir détruire le même nombre d'objet lors du delete.

[EDIT]
Je ne sait pas ce que tu compte faire avec ce new et delete surchargés, mais tu risque d'avoir des problèmes avec toutes les class qui utilisent des new et delete dans leurs fichier d'entête, comme par exemple les std::vector. Car tu va surcharger le delete mais pas le new(qui n'as pas le même prototype), et tu risque d'utiliser mm_free sur de la mémoire allouée avec new.

[Bakura]

Dans tout les cas, un delete ordinaire semble suffire.

Non. La mémoire allouée avec _mm_malloc doit être obligatoirement libérée avec _mm_free. D'ailleurs, si j'alloue la mémoire avec _mm_malloc et que j'appelle delete [] foo, il va appeler la version normale du delete, et m'indiquer un message d'erreur comme quoi la mémoire allouée avec l'alignement doit être libérée avec _mm_free.

Je ne sait pas ce que tu compte faire avec ce new et delete surchargés, mais tu risque d'avoir des problèmes avec toutes les class qui utilisent des new et delete dans leurs fichier d'entête, comme par exemple les std::vector.

Pourquoi ça ? std::vector utilisera les surcharges "normales" de new, non ?


En fait, pour être honnête, j'aimerais beaucoup pouvoir me passer des pointeurs. Le seul soucis, c'est que std::vector ne permet pas d'aligner la mémoire. Après avoir cherché un peu sur Google, visiblement c'est un des problèmes de la STL actuelle... Mais si quelqu'un a une solution portable et pas trop compliquée pour pouvoir utiliser les vector avec la mémoire alignée, je suis preneur aussi :p.

[yan]

Salut.
Il te faut redéfinir new et delete dans ta class

http://www.ann.jussieu.fr/courscpp/S...Sect07-B9.html

[Bakura]

Je pense que je vais faire ça, ça va être moins prise de tête. Et concernant vector ?

[yan]

Je pense que je vais faire ça, ça va être moins prise de tête. Et concernant vector ?

Il utilise l'allocator qu'on lui donne en parametre template.
Donc je suppose qu'il redéfinie ses new et delete

[Bakura]

Ok, en cherchant sur le forum j'ai trouvé une réponse de Charlemagne qui donnait un allocator pour ça ici. Je reposte le code :

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
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)_mm_malloc (n*sizeof(value_type), N);
		}
 
		inline void deallocate (pointer p, size_type)
		{
			_mm_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;
		};
};
 
int main ()
{
	std::vector<Foo, AlignmentAllocator<Foo, 8> > foo;
 
	return EXIT_SUCCESS;
}

[Charlemagne]

J'avais programmé un allocateur pour mémoire alignée. Ca marche sous divers système.
Ca peut peut-être t'intéresser...

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
56
57
58
59
60
61
#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(__MINGW64__)
  #include <malloc.h>
  inline void *aligned_malloc (size_t size, size_t align=16) { return malloc(size+align);  }
  inline void  aligned_free   (void *p)                      { return 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); }
#elif (defined(__MACOSX__) || defined(__APPLE__))
  #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; };
};

[Bakura]

Tiens, bah justement j'ai parlé de ton allocateur dans mon message d'avant :p. Par contre je croyais que _mm_malloc et _mm_free étaient portables... visiblement non :p.

Je me permets d'utiliser ton code si ça ne te dérange pas ^^. Au passage, j'y connais pas grand chose sur les allocateurs, mais je dois allouer pas mal de mémoire d'un seul bloc, je souhaiterais savoir s'il y a un moyen d'aller plus vite que d'utiliser les _mm_malloc et _mm_free.

Secondo, ma classe contient 8 octets, je l'aligne donc sur 8 octets. Est-il préférable toutefois de l'aligner sur 16 octets, quite à perdre de la place, ou aligner sur un multiple de 4 ne pose pas de problèmes de performancs ?

[Charlemagne]

Tiens, bah justement j'ai parlé de ton allocateur dans mon message d'avant :p. Par contre je croyais que _mm_malloc et _mm_free étaient portables... visiblement non :p.

Le temps que je réponde...
Malheureusement, _mm_malloc et _mm_free ne sont pas portables. J'ai trouvé les variantes au fur et à mesure.

Je me permets d'utiliser ton code si ça ne te dérange pas ^^. Au passage, j'y connais pas grand chose sur les allocateurs, mais je dois allouer pas mal de mémoire d'un seul bloc, je souhaiterais savoir s'il y a un moyen d'aller plus vite que d'utiliser les _mm_malloc et _mm_free.

Pas vraiment possible d'améliorer la vitesse à ma connaissance. De plus j'imagine que _mm_alloc et _mm_free font des appels systèmes, ce qui n'encourage pas à s'en passer.
La seule possibilité que je vois est un "pool allocator", mais c'est surtout utile quand on a besoin d'une multitude d'allocations et désallocations d'objets d'une même petite taille.

Secondo, ma classe contient 8 octets, je l'aligne donc sur 8 octets. Est-il préférable toutefois de l'aligner sur 16 octets, quite à perdre de la place, ou aligner sur un multiple de 4 ne pose pas de problèmes de performancs ?

A priori, ça ne pose pas de problème de performance d'utiliser une allocation dynamique non alignée.
L'alignement sur 16 octets n'est à ma connaissance utile que pour les instructions SSE.

Pourquoi as-tu donc besoin de l'alignement?

[Bakura]

Pourquoi as-tu donc besoin de l'alignement?

Justement parce que j'aurai peut-être besoin d'utiliser SSE ^^.

[Nogane]

Dans tout les cas, un delete ordinaire semble suffire.

Non. La mémoire allouée avec _mm_malloc doit être obligatoirement libérée avec _mm_free. D'ailleurs, si j'alloue la mémoire avec _mm_malloc et que j'appelle delete [] foo, il va appeler la version normale du delete, et m'indiquer un message d'erreur comme quoi la mémoire allouée avec l'alignement doit être libérée avec _mm_free.

Attention, par "delete ordinaire" je fait référence au delete surchargé mais ne prenant pas d'argument en plus. C'est d'ailleurs ce qui est fait dans le lien que tu as donné dans ton premier message.
En revanche je suppose qu'il utilise le _mm_malloc dans ces 4 operateurs new. (mais je n'est pas trouvé le contenu de ces new donc je n'ai aucune certitude)

std::vector utilisera les surcharges "normales" de new, non ?

En fait j'ai déjà eu ce problème, en surchargeant new pour y passer _FILE_ et _LINE_. Le vector appelait le new normal, mais mon delete a moi...

[Bakura]

Une petite précision apportée par les gurus de Ompf, lorsque j'ai posté ta solution Charlemagne :

Well, yes, this avoids segfaults at run time by taking care memory is properly allocated, but you still need to patch your STL if you're using Visual Studio, because there the problem is a compile time error and a problem with the compiler itself.

This :

Code :

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

1
2
3
4
5
6
int main(int argc,char *argv[])
{
   std::vector<__m128, AlignmentAllocator<__m128, 8> > foo;
   foo.resize(222);
   return 0;
}

Segfaults when run with msvc9. (But gives no warning messages when being built.)

[Médinoc]

D'un autre côté, qu'un type SIMD de 16 octets plante lorsqu'on lui donne un alignement de 8, ça ne me choque pas particulièrement...

[Bakura]

Effectivement, cela ne me choque pas non plus (en fait j'avias pas vu que le gars avait écrit 8), mais d'après ce que j'ai compris de leur message, ça planterait même avec 16... A tester :p.

[loufoque]

operator new est censé allouer la mémoire avec un alignement suffisamment important pour tous les types.
C'est un design totalement stupide à mon avis, d'autant plus que le type et donc l'alignement sont connus quand on utilise new.

La solution la plus pratique reste de surcharger operator new et operator delete pour ton type, puisque c'est totalement non intrusif...
std::allocator alloue sa mémoire avec ces opérateurs, donc pas de soucis.