thread et "fuite mémoire"

**ChriGoLioNaDor** · 03/03/2006, 23h24

Bonjour,

J'ai un problème de fuite mémoire, lors de la création de mon thread (ou de son éxécution)... j'utilise un pthread_create (...), et je pense que le problème vient du premier paramètre (de type pthread_t&).

Voici ce que me donne Valgrind :

==9545== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 8 from 5)
==9545== malloc/free: in use at exit: 136 bytes in 1 blocks.
==9545== malloc/free: 34 allocs, 33 frees, 9989 bytes allocated.
==9545== For counts of detected errors, rerun with: -v
==9545== searching for pointers to 1 not-freed blocks.
==9545== checked 8618120 bytes.
==9545==
==9545== 136 bytes in 1 blocks are possibly lost in loss record 1 of 1
==9545== at 0x11B1D1FD: calloc (vg_replace_malloc.c:279)
==9545== by 0x1190D379: allocate_dtv (dl-tls.c:306)
==9545== by 0x1190D64D: _dl_allocate_tls (dl-tls.c:459)
==9545== by 0x11C366A4: pthread_create@@GLIBC_2.2.5 (allocatestack.c:502)
==9545== by 0x406A55: LoginServer::start() (in /home/helldream/LoginServer/LoginServer)
==9545== by 0x40707B: main (in /home/helldream/LoginServer/LoginServer)
==9545==
==9545== LEAK SUMMARY:
==9545== definitely lost: 0 bytes in 0 blocks.
==9545== possibly lost: 136 bytes in 1 blocks.
==9545== still reachable: 0 bytes in 0 blocks.
==9545== suppressed: 0 bytes in 0 blocks.

J'ai lu un article parlant de désalouer un handle, un fois le thread terminé, mais je ne sais pas comment... :S

Quelqu'un aurait-il une idée? (à noter que procédure appelée par le thread est totalement vide)

**SteelBox** · 03/03/2006, 23h50

Tu peux déjà vérifier si pthread_exit() est bien appelé. Sinon, tu devrais donner le code correspondant à l'appel de pthread_create().

The thread is created executing start_routine with arg as its sole argument. If the start_routine returns, the effect is as if there was an implicit call to pthread_exit() using the return value of start_routine as the exit status.

**ChriGoLioNaDor** · 04/03/2006, 01h21

Je te donne ca de suite

Code de l'objet voulant créer un thread :

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
	pthread_t		test2;
	struct thread_param2	p2;
...
	pthread_create (&test2,NULL,threadClient2,&p2);
 
	char saisie;
 
	while (this->isrunning())
	{
		cin >> saisie;
		if (saisie == 'e')
		{
			pthread_join(test2, NULL);
			this->stop();
		}
	}

Et le code de threadClient2 :

Code :

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

1
2
3
4
void* threadClient2 (void* arg)
{
//	struct thread_param2 *p2 = reinterpret_cast<struct thread_param2*>(arg);
}

Et pour finir, ma structure créée (thread_param2) :

Code :

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

1
2
3
struct thread_param2{
       LoginServer* ser;
};

**SteelBox** · 05/03/2006, 00h56

A première vue, je ne vois pas de fautes. J'essais ton code demain

**SteelBox** · 05/03/2006, 15h13

J'ai refait un programme et j'obtiens les mêmes résultats :

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
 
/* hellothread.c
 
This program creates a thread which performs an addition based on a counter.
The main thread operates also on the counter. The counter is a global variable.*/
 
/* includes */
#include <stdio.h>
#include <pthread.h>
 
/* Functions declarations */
void addition();
 
/* Global variables */
int i;                         /* counter for the addition */
 
int main()
{
	/* Variables */
	pthread_t thread_id;         /* pointer to address of threads ids */
 
	/* Initialization */
	i = 0;
 
	/* Create a thread */
	if (pthread_create(&thread_id, NULL,(void *(*)())addition, NULL) == -1)
    {
		perror("Unable to create the thread");
    }
 
	/* Addition in the main thread */
	i += 1000;
	printf("Hello main thread, i is: %d\n", i);
	i += 2000;
	printf("Hello main thread, i is: %d\n", i);
 
	/* Wait for the secondary thread to terminate */
	pthread_join(thread_id, NULL);
 
	return 0;
}
 
