Discussion :

[yagero]

Bonjour à tous

Voici un petit programme en C, qui alloue tout simplement un tableau 2D de 200000x64 caractères, puis le désalloue.

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
 
int main() {
 
	char** tab;
	int i;
 
	sleep(5);
 
	printf("Allocation...\n");
	tab = (char**)malloc(200000*sizeof(char*));
	for(i=0; i<200000; i++)
		tab[i] = (char*)malloc(64*sizeof(char));
	printf("Ok\n");
 
	sleep(7);
 
	printf("Desallocation...\n");
	for(i=0; i<200000; i++)
		free(tab[i]);
	free(tab);
	printf("Ok\n");	
 
	sleep(20);
 
	return 1;
}

Je compile ce programme avec GCC sous Ubuntu, et le lance. En scruttant mon moniteur systeme pour voir la place prise par mon programme dans la mémoire vive, je note que :
pendant le premier sleep : 400 ko
pendant le deuxième sleep : 15 mo
pendant le troisième sleep : 14,2 mo !!!!!?!?!?

La désallocation se fait instantanemment, mais semble se faire très mal...

Alors où se trouve le problème ???

NB : en compilant ce meme code sous Windows avec Visual, la désallocation prend du tps, mais ce fait jusqu'au dernier octet alloué....

Merci d'avance pour vos tuyeaux !
Yagéro

[hegros]

Beh tu t'attendais a avoir quelle taux d'occupation de la mémoire ? Tu alloues bien 200000*64 octets non ca fait combien cela en mo

[Emmanuel Delahaye]

Voici un petit programme en C,

