problèmes avec un programme multi threads sous linux

**Xtatic** · 10/02/2006, 23h18

Bonjour,
Je me suis mis récemment à programmer en C sous linux, et j'ai écris (et recopié certain passages, comme les déclarations de sémaphores et de threads) ce programme :

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
 
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>
#define MAX 100
 
sem_t mutex, vide, plein;
char tampon[MAX];
pthread_t tid[2];
 
void* proc(void* i);
 
int main()
{
   int i;
 
   sem_init(&mutex, 0, 1);
   sem_init(&vide, 0, MAX);
   sem_init(&plein, 0, 0);
 
   for(i = 0; i<2; i++)
      pthread_create(tid + i, NULL, (void*(*)())proc, (void*) i );
 
   for(i = 0; i<2; i++)
      pthread_join(tid[i], (void*)i);
 
   return 0;
}
 
void* proc(void* i)
{
   int rep;
   int positionLecteur = 0;
   int positionEcrivain = 0;
 
   if(i==0)
   { // thread Lecteur
      do
      {
         sem_wait(&plein);
         sem_wait(&mutex);
 
         rep = write(STDOUT_FILENO, &tampon[positionLecteur], 1);
 
         sem_post(&mutex);
         sem_post(&vide);
      }while( rep != 0);
 
   else
   { // thread ecrivain
      do
      {
          sem_wait(&vide);
          sem_wait(&mutex);
 
          rep = read(STDIN_FILENO, &tampon[positionEcrivain], 1);
 
          sem_post(&mutex);
          sem_post(&plein);
       }while( rep != 0) ;
    }
    return NULL;
}

Donc ce programme est censé, une fois lancé, afficher à l'écran les chaine de caracteres qu'on tape.
Il marche parfaitement sous KDE (je ne m'y connais pas trop sur linux, mais je sais que c'est une distrib debian).

Je l'ai testé sur mon portable, sur lequel j'ai installé Ubuntu (une distrib issue de Debian). La compilation ne génère ni erreur, ni warning, et le programme se lance sans planté. Mais aucun caractere ne s'affiche lorsque j'en tape au clavier.

J'ai demandé à un ami qui utilise Sygwin de le tester. Le programme génère une segmentation fault chez lui.

Et pour finir, une autre personne (mais je ne sais pas quelle version de linux elle a utilisé) a tenté de le compiler. Là, des erreurs générées dues à la conversion void* en void** (ou le contraire, je ne sais pas...).
Et après quelques corrections, elle est parvenue à lancer le programme, mais comme sur mon portable, aucun caractère ne s'affiche (mis à par la chaine qu'on vient juste d'écrire bien sur).

De plus , en écrivant le code sur ce forum, je me rends compte d'une chose : la lettre 'i' est utilisée comme compteur de boucle , mais elle est aussi utilisée dans la définition et la déclaration de la fonction proc. Ca me parait louche...

Derniere remarque : j'ai utilisé un do_ while avec comme condition rep!=0 . Je ne suis pas sur que ce soit trés utile. Sur les pc de mon école (là où le programme fonctionne) un do _ while (1) marche trés bien aussi.

Quelqu'un pourrait il m'éclairer un peu? Car je suis complétement perdu.
Merci beaucoup.

**Emmanuel Delahaye** · 11/02/2006, 00h46

Envoyé par Xtatic

Je me suis mis récemment à programmer en C sous linux, et j'ai écris (et recopié certain passages, comme les déclarations de sémaphores et de threads) ce programme :

Je ne comprend pas pourquoi tu ne crées pas 2 fonctions différentes ?

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
 
void* Lecteur(void* i)
{
   int rep;
   int position = 0;
 
      do
      {
         sem_wait(&plein);
         sem_wait(&mutex);
 
         rep = write(STDOUT_FILENO, &tampon[positionLecteur], 1);
 
         sem_post(&mutex);
         sem_post(&vide);
      }while( rep != 0);
    return NULL;
}

et

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
 
void* Ecrivain(void* i)
{
   int rep;
   int position = 0;
      do
      {
          sem_wait(&vide);
          sem_wait(&mutex);
 
          rep = read(STDIN_FILENO, &tampon[position], 1);
 
          sem_post(&mutex);
          sem_post(&plein);
       }while( rep != 0) ;
    return NULL;
}

avec

Code :

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

1
2
3
 
      pthread_create(tidEcr, NULL, procEcrivain, NULL);
      pthread_create(tidLec, NULL, procLecteur, NULL);

etc.

Ce serait nettement plus clair, non ?

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

**Médinoc** · 11/02/2006, 00h58

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
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>
#define MAX 100
 
sem_t mutex, vide, plein;
char tampon[MAX];
pthread_t tid[2];
 
/* Médinoc: On remplace "i" par un nom plus explicite */
void* proc(void* pv);
 
int main()
{
	int i;
 
	sem_init(&mutex, 0, 1);
	sem_init(&vide, 0, MAX);
	sem_init(&plein, 0, 0);
 
	/* Médinoc:
		Normalement, Le premier cast est inutile.
		Si ça refuse, c'est que les fonctions sont mal déclarées
 
	for(i = 0; i<2; i++)
		pthread_create(tid + i, NULL, (void*(*)())proc, (void*) i );
	*/
	for(i = 0; i<2; i++)
		pthread_create(tid + i, NULL, proc, (void*) i );
 
	/* Médinoc:
		La segfault est sans doute ici.
		Puisque tu te moques de la valeur de retour, autant passer NULL.
	for(i = 0; i<2; i++)
		pthread_join(tid[i], (void*)i);
	*/
	for(i = 0; i<2; i++)
		pthread_join(tid[i], NULL);
 
	return 0;
}
 
 
/* Médinoc: On remplace "i" par un nom plus explicite */
void* proc(void* pv)
{
	/* Médinoc: On met i à l'intérieur: un vrai entier à présent */
	int const i = (int)pv;
 
	int rep;
	int positionLecteur = 0;
	int positionEcrivain = 0;
 
	/* Médinoc:
		Le read() et le write() prètent à confusion, sans commentaires
		*/
 
	if(i==0)
	{ // thread Lecteur
		do
		{
			sem_wait(&plein);
			sem_wait(&mutex);
 
			/* Lit un caractère du buffer et l'envoit sur la sortie
			Médinoc:
				Il doit manquer un truc, ici...
				posotionLecteur n'est jamais augmenté...
			 */
			rep = write(STDOUT_FILENO, &tampon[positionLecteur], 1);
 
			sem_post(&mutex);
			sem_post(&vide);
		}while( rep != 0);
		/* Médinoc: Tu avais oublié un }, ici */
	}
	else
	{ // thread ecrivain
		do
		{
			sem_wait(&vide);
			sem_wait(&mutex);
 
			/* Reçoit le un caractère de l'entrée et l'écrit dans le buffer
			Médinoc:
				Il doit manquer un truc, ici...
				positionEcrivain n'est jamais augmenté...
			 */
			rep = read(STDIN_FILENO, &tampon[positionEcrivain], 1);
 
			sem_post(&mutex);
			sem_post(&plein);
		}while( rep != 0) ;
	}
	return NULL;
}

Edit: Raah Post croisé avec Emmanuel...

**Xtatic** · 11/02/2006, 15h31

Merci pour vos réponses.

A Emmanuel : C'est vrai que faire deux fonctions disctinces est vraiment plus clair. Je ne l'ai pas fait car c'est la premiere fois que j'utilise des threads, et c'est cette construction que j'ai betement recopiée..

A Médinoc : Concernant l'incrémentation de positionLecteur et posEcrivain, j'ai oublié d'écrire

Code :

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

posEcrivain = (posEcrivain + 1) % MAX ;

Idem pour le lecteur.

Ces lignes comme le } oublié sont bien présent sur mon code source (j'ai pas pu faire de copié collé, j'ai tout retapé en commettant ces erreurs).

