GI-SEII TD3: Synchronisation

Exercice 1 :

Soient les processus concurrents P1 et P2 qui partagent les variables n et out.

Pour contrôler les accès aux variables partagées, un programmeur propose les codes suivants :
Semaphore mutex1.Value = 1;
Semaphore mutex2.Value = 1;

Code du processus P1 : Code du processus P2 :

mutex1.wait(); mutex2.wait();
mutex2.wait(); mutex1.wait();
out=out+1;
out=out-1;
n=n-1;
mutex2.signal(); n=n+1;
mutex1.signal(); mutex1.signal();
mutex2.signal();

1) Cette proposition est-elle correcte ? Si non, pourquoi ?

2) Proposer une solution correcte.
Exercice 1
Semaphore mutex1.Value = 1; Code du processus P1 : Code du processus P2 :
Semaphore mutex2.Value = 1;
mutex1.wait(); mutex2.wait();
mutex2.wait();
mutex1.wait();
out=out+1;
out=out-1;
n=n-1;
n=n+1;
mutex2.signal();
mutex1.signal();
mutex1.signal();
mutex2.signal();

1) Interblocage.
2) Code des processus P1 et P2 :

Code du processus P1 : Code du processus P2 :

mutex2.wait();
mutex1.wait() ;
out=out-1;
n=n-1 ;
mutex2.signal();
mutex1.signal() ;
mutex1.wait();
mutex2.wait();
n=n+1;
Out = out +1 ;
mutex1.signal();
mutex2.signal();
Exercice 2 :
• On souhaite proposer une généralisation du problème du producteur et
consommateur à n producteur et m consommateur.
• Le rôle de chaque producteur P est de produire un item puis de le déposer dans une
case libre du buffer. Pour cela, il faut disposer d’une case libre.
• Le rôle de chaque consommateur C est de supprimer un item du buffer puis de le
consommer. Pour cela, il faut avoir des items dans le buffer.
• De plus, quand un processus (qu’il soit P ou C) accède au buffer (c’est la section
critique), il faut empêcher les autres d’y accéder (exclusion mutuelle).
• Indications: utilisez pour votre solution trois sémaphores:
o empty : vérifie que le buffer contient des cases vides .
o full : vérifie que le buffer contient des items.
o mtx : exclusion mutuelle pour l’accès au buffer.
do{ //Producteur P do{ //Consommateur C
/*produire un item dans next_prod*/ …
… /*supprimer item du buffer vers next_cons*/
/*Ajouter next_prod dans buffer*/ …
… /*Consommer item dans next_cons*/
}while(true); }while(true);
Exercice 2
wait(semaphore *S){ signal(semaphore *S){
S.value--; S.value++;
if (S.value < 0){ if (S.value <= 0){
add_Proc(S.list); Proc=remove_Proc(S.list);
Comportement de chaque producteur P: block();}} wakeup(Proc);}}

• Pour que P vérifie qu’un emplacement est vide, on introduit un sémaphore empty
initialisé par la taille du buffer et dont le rôle est de compter les cases vides. P doit
donc appeler wait(&empty) avant de déposer l’item dans buffer.
• Avant de déposer dans le buffer, il faut que P vérifie qu’aucun autre processus
n’accède au buffer. On introduit donc un sémaphore mtx initialisé à 1 dont le rôle est
de protéger l’accès au buffer (section critique). P doit donc appeler wait(&mtx)
avant d’accéder au buffer.
• P peut déposer l’item dans buffer et libérer l’accès au buffer par signal(&mtx).

do{ //Producteur P do{ //Consommateur C

/*produire un item dans next_prod*/
wait(&empty);
wait(&mtx); /*supprimer item du buffer vers next_cons*/
/*Ajouter next_prod dans buffer*/
signal(&mtx)
/*Consommer item dans next_cons*/
}while(true); }while(true);
Exercice 2
wait(semaphore *S){ signal(semaphore *S){
S.value--; S.value++;
if (S.value < 0){ if (S.value <= 0){
add_Proc(S.list); Proc=remove_Proc(S.list);
block();}} wakeup(Proc);}}

Comportement de chaque consommateur C:

• Pour que C vérifie que le buffer contient des items, on introduit un sémaphore full
initialisé à 0 et dont le rôle est de compter les cases pleines. C doit donc appeler
wait(&full) avant de supprimer l’item du buffer.
• Comme pour P, C doit vérifier qu’aucun autre processus n’accède au buffer avant d’y
supprimer l’item. Il appelle wait(&mtx).
• C peut supprimer l’item du buffer et libérer l’accès au buffer par signal(&mtx)

do{ //Producteur P do{ //Consommateur C

/*produire un item dans next_prod*/ wait(&full);
wait(&empty); wait(&mtx);
wait(&mtx); /*supprimer item du buffer vers next_cons*/
/*Ajouter next_prod dans buffer*/ signal(&mtx).
signal(&mtx)
/*Consommer item dans next_cons*/
}while(true); }while(true);
Exercice 2
wait(semaphore *S){ signal(semaphore *S){
S.value--; S.value++;
if (S.value < 0){ if (S.value <= 0){
add_Proc(S.list); Proc=remove_Proc(S.list);
block();}} wakeup(Proc);}}
Libération des sémaphores empty et full:
• Lorsque P dépose un item dans le buffer, il faut incrémenter le nombre d’items
disponibles dans le buffer et en informer les consommateurs. Ce nombre est géré
par le sémaphore full. Il appelle donc signal(&full)
• Lorsque C supprime un item du buffer, il faut incrémenter le nombre de cases
disponibles dans le buffer et en informer les producteurs. Ce nombre est géré par le
sémaphore empty. Il appelle donc signal(&empty)