Ce code est incorrect. Il invoque un comportement indéfini, tout peut arriver.

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
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums2\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c:2: warning: function declaration isn't a prototype
main.c: In function `main':
main.c:7: warning: implicit declaration of function `sleep'
main.c:9: warning: implicit declaration of function `printf'
main.c:10: warning: implicit declaration of function `malloc'
main.c:19: warning: implicit declaration of function `free'
Linking console executable: console.exe
Process terminated with status 0 (0 minutes, 4 seconds)
0 errors, 5 warnings

Correction :

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
 
#include <stdlib.h>
#include <stdio.h>
 
#ifdef WIN32
#include <windows.h>
 
#define sleep(s) Sleep ((s)*1000)
#else
#include <unistd.h>             /* enfin, je crois */
#endif
 
int main (void)
{
   char **tab;
   int i;
 
   sleep (5);
 
   printf ("Allocation...\n");
   tab = malloc (200000 * sizeof *tab);
   for (i = 0; i < 200000; i++)
   {
      tab[i] = malloc (64 * sizeof *tab[i]);
   }
   printf ("Ok\n");
 
   sleep (7);
 
   printf ("Desallocation...\n");
   for (i = 0; i < 200000; i++)
   {
      free (tab[i]);
   }
   free (tab);
   printf ("Ok\n");
 
   sleep (20);
 
   return 1;
}

[yagero]

Pour Emmanuel Delahaye :
Oui désolé, j'ai pas mis les include, mais c'est pas le problème qui me gène... Vu que j'inclu les header d'une libraire, les sleep passent, et j'ai 0 erreurs et 0 warning, pas de pb à ce niveau la... Si vous voulez essayer le programme en mettant autre chose que les sleep, mais en faisant des "pauses" pour avoir le temps de regarder le Moniteur Systeme... Pourquoi mes "free" finaux ne me restaure pas les 15mo alloués ???

Pour hegros :
bah vu que je désalloue la totalité de tab, je m'attends à avoir 400 ko au 3eme sleep...

[Jean-Marc.Bourguet]

C'est relativement difficile de faire des allocateurs qui rendent à l'OS la mémoire libérée par le programme. Surtout quand il s'agit de petites allocations comme ici. Apparemment l'allocateur de Linux que tu emploies n'essaie pas de le faire dans ce cas; c'est relativement compréhensible, les programmes qui allouent beaucoup, puis libère beaucoup et continuent longtemps doivent être rares; et encore plus rare ceux qui le font d'une manière où il est possible de rendre la mémoire à l'OS.

Si tu as réellement besoin de cela, essaie en allouant de grands blocs (au minimum plusieurs pages). Et si cela ne fait toujours pas ce dont tu as besoin, tu vas devoir écrire un allocateur à toi.

[hegros]

Pourquoi mes "free" finaux ne me restaure pas les 15mo alloués ???

Je ne sais pas si l'appel à free entraîne immédiatement la libération de la mémoire allouée ou si finalement il ne délégue pas cela au système qu'il le fait quand cela l'arrange...

[yagero]

Au fait, voici le code complet (avec les includes cette fois ci) qui se compile avec gcc, si jamais vous voulez essayer chez vous :

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
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <unistd.h>
 
int main() {
 
	char** tab;
	int i;
 
	sleep(5);
 
	printf("Allocation...\n");
	tab = (char**)malloc(200000*sizeof(char*));
	for(i=0; i<200000; i++)
		tab[i] = (char*)malloc(64*sizeof(char));
	printf("Ok\n");
 
	sleep(7);
 
	printf("Desallocation...\n");
	for(i=0; i<200000; i++)
		free(tab[i]);
	free(tab);
	printf("Ok\n");	
 
	sleep(20);
 
	return 1;
}

Ce programme est juste un test. En fait j'ai besoin de créer un arbre, et pour chaque noeud de l'arbre, d'allouer une nouvelle matrice de 64 caractères. Le problème, c'est que la libération de mon arbre ne fonctionne pas du tout (c'est la même chose que je mette les free ou non). C'est pour cela que j'en suis revenu à tester l'allocation/désallocation d'un nombre de données assez importantes, qui à mon grand regret, ne semble pas très bien etre gérée sous Linux....

[|PaRa-BoL]

qui à mon grand regret, ne semble pas très bien etre gérée sous Linux....

Mieux géré que sous win32 en tout cas

[yagero]

J'ai essayé ce programme sous Windows, et la désallocation se fait parfaitement jusqu'au dernier octet...

[Jean-Marc.Bourguet]

J'ai essayé ce programme sous Windows, et la désallocation se fait parfaitement jusqu'au dernier octet...

mais lentement. Tu payes un prix pour cela et tu le paies toujours alors que le bénéfice (rendre la mémoire à l'OS) est rarement présent... Si tu réalloues dans ton process, tu ne vas pas redemander de la mémoire à l'OS.

[Gruik]

Peut etre que le moniteur systeme n'est pas tres fiable?
D'un coté, si il reste de la memoire sur la machine, pourquoi le systeme devrait il libérer ? Peut etre que le systeme commence à liberer vraiment quand la memoire libre devient critique

[yagero]

tiens si j'alloue, désalloue, puis réalloue et désalloue, du coup j'ai plus rien dans la mémoire à la fin...

Si tu réalloues dans ton process, tu ne vas pas redemander de la mémoire à l'OS

Le principe de désallouer, c'est quand meme de virer de la mémoire...
Si je désalloue avec un free, c'est que je veux la libérer cette mémoire et pas qu'il me la garde pour "au cas où j'ai envie de réallouer plus tard"... Si je veux qu'il me la garde, je ne la free pas et puis c'est tout...

[hegros]

Le principe de désallouer, c'est quand meme de virer de la mémoire...

C'est plutot de dire que tu n'en as plus besoin que c'est libre et que tu ne l'utilises plus.

[Thierry Chappuis]

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
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <unistd.h>
 
int main() {
 
	char** tab;
	int i;
 
	sleep(5);
 
	printf("Allocation...\n");
	tab = (char**)malloc(200000*sizeof(char*));
	for(i=0; i<200000; i++)
		tab[i] = (char*)malloc(64*sizeof(char));
	printf("Ok\n");
 
	sleep(7);
 
	printf("Desallocation...\n");
	for(i=0; i<200000; i++)
		free(tab[i]);
	free(tab);
	printf("Ok\n");	
 
	sleep(20);
 
	return 1;
}

Salut,

malloc.h n'est pas standard. En plus je ne vois pas à quoi ça sert, puis les fonctions d'allocation dynamiques de mémoire sont déclarées dans stdlib.h.

Ensuite, par convention, main retourn 0 ou EXIT_SUCCESS lorsque le programme s'est exécuté avec succès.

Concernant, la mémoire non libérée. Je pense que free permet de signaler au système que l'espace mémoire en question n'est plus utilisé. Il est alors libre de le recupérer et le re-allouer quand bon lui semble.

Thierry

[Emmanuel Delahaye]

Mieux géré que sous win32 en tout cas

Tu peux prouver ce que tu avances ou tu répètes bêtement ce qu'on dit parce que 'Microsoft, çaÿ le Mal' ?