Probleme de threads et de pipes

**Marc san** · 21/02/2006, 23h01

Voila mon probleme :
j'ai ecrit un programme qui envoie un message d'un nouveau type dans un pipe qui va communiquer entre le pere et le fils apres un fork.

il fonctionne, grace à une astuce que l'on m'a donné sur ce meme forum :
voici le code :

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
 
typedef struct
{
        char* message;
        int entier;
}nouveau;
 
 
 
int main()
{
 int tube[2],p;
pipe(tube);
nouveau * data;
p = fork();
if(p==0){close(tube[0]);
   data->entier = 42;
   data->message = "pouet pouet";
   write(tube[1], data, sizeof(nouveau));      
 
} else {   
   close(tube[1]);  
   read(tube[0], data, sizeof(nouveau));
   printf("%s\n",data->message);
 
} 
    return 0;
 
 
}

Le prog affiche bien "pouet pouet" ce qui montre que c bon

Ensuite, je me suis dis que puisque cette facon de faire fonctionne, je vais tester le meme programme en créant un thread dans le processus pere qui envoie et un thread dans le processus fils qui recoit :
voici le code :

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
typedef struct
{
        char* message;
        int entier;
}nouveau;
 
 int tube[2];
 
 
pthread_t env,rec;
 
void* envoyer(void* arg)
{  
   nouveau * data;
   int n;   
   printf("ici pere\n");
   close(tube[0]);
   data->entier = 42;
   data->message = "pouet pouet";   
   write(tube[1], data, sizeof(nouveau));
    printf("ici fin pere\n");  
    pthread_exit(NULL);      
}
 
 
void* recevoir(void* arg)
{   
   nouveau * data; 
   printf("ici fils\n");
   close(tube[1]);  
   if(read(tube[0], data, sizeof(nouveau))>0)
   {printf("%s\n",data->message);}
   printf("ici fin fils\n");    
   pthread_exit(NULL);  
}
 
int main()
{
int p;
pipe(tube);
p = fork();
if(p!=0){
         /*pere enoie*/
   pthread_create(&env,NULL,envoyer,NULL);
} else {   
       /*fils recoit*/
   pthread_create(&rec,NULL,recevoir,NULL);
} 
 
    return 0;    
}

seulement lorsque je l'execute, j'ai ceci :

Code :

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

1
2
3
4
 
ici pere
ici fin pere
ici fils

et il me rend la main .

Quelqu'un aurait une idée de ce qu'il faudrait modifier pour que ceci fonctionne ? ( je voudrais que le message pouet pouet soi affiché )

**Emmanuel Delahaye** · 21/02/2006, 23h19

Envoyé par Marc san

Quelqu'un aurait une idée de ce qu'il faudrait modifier pour que ceci fonctionne ?

Je vois des tas de pointeurs jamais initialisés. Comportement indéfini... En plus, le mélange fork() + pthread(), c'est chaud...

http://emmanuel-delahaye.developpez.com/pthreads.htm

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
 
#define N(a) (sizeof (a) / sizeof * (a))
 
typedef struct
{
   char const* message;
   int entier;
}
nouveau;
 
struct tube
{
   void *a[4];
   size_t r;
   size_t w;
   unsigned full:1;
   unsigned empty:1;
};
 
 
static void tube_init(struct tube *this)
{
   this->empty = 1;
}
 
static void tube_put(struct tube *this, void *p)
{
   this->a[this->w] = p;
   this->w++;
   if (this->w == N(this->a))
   {
      this->w = 0;
   }
   this->full = this->r == this->w;
   this->empty = 0;
}
 
static void *tube_get(struct tube *this)
{
   void *p = this->a[this->r];
   this->r++;
   if (this->r == N(this->a))
   {
      this->r = 0;
   }
   this->full = 0;
   this->empty = this->r == this->w;
 
   return p;
}
 
static void* envoyer(void* arg)
{
   struct tube *tube = arg;
 
   if (tube != NULL)
   {
      printf("ici pere\n");
      {
         nouveau *data ;
 
         data = malloc(sizeof * data);
         if (data != NULL)
         {
            data->entier = 42;
            data->message = "pouet pouet";
            {
               /* put in the tube */
               tube_put(tube, data), data = NULL;
            }
         }
 
         data = malloc(sizeof * data);
         if (data != NULL)
         {
            data->entier = 123;
            data->message = "hello world";
            {
               /* put in the tube */
               tube_put(tube, data), data = NULL;
 
            }
         }
 
      }
      printf("ici fin pere\n");
 
   }
   return NULL;
}
 
static void* recevoir(void* arg)
{
   nouveau * data = NULL;
   printf("ici fils\n");
   {
      struct tube *tube = arg;
 
      if (tube != NULL)
      {
         while (!tube->empty)
         {
            /* get from the tube */
            data = tube_get (tube);
 
            if (data != NULL)
            {
               printf ("message = '%s' entier = %d\n"
                       , data->message
                       , data->entier);
 
               free (data), data = NULL;
            }
         }
      }
   }
   printf("ici fin fils\n");
   return NULL;
}
 
