Discussion :

[Aspic]

Bonjour,

Je souhaite essayer de comprendre comment la mémoire est allouée par malloc en C :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int c;
    system("pause");
    for(c=0; c<1024; c++)
    {
        char* tmp = malloc(8);
        //char* tmp = calloc(8, sizeof(char));
        //printf("%d\n", _msize(tmp));
        tmp[0] = '\0';
    }
    system("pause");
    exit(-1);

Soit le programme suivant dans le main. Normalement je devrais allouer 1024*8 octets = 8192 octets = 8 Ko
Or dans le gestionnaire de mémoire de Windows 7, mon programme alloue 16 Ko de mémoire entre mes deux system("pause").

J'ai d'abord pensé aux alignements mémoire mais 8 étant un multiple de 8, normalement, il ne devrait pas y avoir d'alignement.

Je voudrais comprendre pourquoi j'ai deux fois plus de mémoire allouée sachant que j'ai besoin d'optimiser la mémoire de mon programme.

PS : J'ai testé aussi avec 45 000 000 d'itérations dans la boucle for, même problème, j'ai deux fois plus de mémoire allouée au final.

Merci d'avance

[sambia39]

Bonjour
Il me semble que c'est normal et cela est peut-être dû aux données d'alignement essayer de faire un cast sur la valeur de retour et tester éventuellement si l'allocation est correcte.
Cependant, je ne comprends pas trop l'intérêt d'effectuer une allocation avec une valeur constante dans une boucle ?
y a-t-il pas écrasement d'adresse d'allocation à chacun itération ?

for(c=0; c<1024; c++)
{
char* tmp = malloc(8);
//char* tmp = calloc(8, sizeof(char));
//printf("%d\n", _msize(tmp));
tmp[0] = '\0';
}

Il est plutôt préférable d'effectuer une seule allocation et ainsi utiliser cette adresse autrement exemple:

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
 
#include <stdio.h>
#include <stdlib.h>
 
int main( void ){
 
	char *ptr = NULL;
	unsigned int i = 0;
	const size_t size = 127;
 
	ptr = (char*)malloc( size * sizeof(char) );
	if( (NULL) == ptr ){
		perror("Erreur Allocation mémoire\n");
		exit( EXIT_FAILURE );
	}
 
	for( i = 0; i < size; i++ )
		*(ptr+i) = (char)i;
	for( i = 0; i < size; i++ )
		printf( "(%d)\t:%c\n", i, *(ptr+i) );
 
	free( ptr );
	ptr = NULL;
 
	return( EXIT_SUCCESS );
}

à bientôt

[picodev]

Bonjour,

Il n'y a pas un malloc en C. Il y a différentes stratégies d'allocation de mémoire suivant la plateforme et la libc utilisée. Pour avoir plus d'infos, comme tu sembles utiliser windows, il faudrait creuser sur MSDN si tu trouves tes réponses, wikipedia ne présentant que les differentes stratégies sur quelques unix.

[sambia39]

En complément regardez également du coté Windows
à bientôt

[grim7reaper]

Salut,

Comme dit plus haut, impossible de te répondre avec exactitude sans avoir plus d’info.

De manière générale, un allocateur alloue toujours des métadonnées (leur localisation et leur taille dépend de l’allocateur utilisé) en plus de la mémoire que tu lui demandes.
Ici tu alloues des blocs de 8 octets, si l’allocateur alloue 8 octets de métadonnées pour chaque allocation, ça pourrait expliquer ton x2 en taille.
Est-ce que tu as toujours ce facteur de x2 en allouant des blocs de 64Ko ?

Je te donne une explication parmi d’autres (elle est peut être fausse), il faut lire la documentation de l’allocateur utilisé (je ne connais pas trop le monde Windows…) pour savoir exactement ce qu‘il se passe.

[Aspic]

Bonjour à tous,

Voilà plus d'informations :

Je compile mon programme sous GCC version 4.7.2 avec MinGW avec CodeBlocks pour être exact
Je compile en Release avec l'option -O2 pour l'optimisation.

Je ne travaille donc pas avec Visual studio et son compilateur propriétaire.

En testant avec 1024 malloc de blocs mémoire de taille 64, je devrais en théorie avoir 1024*64 = 65536 octets = 64 Ko et j'ai en mémoire en réel : 76 Ko soit une différence de 12 Ko

Avec 1024 malloc de blocs mémoire de taille 128 => 1024*128 = 131072 octets = 128 Ko. En vrai, j'ai 156 Ko d'alloué soit une différence de 28 Ko.

Je ne sais pas si on peut établir une "loi" en fonction de la taille du bloc mémoire mais en tout cas, il semble bel et bien y avoir des métadonnées allouées. Y'a t-il un moyen d'en savoir plus au niveau du code ?

Ca m'embête un peu sachant que je dois allouer 45 000 000 de chaines de caractères de taille 21 (20 octets utiles + '\0'). Je ne sais pas comment optimiser cela pour prendre le moins de mémoire possible avec GCC...

Merci

EDIT: Je viens de tester avec mes 45 000 000 de chaines de 21 octets, en théorie : 922 851Ko de mémoire et en vrai : 1 410 556 Ko, ca fait quand même une différence énorme de 487 704 Ko (476 Mo) !

[Bktero]

En complément regardez également du coté Windows
à bientôt

Extraction de la substantifique moelle de ton lien :

La fonction malloc alloue un bloc de mémoire d'au moins size octets. Le bloc peut être plus grand que size octets en raison de l'espace requis pour les informations d'alignement et de maintenance.

[sambia39]

D'accord !
C'est donc normale ?
j'avais des doutes sur mon tout premier poste. Encore un cas qui donne raison au cast de la fonction malloc
à bientôt

[Aspic]

Extraction de la substantifique moelle de ton lien :

La fonction malloc alloue un bloc de mémoire d'au moins size octets. Le bloc peut être plus grand que size octets en raison de l'espace requis pour les informations d'alignement et de maintenance.

Ouais j'avais déjà lu cela donc au final c'est mort, on ne peut rien y faire ? y'a pas une option/flag de GCC pour réduire cela ?

j'avais des doutes sur mon tout premier poste. Encore un cas qui donne raison au cast de la fonction malloc

Je n'ai pas compris, que l'on cast ou pas le retour de malloc, la quantité mémoire est la même.