A propos du i renommé en pv : pv c'est pour "pointeur sur valeur"?

Je ne comprends pas les void* ou void** ( void étant utilisé pour une fonction sans retour, un pointeur de quelque chose qui n'est pas là, j'ai vraiment beaucoup de mal à l'appréhender) .

Par contre, l'argument passé à proc étant un void* je comprends l'utilité du cast : i = (int) pv

Voila le synopsis de pthread_create donné dans son man :

int pthread_create(pthread_t * thread, pthread_attr_t * attr, void *
(*start_routine)(void *), void * arg);

donc si je comprends bien, on nous oblige à ce que les start_routine (dans mon programme la fonction proc ) aient un void* comme argument.

Et void * (*start_routine) indique qu'on doit passé à pthread_create ce que pointe la fonction start_routine, sur quoi on fait un cast en void* . C'est bien ça?

Dans mon programme, il y a (void*(*) ( ) ) proc . Tu as parlé de premier cast inutile si la fonction est correctement définie. Quel est le premier cast, et quel est le deuxième?

est ce que (void* (*) ( ) ) proc est la même chose que (void*) (*proc) ?

enfin dernier point : read( ) et write ( ) sont pour moi assez confus ^^ mais je pense que je m'y pencherai lorsque j'aurai mieux compris les threads

**Médinoc** · 11/02/2006, 16h57

Envoyé par Xtatic

A propos du i renommé en pv : pv c'est pour "pointeur sur valeur"?

Non, c'était pour "pointeur sur void"

Je ne comprends pas les void* ou void** ( void étant utilisé pour une fonction sans retour, un pointeur de quelque chose qui n'est pas là, j'ai vraiment beaucoup de mal à l'appréhender) .

Le void * est un "pointeur générique" : C'est à dire, un pointeur sur n'importe quoi, qu'on ne peut pas déréférencer (le compilateur refusera " *pv ") et qu'on peut convertir librement en un pointeur vers un autre type. C'est ainsi qu'on utilise la fonction malloc(), qui retourne un void *:

Code :

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

1
2
3
4
5
6
7
8
int *pNombre = NULL;
/* plus tard... */
 
/* On appelle malloc(), qui retourne un void *
et on stocke le pointeur retourné dans pNombre
(conversion implicite de void * à int *)
 */
pNombre = malloc( sizeof(*pNombre) );

Quand au void **, c'est un pointeur sur un pointeur générique.
En fait, tu passes à la fonction pthread_join() l'adresse d'un pointeur, pour que la fonction modifie le pointeur en question.

Envoyé par Xtatic

int pthread_create(pthread_t * thread, pthread_attr_t * attr, void *
(*start_routine)(void *), void * arg);

donc si je comprends bien, on nous oblige à ce que les start_routine (dans mon programme la fonction proc ) aient un void* comme argument.

Plus précisément, la start_routine doit prendre un argument de type void * et retourner un void *

Code :

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

1
2
void* proc(void* pv)
{

Le "premier cast", c'est justement celui que tu mets en gras, et qui est inutile : proc est déjà du type "fonction prenant un void * en argument et retournant un void *", donc elle est du bon type.
Le second cast, c'était (void *) i

Quant au dernier point, c'est une bonne idée. Comme c'est indépendant des threads, autant éviter de t'emmêler les pinceaux avec.

**Xtatic** · 11/02/2006, 19h51

Merci, je commence à y voir plus clair.

Juste une précision sur la syntaxe du cast (void* (*)( )) proc :

(void*(*)( ))

D'après moi, on doit lire et comprendre le cast de cette façon:

les parenthèses en rouges sont les parenthèses englobant le cast;

en bleu des parenthèses qui signifie que c'est un cast sur une fonction (?)

en rouge foncé et vert : le type de retour et le type de l'argument (?)

Mais je ne suis pas sur de moi, surtout à propos de la troisième proposition. Car si j'ai bon, il faudrait écrire (void* (void*)( ))...

**Médinoc** · 11/02/2006, 19h55

En fait, je dirais plutôt (mais ce n'est que mon opinion) que les parenthèses vertes indiquent un pointeur de fonction (c'est là que tu mets le nom de variable, quand tu déclares une variable de type pointeur de fonciton) et que les parenthèses bleues sont le types de l'argument (sachant que () signifie, en C, qu'on ne vérifie pas les arguments).

Ainsi, je pense qu'il faudrait plutôt écrire:
( void* (*)(void*) )

Mais bon, je n'ai pas testé, et ce n'est que mon avis...
Mais comme n'importe qui, je pense que mon avis est le bon.

**Xtatic** · 11/02/2006, 21h31

haha
Ok merci. Bon, ben il ne me restera plus qu'à expérimenter

Au niveau du fonctionnement du programme, ça se passe comment?

Car read (tout comme write) retourne le poids en octet de ce que la fonction lit (ou écrit) . Donc si on se contente d'attendre sans rien taper, les threads devraient mourir au premier tour de boucle. Ce qui n'est pas le cas, je suis obligé de faire Ctrl-C pour quitter.

Du coup, je me suis dit que read ne lit vraiment que lorque on tape Entrée.
Comme Entrée est un saut de ligne, il n'a pas un poids nul, donc le read ne renvois jamais une valeur nulle.

Mais ce raisonnement ne marcherait pas avec write...

(Je sens que c'est un questionnement qui n'a peu etre pas beaucoup d'interet, mais je trouve qu'on comprend plus facilement, et surtout on écrit plus facilement un code lorsqu'on comprend se qu'il se passe vraiment.)

**Xtatic** · 12/02/2006, 04h30

Re-bonjour, (ou plutot bonne nuit :p )

J'ai corrigé mon code en y enlevant le cast inutil et en mettant NULL à la place de void* i dans les pthread_join, mais ça ne corrige pas mon problème : lorsque j'entre des caractères au clavier, alors qu'ils devraient etre réaffichés après avoir appuyé sur Entrée, rien n'arrive.
Est ce qu'il serait possible que STDOU_FILENO ou STDIN_FILENO soient mal configurés? Et que du coup, le programme ne lise pas sur le clavier, ou qu'il ne renvois pas sur l'écran?
Si c'est possible, comment puis-je vérifier et modifier ça?
Merci.

**Médinoc** · 12/02/2006, 13h00

read(STDIN_FILENO) équivaut, à quelques considérations près, à un fread(stdin).

L'entrée standard fonctionne (par défaut) en mode ligne, c'est-à-dire que le programme attend jusqu'à ce que tu envoies une ligne.
Lorsque tu appuies sur Entrée, les caractères sont tous lus par le programmes, jusqu'au caractère \n, et l'attente recommence.

Pour indiquer à un programme que l'entrée est finie, on envoie une ligne composée uniquement d'un certain caractère:
Sous DOS/Windows, il s'agit du caractère 26 (Qu'on envoie au programme en tapant Ctrl-Z), et sous unixoïde, c'est le caractère obtenu par Ctrl-D.

Ainsi, pour terminer le programme sans Ctrl-C, tape une ligne avec juste Ctrl-D dedans.

Si ça ne marche pas, on remplacera les read/write par les fonctions de stdio.h : fgetc() et fputc(), qui ont fait leurs preuves.

PS: je te conseille de mettre do {} while(rep > 0) au lieu de != 0

**Xtatic** · 13/02/2006, 23h50

Et bien je suis en ce moment en train de mettre à jour ma version de linux vers une autre version, je ne peux donc pas tester les modifications que tu me proposes. Néanmoins, j'ai fais un autre test : j'ai mis des

Code :

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

printf("un message");

A différents endroit du programme, avec un message différent à chaque fois.
Et il se trouve que même en mettant un printf juste après la déclaration de int i dans le main( ), rien ne s'affiche.
J'ai créé un programme

Code :

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

1
2
3
4
5
6
7
8
 
#include <stdio.h>
 
int main () 
{
  printf("hello world\n");
  return 0;
}

et là, aucun souci, ça fonctionne correctement.
Donc je ne comprends pas.. Surtout que ce programme réagit différemment selon les pc. Est ce que l'utilisation des threads est lié à la machine? Ca ne devrait pourtant pas...

**Médinoc** · 14/02/2006, 01h26

Pour ça, je ne peux pas t'aider: je n'ai jamais utilisé les threads Posix...

problèmes avec un programme multi threads sous linux

POSIX C

Vue hybride

Discussions similaires

Partager

Partager