Structure de la mémoire

Version imprimable

Bonjour,

Selon le schéma suivant :

http://www.andrew.cmu.edu/course/15-...roccontext.jpg

et le code suivant :

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
 
#include <stdio.h>
#include <stdlib.h>
 
#define MAX 500
int varglobni;
int varglobi;
 
int main (){
	static int staticni=5;
	static int statici;
	int i;
	int nbres;
	printf("Combien y a t'il de résultat a encoder ? ");
	scanf("%d",& nbres);
	int *memoireAlloue = malloc(nbres*sizeof(int));
	if (memoireAlloue == NULL)
		exit(1);
	for (i=0;i<nbres;i++){
		printf("Bonjour ! Veuillez encodez le résultat numéro %d : ",i+1);
		scanf("%d",memoireAlloue + i);
	}
	for (i=0; i<nbres; i++)
		printf("Le nombre %d que vous avez encode est : %d\n",i+1,*(memoireAlloue+i));
	//printf("L'adresse d'un define est : %p",& MAX);
	printf("L'adresse d'une variable globale initialisé est : %p\n", &varglobi);
	printf("L'adresse d'une variable globale non-initialisé est : %p\n", &varglobni);
	printf("L'asresse d'une variable STATIC non-initialisé est : %p\n", &staticni);
	printf("L'asresse d'une variable STATIC initialisé est : %p\n", &statici);
	printf("La pile\n");
	printf("L'adresse du pointeur est : %p\n", &memoireAlloue);
	printf("L'adresse du compteur est : %p\n", &i);
	printf("L'adresse de nbres est :    %p\n", &nbres);
	printf("Le tas\n");
	for (i=0; i<nbres;i++)
		printf("L'adresse du nombre %d que vous avez encode est : %p\n",i+1,memoireAlloue+i);
 
	free(memoireAlloue);
	return 0;
 
}

Et pour ceux qui ont la flemme de le compiler le résultat :

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
 
Combien y a t'il de résultat a encoder ? 5
Bonjour ! Veuillez encodez le résultat numéro 1 : 
5
Bonjour ! Veuillez encodez le résultat numéro 2 : 52
Bonjour ! Veuillez encodez le résultat numéro 3 : 1
Bonjour ! Veuillez encodez le résultat numéro 4 : 0
Bonjour ! Veuillez encodez le résultat numéro 5 : 15
Le nombre 1 que vous avez encode est : 5
Le nombre 2 que vous avez encode est : 52
Le nombre 3 que vous avez encode est : 1
Le nombre 4 que vous avez encode est : 0
Le nombre 5 que vous avez encode est : 15
L'adresse d'une variable globale initialisé est : 0x601068
L'adresse d'une variable globale non-initialisé est : 0x601064
L'asresse d'une variable STATIC non-initialisé est : 0x601048
L'asresse d'une variable STATIC initialisé est : 0x601060
La pile
L'adresse du pointeur est : 0x7fffc8c2c1d0
L'adresse du compteur est : 0x7fffc8c2c1dc
L'adresse de nbres est :    0x7fffc8c2c1d8
Le tas
L'adresse du nombre 1 que vous avez encode est : 0x25d2010
L'adresse du nombre 2 que vous avez encode est : 0x25d2014
L'adresse du nombre 3 que vous avez encode est : 0x25d2018
L'adresse du nombre 4 que vous avez encode est : 0x25d201c
L'adresse du nombre 5 que vous avez encode est : 0x25d2020

Désolé que ca soit aussi long mais c'est pour bien comprendre.

Questions :

-Les variables globales et static non-initialisées devraient être stockées dans le segment de mémoire bss ? Pourquoi dans mon code elles sont visiblement stockée sur le tas ou en tout cas au même endroit que celles initialisées?

-Pourquoi est-ce que je ne peux pas voir l'adresse de #define MAX 500 ? (erreur à la compilation)

-Je pensais que dans le segment de donnée il y aurait mes variables, mais elles sont sur la pile, n'est-ce pas ? Dès lors, dans le segment de donnée qu'est-ce qu'il y a ?

Beaucoup de blabla pour peu de questions mais bon, merci à celui ou ceux qui prendront le temps de me lire et de me répondre ;)

bye bye

03/01/2010, 21h27
SofEvans