void addition()
{
	i += 10;
	printf("Hello secondary thread, i is: %d\n", i);
	i += 20;
	printf("Hello secondary thread, i is: %d\n", i);
}

Résultats :

==17848== Memcheck, a memory error detector.
==17848== Copyright (C) 2002-2005, and GNU GPL'd, by Julian Seward et al.
==17848== Using LibVEX rev 1471, a library for dynamic binary translation.
==17848== Copyright (C) 2004-2005, and GNU GPL'd, by OpenWorks LLP.
==17848== Using valgrind-3.1.0, a dynamic binary instrumentation framework.
==17848== Copyright (C) 2000-2005, and GNU GPL'd, by Julian Seward et al.
==17848== For more details, rerun with: -v
==17848==
Hello secondary thread, i is: 10
Hello main thread, i is: 1010
Hello main thread, i is: 3010
Hello secondary thread, i is: 3030
==17848==
==17848== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 13 from 1)
==17848== malloc/free: in use at exit: 68 bytes in 1 blocks.
==17848== malloc/free: 1 allocs, 0 frees, 68 bytes allocated.
==17848== For counts of detected errors, rerun with: -v
==17848== searching for pointers to 1 not-freed blocks.
==17848== checked 92,500 bytes.
==17848==
==17848== LEAK SUMMARY:
==17848== definitely lost: 68 bytes in 1 blocks.
==17848== possibly lost: 0 bytes in 0 blocks.
==17848== still reachable: 0 bytes in 0 blocks.
==17848== suppressed: 0 bytes in 0 blocks.
==17848== Use --leak-check=full to see details of leaked memory.

Je ne sais pas d'ou vient la fuite des 68 bytes

**ChriGoLioNaDor** · 05/03/2006, 16h30

En effet, j'ai continué à chercher, et j'ai tenté de tester ton programme, et j'ai exactement la même fuite... Et rien n'en faisant référence sur google.

Si quelqu'un a une idée ou une piste, il est le bienvenu :S

**ChriGoLioNaDor** · 06/03/2006, 10h45

Personne n'a d'idée?

**SteelBox** · 06/03/2006, 12h35

Il serait peut être intéressant de comparer les résultats avec un autre outil de détection de fuites mémoires...

**boromir73** · 06/03/2006, 13h54

Quelle est la valeur retournée par pthread_join (normalement c'est non nul s''il y a une erreur) ?

La fonction addition doit retourner void * (et non void). D'après la documentation, cela se fait par un appel à pthread_exit, nécessaire (dans la fonction addition) pour terminer le thread.

**Médinoc** · 06/03/2006, 13h56

Ben non, si la fonction du thread retourne, pas besoin de pthread_exit().
D'ailleurs, c'est plus propre.

**boromir73** · 06/03/2006, 14h01

Quand faut-il utiliser pthread_exit alors ?

**Médinoc** · 06/03/2006, 14h06

Jamais.

Ou à la fin du main(), si le main() est supposé se terminer avant les autres threads.

(Enfin, je suis un peu extrémiste, mais je suis contre toute utilisation de fonction de type exit()/ExitProcess() dans un programme, et contre toute utilisation de pthread_exit()/ExitThread() en dehors qu'à la fin du main().
Pour moi, tout thread (ou tout processus mono-threadé) se termine au retour de sa fonction principale.)

**boromir73** · 06/03/2006, 14h15

Bon...

Néanmoins, la fonction est censée retourner une valeur. C'est peut-être ce qui manque dans les programmes précédents ?

**SteelBox** · 06/03/2006, 19h43

Je suis tout à fait d'accord Médinoc

Sinon, j'avais ajouter un return dans threadClient2 mais ca n'avait rien changé...

**ChriGoLioNaDor** · 06/03/2006, 23h40

La fonction pthread_join() retourne bien 0, j'ai fait le test.

A noter que si on enlève le pthread_join() du main, et donc que le thread est interrompu par la fin du programme, on n'a aucune fuite mémoire supplémentaire (alors que là, le thread ne devrait pas être totalement détruit...). Et biensûr, si on enlève le pthread_create(), on n'a plus de fuite mémoire

Dernier point, si on crée 2 threads, la fuite mémoire est bien doublée. Ca ne semble donc pas être un espace mémoire réservé à la gestion des threads, comme il y a pour les String (à ce que j'ai lu).

Toujours est-il que le mystère est toujours entier. D'autres idées?