Bonjour à tous,

Je poste après avoir cherché longuement sur le Net une réponse à mon problème.

J'ai écrit un petit programme qui se charge de lancer un thread au démarrage puis il alloue des matrices, tableau 2D. Un petit calcul de sommation est ensuite réalisé, puis les matrices sont désallouées. Or, quand je regarde un top ou un moniteur système la mémoire n'est pas effectivement libérée.

J'ai pratiqué plusieurs tests. Le premier est de ne pas lancer le thread et d'utiliser mtrace pour voir s'il n'y a pas de fuite mémoire. Réponse : y en a pas.
La mémoire est également bien libérée sans lancer le thread.

Lorsque je procède à un autre test en lançant cette fois-ci le thread, la mémoire est bien désallouée puisque si le programme refait une allocation il ne demande pas de mémoire supplémentaire au système. Par observation avec top. Par contre si je ne désalloue pas la mémoire et demande une réallocation à ce moment là, j'ai une fuite mémoire puisque de nouvelles ressources mémoires sont prises au système

J'ai également essayé sur d'autres plateformes, d'autres compilateurs, d'autres noyaux. Sur ces autres plateformes, la mémoire est bien rendu au système. Après réflexion, la seule différence entre ces plateformes et celle où le problème réside est le 64 bits (plusieurs plateforme de tests en 64 bits, en fait). En effet, la mémoire est bien désallouée en 32 bits, même sur une plateforme 64bits avec compilation avec gcc -m32.

J'espère avoir été clair et complet. Je joins le bout de code ci-dessous. Soit j'ai fait une erreur fondamentale, soit quelque chose m'échappe.

Merci d'avance pour vos lanternes.


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
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
 
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
 
void sum(double** A, double **B, int block_size)
{
	int i,j;
 
	for(i=0; i < block_size; i++)
	  for(j=0 ; j < block_size; j++)
		A[i][j]=A[i][j]+B[i][j];
}
 
void read_mat(double ***matrix, int block_size)
{
	int i,j;
 
	*matrix=malloc(block_size*sizeof(double*));
 
	for(i=0; i< block_size; i++)
	{	
		(*matrix)[i]=malloc(block_size*sizeof(double));
		for(j=0; j < block_size; j++)
			(*matrix)[i][j]=1.0;
	}
}
 
void free_mat(double **matrix, int block_size)
{
	int i;
 
	for(i=0; i< block_size; i++)
             free(matrix[i]);
	free(matrix);
 
 
}
 
void * launch(void* pthis)
{
	printf("hoho thread\n");
 
        pthread_exit(0);
}
 
 
 
int main( int argc, char **argv )
{
    int block_size=10000;
    double **A;
    double **B;
    void* status;
    pthread_t th;
 
    pthread_create(&th,NULL,launch,NULL);
 
    printf("Alloc\n");
    read_mat(&A,block_size);
    read_mat(&B,block_size);
 
    pthread_join(th,&status);
 
    sum(A,B,block_size);
 
    printf("%f\n",A[0][0]);
 
    sleep(5);
 
    printf("Clear\n");
    free_mat(A,block_size);
    free_mat(B,block_size);
 
    sleep(5);
 
  pthread_exit(NULL) ;
}