Pour ce qui est du define, c'est un cas special : Des personne qui en connaisse plus long sur le sujet le preciseront, mais un define n'est pas retenu en memoire.
Ce n'est pas une variable et un define ne prend pas de place memoire (parce que justement, elle l'est as retenu en memoire), donc tu ne peut pas avoir l'adresse d'un define.

Pour le reste, je m'abstient.

Citation:

Envoyé par Trademark

Questions :

-Les variables globales et static non-initialisées devraient être stockées dans le segment de mémoire bss ? Pourquoi dans mon code elles sont visiblement stockée sur le tas ou en tout cas au même endroit que celles initialisées?

-Pourquoi est-ce que je ne peux pas voir l'adresse de #define MAX 100 ? (erreur à la compilation)

-Je pensais que dans le segment de donnée il y aurait mes variables, mais elles sont sur la pile, n'est-ce pas ? Dès lors, dans le segment de donnée qu'est-ce qu'il y a ?

Réponses :

- Les variables globales et statiques non initialisées sont bien placées dans le segment de mémoire bss.
Si tu remarques bien la mémoire est 'continue' entre les différents segments de mémoire. De ce fait si tu as peu de variables placées dans ces segments tu ne verras pas la différence. Si tu veux vraiment voir la différence il faudra déclarer des variables plus grandes (tableau).

- A la compilation le préprocesseur remplace le mot MAX par la valeur 100 partout où elle apparaît dans ton code. Elle n'a donc pas d'adresse mémoire parce que dans le code 'fini' elle n'existe pas.

- cf réponse 1

D'ailleurs tes 2 variables globales ne sont pas initialisées :)

Mais attention tout de même c'est très dépendant de l'implémentation !!!
Ca peut varier d'un PC à l'autre !

Essaye avec ce code :
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 #include <stdio.h> #include <stdlib.h> #define MAX 10000 int varglobni[MAX] = { 0 }; int varglobi[MAX]; int main (void) { static int staticni[MAX] = { 0 }; static int statici[MAX]; int *memoireAlloue = malloc(MAX * sizeof *memoireAlloue); if (memoireAlloue == NULL) exit(EXIT_FAILURE); printf("L'adresse d'une variable globale initialisé est : %p\n", (void *) &varglobi); printf("L'adresse d'une variable STATIC initialisé est : %p\n", (void *) &statici); puts(""); printf("L'adresse d'une variable globale non-initialisé est : %p\n", (void *) &varglobni); printf("L'asresse d'une variable STATIC non-initialisé est : %p\n", (void *) &staticni); printf("\nLa pile\n"); printf("L'adresse du pointeur est : %p\n", (void *) &memoireAlloue); printf("\nLe tas\n"); printf("L'adresse de la mémoire allouée est : %p\n", (void *) memoireAlloue); free(memoireAlloue); return EXIT_SUCCESS; }
Chez moi il retourne :
Code:

1 2 3 4 5 6 7 8 9 10 11 L'adresse d'une variable globale initialisé est : 0x10001f880 L'adresse d'une variable STATIC initialisé est : 0x10000c000 L'adresse d'une variable globale non-initialisé est : 0x1000023c0 L'asresse d'une variable STATIC non-initialisé est : 0x100015c40 La pile L'adresse du pointeur est : 0x7fff5fbff768 Le tas L'adresse de la mémoire allouée est : 0x100825400

Merci de ta réponse, mais du coup tu as un peu modifier mon code et j'ai quelques autres questions ^^

Citation:

D'ailleurs tes 2 variables globales ne sont pas initialisées

Quelle ***** !

Citation:

int *memoireAlloue = malloc(MAX * sizeof *memoireAlloue);

-Pourquoi sizeof ne necessite pas de () ?
-*memoireAlloue renvoie sur sa déclaration donc sur un int, ce qui équivaut a faire sizeof int ?

-Pourquoi est-ce que tu rajoutes des pointeurs génériques et à quoi ca sert ? (* void)

comme la par exemple :
Code:

1 2 printf("L'adresse d'une variable globale initialisé est : %p\n", (void *) &varglobi);
-Si on demande l'adresse des variables en décimal pour y voir plus clair on a ca :
Code:

