[Mémoire] Alignement de mémoire et new/delete
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:
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:
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:
Foo * foo = new (Align(16)) Foo[4];
La bonne fonction est bien appelée :
Code:
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 !
