Discussion :

[Shadew]

Bonjour,

Je suis en train d'étudier l'alignement et le padding et je cherche à observer comment gcc organise les membres d'une structure en mémoire.

Voici le code que j'utilise :

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
struct example1 {
	char c1;
	short s;
	char c2;
	int l;
};
 
struct example2 {
	char c1;
	short s;
	char c2;
	int l;
}__attribute__ ((aligned (1)));
 
struct example3 {
	char c1 __attribute__ ((aligned (4)));
	short s __attribute__ ((aligned (4)));
	char c2 __attribute__ ((aligned (4)));
	int l;
};
 
struct example4 {
	char c1;
	short s;
	char c2;
	int l;
}__attribute__ ((__packed__));
 
 
int main(){
	printf("char : %d, short : %d, long : %d\n", sizeof(char), sizeof(short), sizeof(int));
	printf("1 : %d, 2 : %d, 3 : %d, 4 : %d\n", sizeof(struct example1), sizeof(struct example2), sizeof(struct example3), sizeof(struct example4));
}

Y a-t'il un moyen de voir comment gcc organise les membres des différentes structures en mémoire ? Je me demande si, par défaut, il met 3 octets de padding après c2 ou s'il en met 1 après c2 et 2 après l (je pencherais plutôt pour la première solution).

Merci !!

[diogene]

Tu peux compléter les informations obtenues par sizeof par celles que peut te donner offsetof(). Tu devrais alors pouvoir reconstituer la configuration mémoire de la structure.

[jeroman]

Par défaut, sur une machine 32 bits, chaque membre de la structure doit être aligné de manière à se trouver à une adresse multiple de X, qui varie en fonction de son type.
Un char : 1
Un short : 2
Un int et float : 4
Un double : 8 (sur Windows)
etc

Les membres de la structure se trouvent en mémoire dans l'ordre écrit.

Si le second membre n'est pas aligné correctement, on rajoute à la suite du membre précédent un nombre d'octets de padding de manière à ce que ce second membre soit bien aligné.
Si le troisième membre n'est pas correctement aligné, on rajoute des octets de padding à la suite du second.
Et ainsi de suite.

Avec ton exemple n°1 :
En admettant que le premier membre soit correctement aligné :
Le premier membre est un char et le second est un short. short exige d'être positionné à une adresse multiple de 2. On rajoute donc un octet de padding après le char, de manière à ce que le second membre se trouve à l'adresse 2 (car 2 % 2 == 0).
Le troisième membre est un char, il se trouve donc à la suite du précédent.
Le quatrième membre doit être aligné sur une adresse multiple de 4. Or le troisième membre se trouve à l'adresse 4 et il a une taille de 1 octet, on doit donc rajouter 3 octets de padding afin que ce 4ème membre soit à l'adresse 8 (cad : multiple de 4, ou encore 8 % 4 == 0).

Dans ton exemple n°2, je ne saurais dire...

Dans ton exemple n°3, tu obliges les trois premiers membres à être alignés de manière à ce que chacun soit positionné à une adresse multiple de 4.

Dans ton exemple n°4, tous les membres de la structures sont mis bout à bout en mémoire (l'alignement est supprimé).

J'espère ne pas avoir dit trop de bêtises...

EDIT :

Quelques explications supplémentaires : http://en.wikipedia.org/wiki/Data_structure_alignment