TD Synchronisation Corrigé
TD Synchronisation Corrigé
TD Synchronisation Corrigé
Exercice 1
Listing 1: Processus "P1" et "P2"
P1 P2
for ( ; ; ) for ( ; ; )
{ {
P(S); P(Q);
a; b;
V(Q); V(S);
} }
Exercice 2
Soient trois processus concurrents P1, P2 et P3 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 = 1 ;
Semaphore mutex2 = 1 ; Code du processus p2 :
P(mutex2) ;
Code du processus p1 : out=out-1 ;
P(mutex1) ; V(mutex2) ;
P(mutex2) ;
out=out+1 ; Code du processus p3 :
n=n-1 ; P(mutex1) ;
V(mutex2) ; n=n+1 ;
V(mutex1) ; V(mutex1) ;
(a) Cette proposition est-elle correcte ? Sinon, indiquer parmi les 4 conditions requises
pour réaliser une exclusion mutuelle correcte, celles qui ne sont pas satisfaites ?
(b) Proposer une solution correcte.
Corrigé
a) Réponse : Non, car si P2 est en section critique et P1 a exécuté P(mutex1) alors
P1 est bloqué et empêche P3 d’entrer en section critique. Conditions non vérifiées
:Un processus en dehors de sa section critique bloque un autre processus.
Processus P1
P(mutex1) ;
n=n-1 ;
V(mutex1) ;
P(mutex2) ;
Out = out +1 ;
V(mutex2) ;
Exercice 3
On considère une séquence de trois processus P0, P1 et P2. Les processus P0 et P1 se
partagent une ressource critique dont l’accès est géré par la solution de Peterson. Le
tableau ci-dessus décrit les trois processus.
P0 0 13 1 7
P1 0 10 4 4
P2 2 8 _ _
On considère par ailleurs que la stratégie d’allocation du processeur est le Round Robin
(ou tourniquet) et que le quantum de temps Q utilisé est de 3ms.
Questions
Processus A Processus B
{ {
char mess[256], rep[256] ; char mess[256], rep[256];
while (1) while (1)
{ {
lire (mess);
depot (mess ) ; recuperer( mess) ;
reponse(mess,rep)
recuperer(rep) ;
depot(rep);
}
} }
}
Processus A Processus B
{ {
char mess[256], rep[256] ; char mess[256], rep[256];
while (1) while (1)
{ {
lire (mess); P(S)
depot (mess ) ; recuperer( mess) ;
V(S) reponse(mess,rep)
P(Q) V(Q)
recuperer(rep) ; depot(rep);
} }
} }
Producteur ( ) Consommateur ( )
{ {
int i, M ; int ic =0 ;
char ch[N]; char c ;
Repeter Repeter
{ {
M =Lire (ch, N); P(plein) ;
M = min (N, M); P(mutex) ;
c= T[ic] ;
Pour i=1 à M pas 1 faire V(mutex) ;
P (vide) ; V(vide) ;
P (mutex) ; Traiter(c) ;
Déposer (ch, M, ip) ; ic++ ;
//insérer ch dans T } tant que vrai ;
ip = (ip+M)%N ; }
V (mutex) ;
Pour i=1 à M pas 1 faire
V (plein) ;
} tant que vrai ;
}
Chaque processus (P1 et P2) récupère après sa nouvelle valeur dans sa case l’écrit à la
place de l’ancienne, puis recommence le même travail. Si la case 3 de la ressource
critique est à -1, les processus s’arrêtent.
On dispose des fonctions suivantes :
•
• int minimum (int tab[],int N); qui prend en paramètre un tableau d’entier et
retourne la position du minimum dans le tableau.
• int maximum (int tab[],int N); qui prend en paramètre un tableau d’entier et
retourne la position du maximum dans le tableau.
• Void echange (int *a,int*b) ; qui échange les contenus de deux cases en mémoire.
Tab1 Tab2
1 3 4 2 6 0
P1 : cherche maximum, écrire dans case 1 de la ressource critique
Ressource critique
max min
4 4 0 P2 : cherche minimum, écrire dans case 2 de la ressource critique
Pos_max 0 Pos_min
P0 : Attendre
2 0 2
1. Pour mettre en œuvre les processus P0, P1 et P2 Quels sont les problèmes à prendre
en considération? Expliquer comment se présente ces deux problèmes entre P0, P1
et P2.
2. Proposer une solution en utilisant les sémaphores pour les trois processus, Ecrire un
pseudo algorithme décrivant chacun des processus P0, P1 et P2.
Corrigé Exercice 6
Il y a trois processus/ thread P1, P2 et P0
Proposition :
Les semaphores : Les 4 autres sémaphores pour la synchronisation, initialisés tous à 0.
P0_attend_P1
P0_atend_P2
P1_attend_P0
P2_attend_P0
V(P0_attend_P1) V(P0_attend_P2)
P(P1_attend_P0) P(P2_attend_P0)
} }
} }
P0
{
While (!stop)
{
P(P0_attend_P1)
P(P0_attend_P2)
If( Tab[0]>=Tab[1] )
Permuter (Tab[0],Tab[1])
Tab[2]==0;
Else
Tab[2]=-1;
Stop=1;
V(P1_attend_P0)
V(P2_attend_P0)
}
}