1 2 3 4 5 6 7 8 9 10 11 Segment de tas L'adresse d'une variable globale initialisé est : 6415648 L'adresse d'une variable STATIC initialisé est : 6335648 Segment bss L'adresse d'une variable globale non-initialisé est : 6295648 L'adresse d'une variable STATIC non-initialisé est : 6375648
On peut se rendre compte que les adresses :

globale non-initialisé < STATIC initialisé < STATIC non-initialisé

Je pensais que chaque segment avaient sa zone d'adresse mémoire bien spécifique ce n'est pas le cas ?

03/01/2010, 22h53
Pouet_forever

Citation:

Envoyé par Trademark

-Pourquoi sizeof ne necessite pas de () ?
-*memoireAlloue renvoie sur sa déclaration donc sur un int, ce qui équivaut a faire sizeof int ?

sizeof nécessite des parenthèses pour les types (int, short, char, etc.) mais pas pour les variables (sizeof a, sizeof *b).
Pour savoir ce que vaut sizeof *memoireAlloue il suffit de savoir ce que vaut *memoireAlloue. memoireAlloue pointe sur un int donc si tu déréférences ça te donne un int :)

Citation:

Envoyé par Trademark

-Pourquoi est-ce que tu rajoutes des pointeurs génériques et à quoi ca sert ? (* void)

Le formateur %p attent un pointeur sur void et pas un pointeur sur int* ;)

Citation:

Envoyé par Trademark

-Si on demande l'adresse des variables en décimal pour y voir plus clair on a ca :

Les adresses mémoires sont des adresses héxa donc pourquoi les transformer en décimal ?

Citation:

Envoyé par Trademark

On peut se rendre compte que les adresses :

globale non-initialisé < STATIC initialisé < STATIC non-initialisé

Je pensais que chaque segment avaient sa zone d'adresse mémoire bien spécifique ce n'est pas le cas ?

Encore une fois ça dépend de l'implémentation ! Ca peut changer d'un PC à l'autre :)
Aucun segment n'a d'adresse de mémoire spécifique ! Ca change à chaque exécution ;)
03/01/2010, 23h29
Trademark
Citation:

Envoyé par Pouet_forever

Le formateur %p attent un pointeur sur void et pas un pointeur sur int* ;)

Je suis d'accord pour ce code la :
Code:

1 2 printf("L'adresse de la mémoire allouée est : %p\n", (void *) memoireAlloue);
mais c'est vraiment utile pour les autres ? Parce que ils retournent une adresse et non pas un pointeur sur int.

En tout cas merci de ton aide :ccool:, c'était ma dernière question ;)

Tchao
03/01/2010, 23h51
Pouet_forever

Citation:

Envoyé par Trademark

mais c'est vraiment utilise pour les autres ?

Ce sont tous des pointeurs sur int donc ils n'échappent pas à la règle ;)

Merci de tes réponses :mrgreen:

EDIT : j'ai vu que tu avais fait l'impasse sur une de mes questions à savoir : Que contient le segment de donnée si les variables ne se situent pas dedans ?

C'est bon je sais. Pour ceux qui passeront par là plus tard je vous mets mes trouvailles dans une balise code, oui c'est assez long...

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
73
74
75
76
77
78
79
Structure de la mémoire

Segment de code ( aussi appelé segment de texte) ==> Adresse basse (ex : 0x000000)
CONTIENT : le code en lecture seule.
Le processeur utilise le registre d'offset EIP (instruction pointer, cf. ASM). 
1- Il lit la première instruction pointé par IP
2- Ajoute à IP la taille en octet de l'instruction (bah oui, on va pas lire 5000 la même).
3- Exécute l'instruction lue en (1)
4- Retourne a l'étape (1).
Évidemment ce segment est en lecture seul, on va pas modifier le programme pendant son execution quand meme oO (ps : meme si on essaye ca fait une méchante erreur). Grace a ca, on peut avoir plusieurs execution d'un meme programme [à méditer].

Segment de donnée
CONTIENT : Les variables statiques et globales INITIALISES.
Segment bss
CONTIENT : Les variables statiques et globales NON-INITIALISES.

EXPLICATION : Les trois segments précédents ont une taille fixe, c'est ce qui permet aux variables globales et statiques de persister. Pourquoi ? Car ca ne fonctionne comme la pile, cf. bloc d'activation. No stress, vous comprendrez plus tard.

