Système d’exploitation (Corrigé)

TD-synchronisation des processus

Exercice 1
Listing 1: Processus "P1" et "P2"

P1 P2
for ( ; ; ) for ( ; ; )
{ {
P(S); P(Q);
a; b;
V(Q); V(S);
} }

(a) Que se passe-t-il si l'un des sémaphores est initialisé à 1 et l'autre à 0 ?

Reponse :
Si S initialisée à 1 et Q à 0, les processus s’exécuteront en alternance et c’est P1 qui
commence ensuite P2 on observe l’exécution
a b a b a b a b a b a b a b a b a b a b a b a b a b …..

Si S initialisée à 0 et Q à 1, les processus s’exécuteront en alternance et c’est P2 qui

commence ensuite P1 on observe l’exécution
b a b a b a b a b a b a b a b a b a b a b a b a b a…..

(b) Que se passe-t-il si S et Q sont initialisés à 0 ?

Reponse :
Si S initialisée à 0 et Q à 0, les processus se bloquent P1 dans S et P2 dans Q indéfininiment

(c) Que se passe-t-il si S et Q sont initialisés à 1 ?

Reponse :
Si S initialisée à 1 et Q à 1, les processus s’exécuteront en parallèle durant la première
itération de leur boucles respectives à la seconde itération les processus doivent s’attendre
mutuellement (RDV) et ainsi de suite
On obseerve : a||b - a||b- a||b- ….

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.

b) Réponse : il faut changer le code du processus P1 comme suit

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.

Durée d’exécution Date d’entrée en Durée d’exécution en

Prêt à l’instant t=
totale en ms section critique section critique en ms

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

1. Ecrire les pseudocodes des processus P0 et P1.

2. Dressez le diagramme de Gantt relatif à l’exécution des trois processus

indiquez pour chacun des processus l’état à chaque instant. On désigne les
abréviations suivantes : Ex : exécution ; SC : Section Critique ; AA : Attente
Active.

3. Si au lieu de l’algorithme de Peterson on utilise un sémaphore d’exclusion

mutuelle (Mutex), Comment utiliser Mutex pour assurer l’exclusion mutuelle
entre P0 et P1. Ecrire les Pseudocodes de P0 et de P1 dans ce cas.

4. Que devient le diagramme de Gantt relatif à l’exécution des trois processus

avec le sémaphore Mutex.

5. Si nous voulons apporter une synchronisation supplémentaire ou P2 ne peux

commencer qu’après la fin des deux processus P1 et P2. Comment doit-on
transformer les codes des processus P0, P1 et P2 moyennant les sémaphores
pour réaliser cette synchronisation.
Exercice 4
Deux processus A et B communiquent au moyen d’un tampon T pouvant contenir qu’un
seul message à la fois. Ce tampon est utilisé, de façon alternée, pour la communication
dans les eux sens (attention un seul processus utilise à la fois ce tampon). Le processus
A dépose un message dans le tampon puis attend la réponse de B avant de déposer à
nouveau un autre message et ainsi de suite….
Lorsque B reçoit un message de A, il dépose sa réponse dans le tampon puis se met en
attente
d’un autre message de A et ainsi de suite…

1. synchronisez au moyen de sémaphores les processus A et B (pour répondre à la

question, complétez le code suivant)

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);
}
} }
}

2. Supposez maintenant qu’un troisième processus C veuille communiquer avec B en

utilisant l’unique tampon T. Les processus A et C se comportent de la même manière.
B peut donc recevoir un message de A ou C, la réponse doit être récupérée par le
processus expéditeur du message. Synchroniser au moyen de sémaphores les
processus A, B et C.
Corrigé Exercice 4
1. Il faut deux sémaphores S et Q initialisés à 0

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);
} }
} }

2. Pour sunchroniser A et C avec B il faut que A et B s’exécute en exclusion

