thread et "fuite mémoire"

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 :

Citation:

---

==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)

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

Citation:

---

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.

---

Je te donne ca de suite :)

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

Code:

---

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:

---

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:

---

1 2 3

struct thread_param2{ LoginServer* ser; };

---

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

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

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

/* 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 :

Citation:

---

==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 :?

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

Personne n'a d'idée?

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

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.

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

Quand faut-il utiliser pthread_exit alors ?

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.)

Bon...

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

Je suis tout à fait d'accord Médinoc :D

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

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?

Vous connaissez d'autres outils pour détecter les fuites mémoire ?

Personnellement, non, aucun :S

Up du soir, up plein d'espoir ^^

Toujours personne? Ne me dites pas que personne n'utilise de thread, ou que personne qui en utilise a remarqué ce problème.... :S