RT4-GL4-IMI4

Systèmes Temps-Réel

Chapitre 3 - Suite
Exemple – Sémaphores

Olfa Mosbahi
[email protected]
Exemples de Processus en Concurrence
Problème des Lecteurs-Rédacteurs

2
 Priorité égale
1 module lecteurs_redacteurs
2 defines debut_lecture, fin_lecure, debut_ecriture, fin_ecriture
3 var
4 nb_lecteurs : integer  0;
5 lr : semaphore  1 ; /* exclusion mutuelle pour lecteurs */
6 r : semaphore  1 ; /* exclusion mutuelle pour rédacteurs */
7 mutex: semaphore  1 ; /* semaphore sur nb-lecteurs */
8 procedure debut_lecture
9 P(lr) ;
10 P(mutex) ;
11 nb_lecteurs  nb_lecteurs + 1 ;
12 if nb_lecteurs = 1 then
13 P(r) ;
14 end
15 V(mutex) ;
16 V(lr) ;
17 end
18 procedure fin_lecture
19 P(mutex) ;
20 nb_lecteurs  nb_lecteurs - 1 ;
21 if nb_lecteurs = 0 then
22 V(r) ;
23 end
24 V(mutex) ;
25 end
26 procedure debut_ecriture
27 P(lr) ;
28 P(r) ;
29 end
30 procedure fin_ecriture
31 V(r) ;
32 V(lr) ;
33 end 3
37 end module
 Priorité égales
Execution :

Soit l’ordre d’arrivée est : r1 l1 r2 l2

L’ordre d’entrée en section critique est : r1 l1 r2 l2

Lecteur r1 l1 r2 l2 Redacteur

l28: p(lr) lr = 0 puis p(r) r=0

l10 : p(lr) l2 passe à file d’attente de lr Ok pour r1

l28: p(lr) r2 passe à la

file d’attente de lr
l10: p(lr) l2 passe à la file d’attente de lr

r
File d’attente pour r

lr l1 r2 l2 File d’attente pour lr

r1 V(r) file non vide libérer entete de la file l1 V(lr) liberer r2 l2

 Priorité égales

Questions :

1- Considérer la solution du problème des lecteurs-rédacteurs avec priorités égales

de l’Algorithme. Que se passe-t-il si, dans la procédure début lecture, quand on
déplace P(lr) après V(mutex) ?

5
 Priorité égale
1 module lecteurs_redacteurs
2 defines debut_lecture, fin_lecure, debut_ecriture, fin_ecriture
3 var
4 nb_lecteurs : integer  0;
5 lr : semaphore  1 ;
6 r : semaphore  1 ;
7 mutex: semaphore  1 ;
8 procedure debut_lecture
9 P(lr) ;
10 P(mutex) ;
11 nb_lecteurs  nb_lecteurs + 1 ;
12 if nb_lecteurs = 1 then
13 P(r) ;
14 end
15 V(mutex) ;
16 V(lr) ;
17 end
18 procedure fin_lecture
19 P(mutex) ;
20 nb_lecteurs  nb_lecteurs - 1 ;
21 if nb_lecteurs = 0 then
22 V(r) ;
23 end
24 V(mutex) ;
25 end
26 procedure debut_ecriture
27 P(lr) ;
28 P(r) ;
29 end
30 procedure fin_ecriture
31 V(r) ;
32 V(lr) ;
33 end 6
37 end module
 Priorité égales

Questions :

1- Considérer la solution du problème des lecteurs-rédacteurs avec priorités égales

de l’Algorithme. Que se passe-t-il si, dans la procédure début lecture, on déplace
P(lr) après V(mutex) ?

Réponse :

Interblocage (Deadlock)
Par exemple, un lecteur execute P(r) et avant d’éxécuter P(lr) un rédacteur
execute P(lr) suivi de P(r).
Ainsi le lecteur attend sur P(lr) alors que le rédacteur attend sur P(r).

7
 Priorité égales

2- Que se passe-t-il si l’on supprime les appels de P(lr) dans la procédure début
écriture et V(lr) dans la procédure fin écriture ?

8
 Priorité égale
1 module lecteurs_redacteurs
2 defines debut_lecture, fin_lecure, debut_ecriture, fin_ecriture
3 var
4 nb_lecteurs : integer  0;
5 lr : semaphore  1 ;
6 r : semaphore  1 ;
7 mutex: semaphore  1 ;
8 procedure debut_lecture
9 P(lr) ;
10 P(mutex) ;
11 nb_lecteurs  nb_lecteurs + 1 ;
12 if nb_lecteurs = 1 then
13 P(r) ;
14 end
15 V(mutex) ;
16 V(lr) ;
17 end
18 procedure fin_lecture
19 P(mutex) ;
20 nb_lecteurs  nb_lecteurs - 1 ;
21 if nb_lecteurs = 0 then
22 V(r) ;
23 end
24 V(mutex) ;
25 end
26 procedure debut_ecriture
27 P(lr) ;
28 P(r) ;
29 end
30 procedure fin_ecriture
31 V(r) ;
32 V(lr) ;
33 end 9
37 end module
 Priorité égales