do{ //Producteur P do{ //Consommateur C

/*produire un item dans next_prod*/ wait(&full);
wait(&empty); wait(&mtx);
wait(&mtx); /*supprimer item du buffer vers next_cons*/
/*Ajouter next_prod dans buffer*/ signal(&mtx).
signal(&mtx) signal(&empty)
signal(&full) /*Consommer item dans next_cons*/
}while(true); }while(true);
Exercice 3
• Un salon de coiffure avec un coiffeur, un fauteuil de coiffure et n chaises pour les
clients qui attendent. En l’absence de clients, le coiffeur s’assoit dans le fauteuil et
s’endort. Le premier client qui arrive réveille le coiffeur. Les clients suivants doivent
s’asseoir sur une chaise (s’il y en a de libre) ou partir (si toutes les chaises sont
occupées). Le problème consiste à programmer le coiffeur et les clients pour éviter
les accès concurrents.

• Utilisez pour votre solution trois sémaphores :

o clients: pour compter le nb de clients en attente (sans le client dans le fauteuil du
coiffeur)
o coiffeur: pour savoir si le coiffeur est libre ou pas (1 ou 0)
o mutex: pour l’exclusion mutuelle.
o attente: une variable pour compter le nombre de clients en attente (c’est une copie de
clients, puisque on ne peut pas obtenir sa valeur et qu’un nouveau client doit connaître
le nombre de clients qui attendent pour comparer au nombre de chaises du salon)
Exercice 3
• Le problème:
Le salon de coiffure dispose de n chaises représentant le nombre de clients pouvant
rester en attente.
 Le sémaphore clients compte le nombre de clients en attente. Utilisé par le coiffeur et
les clients dans la salle. Il est initialisé à 0
o Le client dans le fauteuil est servi par le coiffeur.
 Le sémaphore coiffeur indique l’état du coiffeur s’il est libre (1) ou occupé (0). Utilisé
par le coiffeur et les clients dans la salle pour demander une coiffure. Il est initialisé à 1.
o Deux clients ne peuvent pas être servi en même temps par le coiffeur.
 Le sémaphore mutex gère l’exclusion mutuelle pour l’accès au fauteuil du coiffeur . Il
est initialisé à 1. Utilisé par le coiffeur et les clients dans la salle.
o La variable attente est une copie du sémaphore clients pour que chaque
nouveau client puisse comparer le nombre de clients en attente au nombre de
chaises n et savoir s’il reste ou part. Elle est initialisée à 0 (comme le sémaphore
clients). do{ //Coiffeur //un Client

/*effectuer une coupe*/ /*obtenir une coupe*/

}while(true);
Exercice 3
wait(semaphore *S){ signal(semaphore *S){
Comportement coiffeur: S.value--; S.value++;
if (S.value < 0){ if (S.value <= 0){
add_Proc(S.list); Proc=remove_Proc(S.list);
block();}} wakeup(Proc);}}

• Le coiffeur appelle wait(&clients) avant d’effectuer une coupe.

• Lorsque le coiffeur invite un client à son fauteuil (section critique), il décrémente la
variable attente. Pour cela, il faut la protéger par le sémaphore mutex pour
éviter qu’elle soit manipulée ailleurs. Le coiffeur appelle wait(&mutex) avant
d’inviter le client au fauteuil (décrémenter attente).
• Le coiffeur appelle signal(&coiffeur)pour indiquer qu’il est libre.
• Le coiffeur appelle signal(&mutex)pour libérer l’accès à attente.
• Le coiffeur effectue la coupe.

do{ //Coiffeur
//un Client
wait(&clients);
wait(&mutex);
attente - -;
/*obtenir une coupe*/
signal(&coiffeur)
signal(&mutex)
/*effectuer une coupe*/
}while(true);
Exercice 3 wait(semaphore *S){
S.value--;
if (S.value < 0){
signal(semaphore *S){
S.value++;
if (S.value <= 0){
add_Proc(S.list); Proc=remove_Proc(S.list);
Comportement client: block();}} wakeup(Proc);}}

• Lorsque le client entre dans le salon, il vérifie s’il y a des places libres (compare
attente au nombre chaises n). Evidement, il doit vérifier qu’attente ne change
pas en cours de comparaison, il appelle wait(&mutex)
oS’il ne trouve pas de place, il n’attend pas et quitte le salon en appelant
signal(&mutex). do{ //Coiffeur
wait(&clients);
oS’il y a une place: wait(&mutex);
attente - -;
 il prend une chaise (incrémenter attente), et signal(&coiffeur)
signal(&mutex)
appelle signal(&clients)pour augmenter le /*effectuer une coupe*/
nombre clients en attente et réveiller le coiffeur si }while(true);
nécessaire.
 Il appelle signal(&mutex)pour indiquer qu’il ne //Client
wait(&mutex);
manipule plus la variable attente . If (attente < n){
attente ++;
 Il appelle wait(&coiffeur) pour attendre signal(&clients);
d’obtenir une coupe si ce dernier est occupé. signal(&mutex);
wait(&coiffeur);
/*obtenir une coupe*/
}
else signal(&mutex);