Bonjour,

Je viens sur ce forum pour demander un peu d'aide.
J'étudie la programmation et depuis maintenant un sacré bout de temps, je bloque sur un devoir. ( Je demande pas forcément la solution mais un petit coup de pouce pour me mettre sur le droit chemin ).
Je souhaite donc synchroniser trois processus au moyen de sémaphore. J'ai P1 Qui écris des données dans un buffer(a), P2 qui le récupère, les exploites et les transferts dans un buffer(b), et P3 qui les récupères et les mets en forme.

Le fonctionnement serait donc:

P1
création des données;
transfert tampon(a);

P2
lire tampon(a);
exploitation tampon(a);
transfert tampon(b);

P3
lire tampon(b);
mise en forme tampon(b);

en ce qui concerne la synchronisation:
Stop(s) // S sémaphore
{
s.c = s.c - 1;
if (s.c < 0 ) { // si la valeur du compteur est inf à 0
attendre(); // met le processus en attente
entrer(s.f); // inclu le processus dans la file F
}
}

Start(s);
{
s.c = s.c +1;
if (s.c >= 0) { // Si la valeur du compteur est sup ou = à 0
sortir(s.f); // Extrait le processus de la file F
activer(); // réactive le processus
}
}

Voila pour l'instant quesque vous pensez de ça ?
C'est plutot un pseudo code mais je veux simplement comprendre le fonctionnement.

Les processus P1, P2, et P3 n'ont aucune condition, aucun sens de lecture, c'est normal ?

J'espère que vous comprendrez mon problème.
Autrement si vous pouviez me donner des exemples ca serait aussi gentil. Merci d'avance.

les joies de la synchro de processus. J'adorais ça quand on en avait a la fac.

A mon avis, pour faire quelque chose d'efficace, il te faut 4 semaphores.
- 1 pour savoir si on peut ecrire dans le tampon A : SemWriteA
- 1 pour savoir si on peut lire dans le tampon A : SemReadA
- 1 pour savoir si on peut ecrire dans le tampon B : SemWriteB
- 1 pour savoir si on peut lire dans le tampon B : SemReadB

et tu fait un truc dans le genre :

initialisation(){
// init a 0 car il n'y a rien a lire pour le moment.
SemReadA.c = SemReadB.c = 0;
// init a 1 car on peut ecrire.
SemWriteA.c = SemWriteB.c = 1;
}

Boucle de P1 :
while(1){
// on attend de pouvoir ecrire
stop(SemWriteA);
// ecrit dans le tampon A
// libre le processus qui attend pour lire
start(SemReadA);
}

Boucle de P2 :
while(1){
// on attend de pouvoir lire
stop(SemReadA);
// lire le contenu du tempon A et le mettre dans une variable temporaire
// permetre de nouveau l'ecriture dans le tampon
start(SemWriteA);

// on attend de pouvoir ecrire dans B
stop(SemWriteB);
// ecrire ce qu'on a lu plus haut dans le tampon B
// permetre la lecture dans B
start(SemReadB);
}

Boucle de P3 :
while(1){
// on attend de pouvoir lire dans le tampon B
stop(SemReadB);
// lire le contenu de B
// permettre d'y ecrire a nouveau
start(SemWriteB);
}

--------------------------------------

j'espere avoir mis assez de commentaire pour que tu puisse comprendre l'idée.

En gros l'idée c'est
- apres avoir lu, il faut permetre d'ecrire
- apres avoir ecrit il faut permetre de lire.
- au debut il n'y a rien d'ecrit don on permet d'ecrire mais pas de lire.

j'ai oublié de préciser : il faut limiter au maximum le temps passé dans les sections critiques donc si tu as des traitements a faire sur tes données, fait les avant de te bloquer sur un sémaphore.
typiquement, il faut se contenter de lire ou ecire quand tu es dans une section critique.

Merci beaucoup pour votre réponse
Donc le résultat final serait :

initialisation(){
SemReadA.c = SemReadB.c = 0;
SemWriteA.c = SemWriteB.c = 1;
}

Boucle de P1 :
while(1){
stop(SemWriteA);
write tampon(a) ;
start(SemReadA);
}

Boucle de P2 :
while(1){
stop(SemReadA);
read tampon(a) ;
start(SemWriteA);
stop(SemWriteB);
write tampon (b) ;
start(SemReadB);
}

Boucle de P3 :
while(1){
stop(SemReadB);
read tampon(b)
start(SemWriteB);
}

Serait-t-il possible d’avoir une traduction « humaine » de P1 par exemple ?
En particulier a propos de la boucle « while(1) » Cela donnerais Tant que.. ?
C’est une boucle infinie vue que 1 est toujours vrai c’est bien ça ?
Je ne comprend pas tout malheureusement mais je vais réviser tout ça.
Merci beaucoup en tout cas

P1 c'est le premier processus
le while(1) est bien une boucle infinie ; c'est pour dire que c'est un morceau de code qui revient souvent... Si ce n'est pas le cas, alors c'est pas la peine de faire de la synchronisation.

alors, en avant pour la traduction :

Initialisation :
permettre d'ecrire dans les tampons A et B
Interdire la lecture dans les tampons.

Boucle de P1
Tant que le programme doit tourner faire :
- attendre d'avoir le droit d'ecrire dans le tampon A
--- ecrire les données
--- autoriser la lecture dans le tampon A
fin tant que.

boucle de P2
Tant que le programme doit tourner faire :
- attendre d'avoir le droit de lire dans A
--- copier ce que contient le tampon A dans une variable temporaire
--- autoriser a ecrire a nouveau dans le tampon A

- attendre d'avoir le droit d'ecrire dans le tampon B
--- ecrire dans le tampon B
--- autoriser a lire dans le tampon B
fin tant que

Boucle de P3 :
Tant que le programme doit tourner faire :
- attendre d'avoir le droit de lire dans le tampon B
--- lire les données
--- autoriser l'ecriture dans le tampon B
fin tant que.

C'est beaucoup plus clair à mes yeux.
J'ai à présent compris :D
Merci beaucoup d'avoir pris le temps de me répondre et de m'aider