pointeur de fonction et pthread

**bioinfornatics** · 16/03/2009, 09h41

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 :

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
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;
}

**Emmanuel Delahaye** · 16/03/2009, 18h04

Envoyé par bioinfornatics

Bonjour,
voila je bloque bêtement sur cette partie de code

C'est à dire ? Tu ne comprends pas les messages ?

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
 
 
-------------- Build: Debug in hello ---------------
 
Compiling: main.c
Linking console executable: bin\Debug\hello.exe
C:\dev\hello\main.c: In function `processus':
C:\dev\hello\main.c:36: error: parameter name omitted
C:\dev\hello\main.c: In function `generateur_de_processus_legers':
C:\dev\hello\main.c:55: error: syntax error before "pthread_t"
C:\dev\hello\main.c:57: error: `id_Processus' undeclared (first use in this function)
C:\dev\hello\main.c:57: error: (Each undeclared identifier is reported only once
C:\dev\hello\main.c:57: error: for each function it appears in.)
C:\dev\hello\main.c:57: warning: implicit declaration of function `malloc'
C:\dev\hello\main.c:57: error: `nbProcessus' undeclared (first use in this function)
C:\dev\hello\main.c:62: error: syntax error before ')' token
C:\dev\hello\main.c: At top level:
C:\dev\hello\main.c:50: warning: unused parameter 'fonction'
C:\dev\hello\main.c: In function `generateur_de_processus_legers':
C:\dev\hello\main.c:62: warning: value computed is not used
C:\dev\hello\main.c: At top level:
C:\dev\hello\main.c:73: error: syntax error before "pthread_mutex_unlock"
C:\dev\hello\main.c:73: warning: type defaults to `int' in declaration of `pthread_mutex_unlock'
C:\dev\hello\main.c:73: warning: function declaration isn't a prototype
C:\dev\hello\main.c:73: warning: 'pthread_mutex_unlock' redeclared without dllimport attribute after being referenced with dllimport linkage
C:\dev\hello\main.c:73: error: ISO C forbids data definition with no type or storage class
Process terminated with status 1 (0 minutes, 0 seconds)
9 errors, 6 warnings

Ceci compile :

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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
/**
 * \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/>.
 */
 
/* gestion des processus léger */
#include <pthread.h>
/* pour les fonctions avec un nombre variable d'argument */
#include <stdarg.h>
 
#include <stdlib.h>
 
/**< declaration du verrou */
pthread_mutex_t 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 *user)
{
/**< 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_lock (&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;
/**< Déclaration d'une variable type va_list                                           */
   va_list arg_ptr;
/**< Initialisation du compteur                                                         */
   short i = 0;
/**< Initialisation du pointeur vers les arguments                                      */
   va_start (arg_ptr, nb_de_processus);
   {
/**< Identifiant unique du processus                                                    */
      pthread_t *id_Processus;
 
      id_Processus = malloc (nb_de_processus * sizeof (pthread_t));
/**< Allocation memoire permettant de recuperer tous les "id" des processus legers      */
 
/**< Initialisation du mutex                                                            */
      pthread_mutex_init (&verrou, NULL);
/**< Verrouillage du mutex                                                              */
      pthread_mutex_lock (&verrou);
 
/**< Récupérer chaque argument de la liste variable                                   */
      for (i = 0; i < nb_de_processus; i++)
      {
/**< Creation du processus legers                                                       */
         fonction = va_arg (arg_ptr, void *);
         pthread_create (&id_Processus[i],
/**< Id du processus leger                                                              */
                         NULL,
/**< Attribut du processus                                                              */
                         processus,
/**< Fonction                                                                           */
                         fonction);
/**< Parametres de la fonction                                                          */
 
      }
 
/**< Quitte la macro                                                                    */
      va_end (arg_ptr);
      pthread_mutex_unlock (&verrou);
/**< Deverrouillage du mutex -> debloquage des processus legers                         */
 
/**< Attente de la terminaison                                                          */
      for (i = 0; i < nb_de_processus; i++)
      {
         pthread_join (id_Processus[i], NULL);
/**< des processus legers                                                               */
 
      }
   }
   return 0;
}

Attention, si 'fonction' désigne un pointeur de fonction, le type void* ne convient pas.

**bioinfornatics** · 16/03/2009, 19h47

ah oui en effet c'était bête comme soucis.
bon je vais lancer quelques jeu de test.
Je te remercie pour ton aide

pointeur de fonction et pthread

C

Discussions similaires

Partager

Partager