mutuelle, celui de A et C, qui entame la communication avec B la termine
jusqu’au bout et ne sera pas interrompu par l’autre il faut un sémaphore
d’exclusion mutuelle mutex initialisé à 1.
Processus A Processus C
{ {
char mess[256], rep[256] ; char mess[256], rep[256] ;
while (1) while (1)
{ {
P(mutex) P(mutex)
lire (mess); lire (mess);
depot (mess ) ; depot (mess ) ;
V(S) V(S)
P(Q) P(Q)
recuperer(rep) ; recuperer(rep) ;
V(mutex) V(mutex)
} }
} }
}
Exercice 5
Considérez un ensemble de processus composés de plusieurs producteurs et d’un seul
consommateur dont les codes sont les suivants :

Semaphore plein =0, vide=N, mutex=1,mutex1=1;

char T[N] ;
int ip=0 ;

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

1. Peut-on avoir une situation d’interblocage ? (si oui, expliquez en décrivant

clairement une situation d’interblocage).

2. Complétez le code précédent de manière à éviter les situations d’interblocage.

Corrigé Exercice 5
Réponses :
1. Oui, un ensemble de producteurs et le consommateur peuvent être interbloqués :
Chaque producteur Pi de l’ensemble est en attente suite à l’appel à P (vide) et il n’y a
plus de cases pleines (vide=0 et plein=0) :

Exemple : N=8, M=4, |P|=4

Les 4 processus s’exécutent en « parallèle » (time sharing).
Supposons qur les 4 processus parviennent à exécuter en parallèle les itération i=1 et
i=2 de la boucle pour de réservation où ils exécutent P(vide) ; ainsi en exécutant les
Itérations i =1 et i=2 : les 4 processeurs exécutent P (vide). P1 : réserve ch[1] et ch[2],
P2 : réserve ch[3],ch[4] , P3 ch[5] et ch[6] et enfin P4 réserve ch[7] et ch[8]. A
l’itération i=3, les 4 processus se bloquent sucessivement dans le sémaphore vide car il
n’ y a plus de case à réserver. Mais aucun ne peut déposer son message M de taille 4 car
ils n’ont réservé chacun que 2 cases.
Par ailleur pour le consommateur le plein initialisé à zéro et comme aucun message n’a
encore été dépoé, il exécute P(plein) et se bloque également.

2. Pour corriger ceci, il suffit de mettre la boucle de réservation en exclusion

mutuelle entre les différents producteurs

Semaphore plein =0, vide=N, mutex=1, mutex1=1 ;

char T[N] ;
int ip=0 ;
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) ;
P (mutex1) ; c= T[ic] ;
Pour i=1 à M pas 1 faire V (mutex) ;
P (vide) ; V (vide) ;
V (mutex1) ; Traiter(c) ;
P (mutex) ; ic++ ;
Déposer (ch, M, ip) ; //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 ;
}
Exercice 6
Deux processus P1 et P2 disposant chacun d’un tableau d’entiers de taille N, Tab1 et
Tab2 veulent échanger des nombres de ces tableaux de manière à ce que à la fin de
leurs exécutions respectives, P1 dispose des N plus petites valeurs et P2 des N plus
grandes.
Pour pouvoir échanger ces nombres, on dispose d’une ressource critique RS, contenant
trois cases et d’un processus gestionnaire P0. Le fonctionnement général est le suivant :
Le processus P1 (resp. P2) cherche le maximum (resp. le minimum) dans son tableau et
le place dans la première (resp. la deuxième) case de la ressource critique. Le processus
P0 vérifie que la valeur de la première case est supérieure à la seconde. Si c’est le cas,
P0 effectue l’échange des valeurs, sinon il bascule la valeur de la troisième case de la
ressource critique à -1, qui était initialement à zéro.

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

Les trois processus en pseudo-code donnent ceci

Int STOP=0
Int Tab[3]
P1 P2
{ {
While (!stop) While (!stop)
{ {
Pos_max=recherche_max_tab(Tab1) Pos_min=recherche_min_tab(Tab2)
Tab[0]=Tab1[pos_max] ; Tab[1]=Tab2[pos_min] ;

V(P0_attend_P1) V(P0_attend_P2)
P(P1_attend_P0) P(P2_attend_P0)

If(Tab[2]==0) If(Tab[2]= =0)

Tab1[pos_max] =Tab[0]; Tab2[pos_min] =Tab[1];

} }
} }

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