Segment de tas Adresses basses, grandit vers les adresses hautes.
CONTIENT : Les mallocs(), càd les allocations dynamiques, en effet ce segment ci n'a pas une taille fixe, donc on alloue (malloc, calloc) et puis libère (free).

--
--
--
\/

/\
--
--
--

Segment de pile Adresses mémoires hautes (ex = 0xFFFFFF), augmente vers les adresses basses (bon ca va, on aura compris je crois)

CONTIENT : les variables locales, et le contexte des appels de fonctions.
Bon pour bien comprendre il faut expliquer ça,
...
[S'hydrate au pepsi]
...


Reprenons le code du site  :

	Code:
	
12345678910  
int triple(int nombre){
    int resultat = 0;
    resultat = 3 * nombre;
    return resultat;}
 
int main(int argc, char *argv[]){
    printf("Le triple de 15 est %d\n", triple(15));   
    return 0;
}
Contexte de fonction : Ici le contexte de main() c'est les 2 instructions (placée dans le segment de donnée)
Le contexte de triple() : c'est les variables locales a triple() (au CONTEXTE de triple()) (placée dans le segment de pile) et les instructions.

Bon maintenant suivons le programme, il fait triple(15), très bien il va faire appel a la fonction triple, il y va et fait les instructions qu'il y a a l'intérieure. Mais il s'est perdu... Comment peut-il savoir comment revenir dans le programme main() et continuer ??
C'est la qu'intervient l'astuce, une fois que main() fait appel à notre fonction triple(), on va sauvegarder le contexte de main() sur la pile. 
Cette sauvegarde est appelé bloc d'activation.
Retenez bien qu'il faut toujours des adresses et donc un pointeur pour tout et n'importe quoi (les variables, instructions, etc).
Le bloc d'activation contient donc : 
1- Un pointeur sur le bloc d'activation (son adresse) ; SFP (save frame pointer).
Il pointera donc sur l'adresse de main() quand il chez triple(). [Segment de pile]
2- Un pointeur sur l'instruction que le processeur doit executé après l'appel de la fonction : l'adresse de retour (ret ca vous dit rien en assembleur? :king:).ex = mov IP, ret [Segment de code]
3- Les variables locales, instructions...

1- et 2- sont appelés prologue de fonction

Evidemment vous devez remarqué quelque chose, un élément manquant, si SFP pointe sur main(), QUI montre au processeur le bloc d'activation dans lequel ils sont en train de travailler ? Et bien c'est EBP (base pointer) aussi appelé.... EFP (frame pointer). En fait SFP ne sert qu'a sauvergarder, une fois de retour dans notre fonction main() c'est EBP qui prendra le relais : 

ex = mov ebp, SFP

La pile va donc contenir plein de blocs d'activation si on a plein de fonction :D

Remarque : Voila pourquoi une variable locale ne peut être accedée que dans son contexte, car imaginons notre fonction triple, il ne peut pas accéder au bloc d'activation de main(), car il est en dessous de lui et que BP pointe sur lui ( et que du coup si on dit a BP d'aller pointer sur main() ca n'aura plus rien avoir avec notre fonction triple()). Au contraire nos variables statics et globales stockées sur le segment de données ou bss sont bien accessibles a tous les blocs d'activations !


Ca parait compliqué mais ca ne l'est pas tant que ca. Et c'est fini Very Happy !

SI vous voyez des fautes ca serait gentil de me le dire, ca voudrait aussi dire que je n'ai pas tout compris ^^ Allez Bye bye

04/01/2010, 11h31
diogene

Citation:

-Les variables globales et static non-initialisées devraient être stockées dans le segment de mémoire bss ? Pourquoi dans mon code elles sont visiblement stockée sur le tas ou en tout cas au même endroit que celles initialisées?

Peut-être simplement parce que, en C, les variables globales ou static sont toujours initialisées (explicitement ou par défaut)
04/01/2010, 14h52
Médinoc

À savoir aussi, il y a des données en lecture seule et des données pouvant être écrasées. Les chaînes littérales notamment sont en lecture seule sous Windows et Linux (bien que pour raisons historiques, le compilateur C autorise un pointeur non-const à pointer dessus).

PS: Tu devrais discuter avec l'utilisateur wafiwafi, qui semble être à fond là-dedans en ce moment.