Pthread terminés restent en mémoire, conduisant à une Seg Fault [Résolu]

[truboy]

Bonjour,

Je développe actuellement une application en C++, tournant sur une carte SBC9261, sous Linux 2.6.24.

Cette application est chargée de communiquer sur le bus CAN (bus de terrain très utilisé dans l'automobile) avec d'autres systèmes.

Pour cela, j'ai mis en place dans mon programme deux phtreads : l'un s'occupe de "lire" les messages arrivant sur le CAN. Si un message est lu, il lance un second pthread qui lui va s'occuper de traiter la trame CAN reçue. Ainsi, il est possible de traiter une trame tout en en réceptionnant une autre, ce qui peut-être nécessaire lorsque le traitement d'une trame demande d'autres informations sur le bus CAN.

Voici le code (simplifié) de la routine du premier thread (la réception) :

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
void *canRead(void *arg) {
 
    struct can_frame frameRecv;
    unsigned int i;
    pthread_attr_t attr;
    pthread_t threadHandler;
 
    // P. thread attribute
    pthread_attr_init(&attr);
    pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
 
    while(1) {
 
        // Init frame
        memset(&frameRecv, 0, sizeof(struct can_frame));
 
        // Read from CAN
        read(canDevice, &frameRecv, sizeof(struct can_frame));
 
        // Threading to be able to receive while handling requests
        // pthread_create() prototype : int pthread_create(pthread *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg_of_routine);
	if (pthread_create(&threadHandler, &attr, canHandler, &frameRecv)) {
            perror("pthread_create");
            exit(-1);
        }
 
        // Sleep for a while
        usleep(50*1000);
    }
}

canHandler est la routine qui s'occupe du traitement de la trame. Elle ne contient pas de boucle infinie et s'exécute en 3 secondes, dans le pire des cas.

Tout ceci fonctionne sans problème, du moins les 15 premières minutes. Un problème survient ensuite :

Les threads canHandler semblent rester en mémoire après leur exécution, car la mémoire système décroît jusqu'à entraîner une Segmentation Fault.

Si je retire le pthread_create(), l'appli peut tourner indéfiniment sans dépasser les 17% d'occupation mémoire.

Le manuel de pthread_create() donne un exemple qui traite de la mémoire.

En gros, ça donne :

Code :

1
2
3
4
5
6
7
void *res;
 
/*Création de threads ici...*/
 
pthread_join(<un_thread>, &res);
 
free(res);      /* Free memory allocated by thread */

N'ayant pas à exécuter de pthread_join(), comment pourrais-je initialiser le pointeur res ou utiliser la fonction free(), pour stopper ces fuites de mémoires ?

Toutes autres suggestions sont les bienvenues !

Merci pour votre aide !

[matafan]

Si tu ne veux pas faire de pthread_join(), il faut que tu créé un thread "détaché" en utilisant pthread_attr_setdetachstate().

La totalité des ressources d'un "joinable thread" (c'est le cas par défaut) n'est libérées que sur le pthread_join(). La totalité des ressources d'un "detached thread" est libérée automatiquement dès que le thread termine.

[truboy]

Wow ! Grand merci, ça fonctionne !
Moi qui m'attendais à passer encore quelques jours là-dessus !

Encore merci, joyeuses fêtes !