Multithreading - Sémaphore - Dîner des Philosophes

Bonjour à tous,

Voilà depuis quelques semaines j'étudie (en cours) la programmation système en C sous Linux. Ayant bien galéré à l'école, j'ai décidé de m'y replonger totalement pour bien comprendre et assimiler. Actuellement je bloque sur le TP "final" de la partie Threads et Sémaphore (Pour ceux qui connaisse il s'agit du Problème du dîner des philosophes).
Voici l'énoncé :
On rappelle qu’un nombre n (pour ma part n = 5) de philosophes sont assis autour d’une table ronde, sur laquelle sont installées n assiettes de spaghettis et n fourchettes. Chaque philosophe dispose d’une fourchette de chaque côté de son assiette.
Les philosophes commencent tous à penser. Lorsque l’un d’eux se décide à faire une pause pour manger, il cherche à prendre les deux fourchettes qui se trouvent de chaque côté de son assiette. Si un de ses voisins mange, il devra attendre… Si une des deux fourchettes est occupée par un voisin, il devra attendre. Le programme prend fin dès que NBCYCLES cycles penser-manger ont été réalisés par chaque philosophe. L'affichage devra se faire sur une seule ligne représentant l'état de chaque Philosophe (P P P P P). On doit afficher seulement quand il y a Changement d'Etat d'1 Philosophe (P P P P P , P P P P A, P P P P M, P P P A M, etc...).
Le schéma du système :

Bien sûr ce système est connu pour être bloquant. J'ai donc choisi d'utiliser un tableau de sémaphores "privé", 1 pour chaque philosophe en attente de ses fourchettes. Les états des philosophes sont stockés dans un tableau. J'utilise donc un sémaphore "public" de type mutex pour la section critique Tableau d'état.
Déjà voilà mon code :

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

/************************************** ** pthread-philo2.c ** ** Programme d'exemple de pthread avec ** philosophes qui dinent et mutex ** ***************************************/   #include <pthread.h> #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <unistd.h> #include <semaphore.h> #include <errno.h> #include <string.h>   #define NB_PHILO 5 #define NB_CYCLE 5   typedef enum{Pense, Mange, Attend} T_etat;   T_etat etatPhilo[NB_PHILO];   static sem_t fourchettes[NB_PHILO]; // sémaphore privé, sémaphore pour les ressources fourchettes (1 par philosophe) static sem_t SemaPublic; // pour l'affichage (il faut pas que ça change pendant qu'on affiche)       void error(int err, char *msg) { fprintf(stderr,"%s a retourné %d message d'erreur : %s\n",msg,err,strerror(errno)); exit(EXIT_FAILURE); }   void changeEtaffiche ( int* id, T_etat nouvelEtat) // fonction affichant les états des différents philosophes sur une ligne { int i; sem_wait(&SemaPublic); etatPhilo[*id] = nouvelEtat; for (i = 0; i<NB_PHILO; i++) { switch(etatPhilo[i]){ case Pense: printf(" P "); break; case Mange: printf(" M "); break; case Attend: printf(" A "); break; } } printf("\n\n"); sem_post(&SemaPublic); }       void* philosophe ( void* arg ) { int *id=(int *) arg; int left = *id; int right = (left + 1) % NB_PHILO;   int cycle; for(cycle=0; cycle<NB_CYCLE; cycle++) {   // il attend changeEtaffiche(id,Attend); if(left<right) { sem_wait(&fourchettes[left]); sem_wait(&fourchettes[right]); } else { sem_wait(&fourchettes[right]); sem_wait(&fourchettes[left]); }   // il mange changeEtaffiche(id,Mange); //sleep(2);   // il pense (important: avant de relacher ses fourchette, parce que s'il le fait après, l'affichage mettrait que 2 voisins mange en même temps) changeEtaffiche(id,Pense); sem_post(&fourchettes[left]); sem_post(&fourchettes[right]);   //sleep(2);   } return (NULL); }   /********************* ***** MAIN *********************/ int main ( int argc, char *argv[]) { int i; int id[NB_PHILO]; int err; pthread_t thread[NB_PHILO]; // threads philosophes   srand(getpid());   sem_init(&SemaPublic,0,1);   for (i = 0; i < NB_PHILO; i++) { id[i]=i; etatPhilo[i] = Pense; // au début TOUS les philosophes pensent err=sem_init( &fourchettes[i], 0, 1); if(err!=0) error(err,"sem_init"); }   for (i = 0; i < NB_PHILO; i++) { err=pthread_create(&thread[i], NULL, philosophe, (void*)&(id[i]) ); if(err!=0) error(err,"pthread_create"); }   for (i = 0; i < NB_PHILO; i++) { pthread_join(thread[i], NULL); if(err!=0) error(err,"pthread_join"); }   for (i = 0; i < NB_PHILO; i++) { sem_destroy(&fourchettes[i]); if(err!=0) error(err,"pthread_mutex_destroy"); }   sem_destroy(&SemaPublic);   return (EXIT_SUCCESS); }

---

Ce code compile et s'exécute.
J'ai plusieurs problèmes :
1. Déjà je n'arrive pas à afficher QUE quand il y a changement d'état d'un philosophe (vous verrez qu'on a un affichage de 5 lignes en même temps et plusieurs fois la même ligne s'affiche à la suite)
2. J'ai l'impression que plusieurs philosophes ne peuvent pas manger en même temps (alors que par exemple philo 0 et philo 2 pourraient..) et à chaque fois j'ai une ligne où les 5 philosophes attendent et ce toutes les 3 lignes affichées.
3. Je n'arrive pas à gérer le fait que quand chaque philosophe aura manger X fois il reste en état pense et que quand tous les philos ont mangés X fois et sont en état Pense, le programme se termine.

Pour mes 1ère et 2è questions c'est au niveau des sémaphores que cela se passe je le sais. Et c'est sur cette partie que je bloque le plus, donc hésitez pas à critiquer mon code et surtout à bien m'expliquer pourquoi ça plutôt que comme moi j'ai fait.
Je veux vraiment afficher une ligne quand UN etat d'UN philosophe change et je ne veux pas que ca fasse les philosophes les uns après les autres (n°0 mange, puis pense, n°1 mange puis pense etc..) comme cela fait quand on exécute mon code.

Désolé de la taille du poste (j'aime bien détailler et expliquer ce que je veux vraiment). Si vous avez mal compris des choses, demandez ^^
Merci d'avance à ceux qui prendront le temps de me lire et de me répondre
Je compte sur votre aide^^
Cordialement,
Fuot

Citation:

---

Désolé de la taille du poste (j'aime bien détailler et expliquer ce que je veux vraiment). Si vous avez mal compris des choses, demandez ^^

---

Au contraire, c'est une excellente chose et ca facilite notre demarche pour t'aider sans parler du fait que c'est plus agreable.

Citation:

---

1. Déjà je n'arrive pas à afficher QUE quand il y a changement d'état d'un philosophe (vous verrez qu'on a un affichage de 5 lignes en même temps et plusieurs fois la même ligne s'affiche à la suite)

---

Je pense que c'est a cause du buffering de printf. En gros, si tu veux etre sur qu'il affiche le texte que tu lui as envoye, il faut qu'il y ait un retour a la ligne a la fin de la chaine de caracteres. Exemple :

Code:

---

1 2	printf("test"); //peut ne pas s'afficher immediatement printf("test\n"); //sera affiche immediatement

---

Citation:

---

2. J'ai l'impression que plusieurs philosophes ne peuvent pas manger en même temps (alors que par exemple philo 0 et philo 2 pourraient..) et à chaque fois j'ai une ligne où les 5 philosophes attendent et ce toutes les 3 lignes affichées.

---

Je pense qu'avant meme de regarder tes fonctions, ton probleme n'est pas super bien pose. Lorsque je suis tombe sur ce projet (il y a 1 ou 2 ans maintenant) a mon ecole, je m'y etais pris de cette facon :

- l'element bloquant est clairement les fourchettes donc autant creer un mutex par fourchette.
- pour gerer plus facilement ces fourchettes et ces philosophes, autant creer des structures qui vont les gerer :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

struct philosophe { struct fourchette *main_droite; struct fourchette *main_gauche; int etat; };   struct fourchette { struct philosophe *mangeur; semaphore mutex; };

---

Avec ca tu devrais deja y voir un peu plus clair.

Citation:

---

3. Je n'arrive pas à gérer le fait que quand chaque philosophe aura manger X fois il reste en état pense et que quand tous les philos ont mangés X fois et sont en état Pense, le programme se termine.

---

Il te suffit de rajouter une variable dans la structure philosphe qui permette de savoir combien de fois il a mange. Il te suffira de verifier a chaque tour si tous les philosophes ont mange X fois ou non.

En esperant t'avoir aide.

Salut à toi et merci de te réponse :)

Pour l'affichage à chaque Changement d'Etat, j'ai réussi, cela affiche une ligne quand un philosophe change d'état. Merci à toi.
Par contre cela s'affiche par 5 lignes en même temps à chaque fois, moi je veux une ligne à la fois, 1 seconde entre chaque, tout en gérant ce que j'ai dit juste au dessus.

Pour le reste j'ai corrigé plusieurs choses c'est pratiquement parfait^^ : 2 philosophes arrivent à manger en même temps (j'ai utilisé des sémaphores pour chaque fourchette), et j'ai introduit une variable cycle : quand chaque philosophe a fait 3 cycles (Penser-Manger), le programme se termine.

PAR CONTRE j'ai toujours, toutes les 5-6 lignes, tous les philosophes repassent à ATTEND, et à chaque fois... et j'arrive vraiment pas à voir le problème en fait.

J'ai mis à jour le code dans le 1er Post, vous pouvez m'aider, à partir de mon code svp ???

Merci encore des aides et infos en tout cas, ca m'a aidé :D