Correction :

Soit l’ordre d’arrivée est : r1 l1 r2 l2

L’ordre d’entrée en section critique est : r1 l1 l2 r2

Lecteur r1 l1 r2 l2 Redacteur

l9 : p(lr) lr = 0 l28 : p(r) r=0

……. Ok pour r1
l13 : p(r) or r=0
l28 : p(r) r2 passe à la
file d’attente de r
l1 passe à la file attente de r
p(lr) l2 passe à la file d’attente de lr

l1 r2 File d’attente pour r

l2 File d’attente pour lr

r1 V(r) file non vide libérer entete de la file l1 V(lr) liberer l2 r2

 Priorité égales

2- Que se passe-t-il si l’on supprime les appels de P(lr) dans la procédure début
écriture et V(lr) dans la procédure fin écriture ?

Correction :

Si on supprime P(lr) dans la procédure début-écriture et V(lr) dans la procédure

fin-écriture, la sémantique des priorités égales est violée : un lecteur en attente
peut entrer en section critique avant un rédacteur en attente alors que le lecteur
est arrivé après le rédacteur.

11
 Priorité aux Rédacteurs
Algorithm 1 : Lecteurs/Rédacteurs avec Priorités aux rédacteurs
1 module lecteurs_redacteurs
2 defines debut_lecture, fin_lecure, debut_ecriture, fin_ecriture
3 var
4 r_number : integer  0 ; /* nombre des rédacteurs */
5 lr_number : integer  0 ; /* nombre des lecteurs */
6 r_mutex : semaphore  1 ; /* exclusion mutuelle pour r_number * /
7 lr_mutex : semaphore  1 ; /* exclusion mutuelle pour lr_number * /
8 lr : semaphore  1 ; /* garantit la sémantique sur les lecteurs */
9 r : semaphore  1 ; /* garantit la sémantique sur les rédacteurs */
11 procedure debut_lecture
12 P(lr) ; /* attente sur les rédacteurs */
13 P(lr_mutex) ;
14 lr_number  lr_number + 1 ;
15 if lr_number = 1 then
16 P(r) ; /* bloque l’acces aux rédacteurs */
17 end
18 V(lr_mutex) ;
19 V(lr) ;
20 end
21 procedure fin_lecture
22 P(lr_mutex) ;
23 lr_number  lr_number - 1 ;
24 if lr_number = 0 then
25 V(r) ; /* permet l’acces aux rédacteurs */
26 end
27 V(lr_mutex) ; 12
28 end
 Priorité aux Rédacteurs
Algorithm 1 : Lecteurs/Rédacteurs avec Priorités aux rédacteurs
……..
4 r_number : integer  0 ; /* nombre des rédacteurs */
5 lr_number : integer  0 ; /* nombre des lecteurs */
6 r_mutex : semaphore  1 ; /* exclusion mutuelle pour r_number * /
7 lr_mutex : semaphore  1 ; /* exclusion mutuelle pour lr_number * /
8 lr : semaphore  1 ; /* garantit la sémantique sur les lecteurs */
9 r : semaphore  1 ; /* garantit la sémantique sur les rédacteurs */
29 procedure debut_ecriture
30 P(r_mutex) ;
31 r_number  r_number + 1 ;
32 if r_number = 1 then
33 P(lr) ; /* bloque les futurs lecteurs */
34 end
35 V(r_mutex) ;
36 P(r) ; /* attend l’acces */
37 end
38 procedure fin_ecriture
39 V(r); /* permet l’acces aux rédacteurs */
40 P(r_mutex) ;
41 r_number  r_number - 1 ;
42 if r_number = 0 then
43 V(lr) ; /* permet l’acces aux lecteurs */
44 end
45 V(r_mutex) ;
46 end 13
47 end module
Priorité aux Lecteurs

14
Priorité aux Lecteurs

15
Problème : L1 L2 L3 R1 R2 R3 R1 L1 R2 L2 R3 L3

▪ Un sémaphore entre les rédacteurs (r-sem)

▪ Un sémaphore entre lecteurs et rédacteurs (lr-sem)
▪ Chaque sémaphore a sa propre file d’attente

Cas 1 : (Priorité aux lecteurs) R1 L1 L2 L3 R2 R3

Cas 2 : (Priorité aux rédacteurs) R1 R2 R3 L1 L2 L3

Cas 3 : (Priorité Egale) R1 L1 R2 L2 R3 L3

▪ lr-number : nbre de lecteurs qui peuvent utiliser la ressource partagée

▪ r-number : nbre de rédacteurs qui attendent la ressource
▪ C’est la sortie du premier rédacteur qui va jouer le jeu
▪ Le premier lecteur bloque le rédacteur
▪ Le dernier lecteur débloque le rédacteur
▪ Le sémaphore lr-mutex est utilisé pour la variable lr-number
▪ Le sémaphore r-mutex est utilisé pour la variable r-number

16