int main()
{
   pthread_t env, rec;
 
   /* ADT bienvenu... */
   static struct tube tube;
   tube_init(&tube);
 
   /*pere envoie*/
   pthread_create(&env, NULL, envoyer, &tube);
 
   /*fils recoit*/
   pthread_create(&rec, NULL, recevoir, &tube);
 
   pthread_join(env, NULL);
   pthread_join(rec, NULL);
 
   return 0;
}

qui donne

Code :

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

1
2
3
4
5
6
7
 
ici pere
ici fin pere
ici fils
message = 'pouet pouet' entier = 42
message = 'hello world' entier = 123
ici fin fils

**granquet** · 21/02/2006, 23h25

tu dois "synchroniser" tes threads en utilisant des mutex.

en gros:

Code :

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

1
2
3
4
5
6
 
pthread_mutex_t fils_mtex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t fils_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_lock (&fils_mtex);
pthread_create (&filsthread, 0, fonctionfils, NULL);
pthread_cond_wait (&fils_cond, &fils_mtex); //on reste bloqué ici jusqua ce que le fils unlock le mutex.

et tu debloque le tout en balancant quelque chose de ce style dans le fils.

Code :

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

1
2
3
 
	pthread_mutex_unlock (&fils_mtex);
	pthread_cond_broadcast (&fils_cond);

c'est un exemple. j'ai lut en diagonnale, tu vas sans doute devoir l'adapter a ton code.

**hegros** · 22/02/2006, 00h14

Pas besoin de rajouter un mutex pour la synchronisation. Un pipe est une IPC elle permet non seulement de communiquer mais aussi de se synchroniser.

Un read sur un pipe vide est bloquant tout comme un write sur un pipe plein est bloquant. Ce qui signifie que tant que y'a rien d'écrit dans le pipe (pipe vide)le process lecteur est sensé "attendre" que quelque chose soit dedans.

La lecture et l'ecriture dans un pipe est atomique.

**Marc san** · 22/02/2006, 00h44

Envoyé par hegros

Pas besoin de rajouter un mutex pour la synchronisation. Un pipe est une IPC elle permet non seulement de communiquer mais aussi de se synchroniser.

Un read sur un pipe vide est bloquant tout comme un write sur un pipe plein est bloquant. Ce qui signifie que tant que y'a rien d'écrit dans le pipe (pipe vide)le process lecteur est sensé "attendre" que quelque chose soit dedans.

La lecture et l'ecriture dans un pipe est atomique.

Donc ca voudrait dire que le probleme viens du write ( qui ne veux pas ecrire ) dans mon 2é code ?
(ca pourrait alors expliquer pourquoi le thread du processus fils n'a pas l'air de se terminer )

PS: désolé si mes questions parraissent un peu betes, mais j'ai debuté le c y quelques mois et je maitrise pas encore toutes les subtilités des différentes fonctions

**hegros** · 22/02/2006, 01h15

Tu ferais bien déja de rajouter les pthread_join à la fin de ton programme.

Après ça de fais peux-être reçois tu le signal SIGPIPE ce qui termine ton process fils ? Ce qui au vu du code me paraît pas impossible...

**Marc san** · 22/02/2006, 22h31

Merci ! oui j'avais oublié les pthread_join !!

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
typedef struct
{
        char* message;
        int entier;
}nouveau;
 
 int tube[2];
 
 
pthread_t env,rec;
 
void* envoyer(void* arg)
{  
 
   nouveau * data;
   int n;   
   printf("ici pere\n");
   close(tube[0]);
   data->entier = 42;
   data->message = "pouet pouet";   
   write(tube[1], data, sizeof(nouveau));
    printf("ici fin pere\n");  
    pthread_exit(NULL);      
}
 
 
void* recevoir(void* arg)
{   
   nouveau * data; 
   printf("ici fils\n");
   close(tube[1]);  
   if(read(tube[0], data, sizeof(nouveau))>0)
   {printf("%s\n",data->message);}
   printf("ici fin fils\n");    
   pthread_exit(NULL);  
}
 
int main()
{
int p;
pipe(tube);
p = fork();
 
if(p!=0){
         /*pere enoie*/
   pthread_create(&env,NULL,envoyer,NULL);
   pthread_join(env,NULL);
} else {   
       /*fils recoit*/
   pthread_create(&rec,NULL,recevoir,NULL);
   pthread_join(rec,NULL);
} 
 
    return 0;    
}

et j'ai bien :

Code :

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

1
2
3
4
5
6
 
ici pere
ici fils pere
ici fils
pouet pouet
ici fin fils

**hegros** · 22/02/2006, 22h32

Ton mutex c'est pour faire beau ?

Probleme de threads et de pipes

C

Discussions similaires

Partager

Partager