pointeur de fonction et pthread
Bonjour,
voila je bloque bêtement sur cette partie de code
je souhaite créer une fonction recevant un nombre variable de fonction pour les lancer dans plusieurs thread et attendre la fin de toutes les fonctions (synchronisation)
je vous remercie par avance
contenu du fichier: processus_leger.c
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
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
79
80
81
| /**
* \file processus_leger.c
* \brief Programme.
* \author Jonathan MERCIER
* \version 1.0
* \date 01 mars 2009
*
*
* LICENSE:
* Copyright (C) <2009-2010> <MERCIER Jonathan>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <pthread.h> /* gestion des processus léger */
#include <stdarg.h> /* pour les fonctions avec un nombre variable d'argument */
pthread_mutex_t verrou; /**< declaration du verrou */
/**
* \brief Fonction executee par un processus leger, pour empécher au processus de commencer.
* \fn void *processus ( void * )
* Cette fonction permet d'attendre la création de tous les processus pour les éxécuter en même temps
*/
void *processus ( void * )
{
pthread_mutex_lock (&verrou); /**< Essai de verrouillage de la variable mutex le processus léger sera bloqué jusqu'à la disponibilité le processus léger sera bloqué jusqu'à la disponibilité du verrou */
pthread_mutex_unlock (&verrou);
return NULL;
}
/**
* \brief creation des processus legers.
* \fn int generateur_de_processus_legers(short nb_de_processus, void *fonction, ..)
* \param reçoit en argument les fonctions à lancer ensemble dans un processus léger
*/
int generateur_de_processus_legers(short nb_de_processus, void *fonction, ...)
{
va_list arg_ptr; /**< Déclaration d'une variable type va_list */
short i = 0; /**< Initialisation du compteur */
va_start(arg_ptr, nb_de_processus) /**< Initialisation du pointeur vers les arguments */
pthread_t *id_Processus; /**< Identifiant unique du processus */
id_Processus = (pthread_t *) malloc (nbProcessus * sizeof(pthread_t)); /**< Allocation memoire permettant de recuperer tous les "id" des processus legers */
pthread_mutex_init (&verrou, NULL); /**< Initialisation du mutex */
pthread_mutex_lock (&verrou); /**< Verrouillage du mutex */
for (i = 0, i < nb_de_processus; i++) /**< Récupérer chaque argument de la liste variable */
{
/**< Creation du processus legers */
pthread_create ( &id_Processus[i] /**< Id du processus leger */
NULL, /**< Attribut du processus */
processus, /**< Fonction */
fonction = va_arg(arg_ptr, void) ); /**< Parametres de la fonction */
}
va_end(arg_ptr) /**< Quitte la macro */
pthread_mutex_unlock (&verrou); /**< Deverrouillage du mutex -> debloquage des processus legers */
for ( i = 0; i < nb_de_Processus; i++) /**< Attente de la terminaison */
{
pthread_join(id_Processus[i], NULL); /**< des processus legers */
}
return 0;
} |
