Vous êtes sur la page 1sur 53

SYNCHRONISATION PAR SEMAPHORES

rappels de cours , exercices

Par : HABET Mohammed-Said

Editions lAbeille, 2006

Sommaire

Leon Une : Gnralits 1. Dfinitions 1.1 processus 1.2 relations entre processus 1.3 proprits 1.4 smaphores 2. Exercices 3. Exercices Supplmentaires Leon Deux : Classiques et autres 1. Prsentation 1.1 exclusion mutuelle 1.2 prcdence des taches 1.3 Lecteurs / Rdacteurs 1.4 Producteurs / Consommateurs 1.5 Philosophes 2. Exercices 3. Exercices Supplmentaires Leon Trois : Plus formellement 1. Prsentation : formalisme de Boksenbaum 1.1 exclusion mutuelle 1.2 Lecteurs / Rdacteurs 1.3 Producteurs / Consommateurs 2. Exercices 3. Exercices Supplmentaires Leon Quatre : Variantes 1. Prsentation 1.1 smaphores de Vantilborgh 1.2 smaphores de Patil 1.3 smaphores binaires : verrous 2. Exercices 3. Exercices Supplmentaires Bibliographie

Leon Une :

Gnralits

1. Dfinitions :
1.1 Processus Un processus reprsente lexcution dun programme squentiel : cest une entit dynamique associe la suite des actions ralises par un programme squentiel (qui ,lui, est une entit statique associe la suite dinstructions qui le composent). Cette distinction entre un programme et son excution vient du fait que pour un systme dexploitation multiprogramm le processeur ne peut travailler que pour un utilisateur/ programme la fois. Cest dire que le systme dexploitation doit assurer lallocation du processeur ; mais aussi dautres ressources de la machine , aux diffrents programmes. Les diffrents processus ne sont par tout fait indpendants : tout en sexcutant en parallle ils doivent cooprer, se synchroniser . . . etc . Et cela est un rle du systme dexploitation. Remarque : notion de processus du point de vue langages de programmation La notion de processus prsente prcdemment est une notion relative aux systmes dexploitation. Il existe galement la notion de processus du point d e vue langages de programmation : dans quelques langages on peut dcrire , syntaxiquement , lactivit parallle. Pour cela il existe des structures de contrle telle que : ParBegin (dbutpar) / ParEnd (finpar). A titre dexemple : on a ci-dessous un programme parallle compos de n processus squentiels Pi (i=1,..,n): Dbutpar Processus P1 Dbut . . . Fin . . . Processus Pn Dbut . . . Fin Finpar Cette criture signifie que les n processus Pi (i=1,..,n) entament leur excution simultanment. La fin dexcution du bloc Dbutpar/Finpar a lieu lorsque tous les Pi (i=1,..,n) sont termins.

HABET M.S.

Synchronisation par smaphores - Leon 1

1.2 Relations entre processus Lorsque des processus sexcutent , ils interagissent soit en cooprant (pour partager des informations ou acclrer un calcul par exemple) , soit en concourant pour acqurir des ressources quand celles-ci sont en quantit limite. Ainsi les relations entre processus peuvent tre multiples, on en numre quelques unes dans ce qui suit : a) paralllisme : cest la simultanit de lexcution de plusieurs processus. Ce paralllisme peut tre rel : dans le cas o les diffrents processus sont excuts chacun sur un processeur diffrent. Mais dans le cas o les processus sont excuts sur un mme processeur (en temps partag par exemple) on parle de pseudo-paralllisme (c'est--dire un paralllisme simul). b) communication : Dans beaucoup dapplications , des processus peuvent avoir communiquer entre eux , pour changer des informations par exemple . Cette communication peut se faire soit par lintermdiaire de variables ou objets partags (mmoire commune) , soit par le biais d e messages : envoi et rception de messages (canaux de communication). c) synchronisation : La synchronisation consiste cadencer (contrler) lvolution des processus , et par suite loccurrence des vnements , en fonction de lhistoire passe de lensemble de ces processus. Exemple : synchronisation pour laccs une ressource critique Une ressource qui ne peut tre utilise que par un processus ,au plus, la fois est appele ressource critique . Lorsque plusieurs processus doivent utiliser une ressource critique (R.C) on doit les synchroniser en coordonnant les diffrentes demandes de chacun des processus de telle sorte qu tout moment un seul processus la fois utilise la R.C. Cela est ralis en faisant attendre les processus qui demandent utiliser la R.C sil y a dj un processus qui lutilise. Lorsque le processus qui utilise la R.C finit son utilisation , on alloue la R.C un autre processus qui la demande (et qui est en attente). Remarque : On dit que les processus qui utilisent une R.C tel qunonc prcdement sont en exclusion mutuelle pour laccs la ressource en question. Et la partie du processus qui sexcute en exclusion mutuelle est appele section critique . A titre dexemple une R.C peut tre une variable globale (variable commune plusieurs processus : la mise jour de cette variable doit se faire en exclusion mutuelle pour garantir la cohrence des donnes). Une R.C peut aussi tre un fichier , un enregistrement de fichier , un priphrique . . . etc.

1.3 Proprits Lorsquon sintresse au bon fonctionnement des systme s parallles , il convient de dterminer les proprits ncessaires qui doivent tre vrifies. a) absence dinterblocage : cest une proprit fondamentale qui exprime quun ensemble de processus ne doit pas atteindre ,lors de son excution, un tat o chaque processus reste bloqu en attente dune condition logique qui ne deviendra jamais vraie. Exemple dune situation dinterblocage : On considre deux processus P1 et P2 utilisant deux ressources critiques R1 et R2 comme suit : Processus P1 Processus P2 Dbut Dbut acqurir R1 acqurir R2 acqurir R2 acqurir R1 utiliser R1 et R2 utiliser R2 et R1 Fin Fin

HABET M.S.

Synchronisation par smaphores - Leon 1

La squence dexcution : acqurir R1 (processus P1) , acqurir R2 (processus P2) ; conduit un interblocage : le processus P1 en faisant acqurir R2 sera bloqu (car R2 est dj dtenue par P2) , le processus P2 en faisant acqurir R1 sera bloqu (car R1 est dj dtenue par P1). Remarque : Labsence dinterblocage est une proprit de sret (une proprit de sret est une proprit qui doit tre vrifie durant toute la dure du fonctionnement des processus du programme/systme parallle). b) quit : absence de famine Cette proprit est lie aux demandes daccs des ressources et/ou excution de certaines sections de programmes : toute demande dallocation de ressource doit finir par tre satisfaite. Remarque : Lquit est une proprit de vivacit (une proprit de vivacit spcifie des tats qui devront tre atteints par le systme). c) priorit : Dans quelques cas on peut avoir privilgier certains processus par rapport dautres : on dit que les processus quon a privilgi sont plus prioritaires que les autres. A titre dexemple : on peut classer les demandeurs dune ressource critique en deux catgories o lon donnera la priorit une seule catgorie pour laccs la ressource (les processus de la catgorie la moins prioritaire nauront laccs la ressource que lorsquil ny a aucun processus de la catgorie le plus prioritaire qui attende). Autre exemple : les processus urgents du systme. Il se trouve que pendant lexcution de progammes utilisateurs par le processeur , ceux-ci peuvent tre interrompus momentanment pour que le processeur excute des processus ou des tches urgents et qui sont donc plus prioritaires. 1.4 Smaphores Un smaphore est un outil de synchronisation . Il est matrialis par une variable entire laquelle est ajoute une file dattente de processus. Si s est un smaphore : il possde deux champs : val (valeur : entier) et un champ file (structure de file de BCP (Bloc de Contrle de Processus)) : Il nest possible daccder un smaphore que par deux oprations notes P et V. Les primitives P et V sont dfinies comme suit : P(s) : Dbut s.val := s.val - 1 Si s.val < 0 alors tat(p) := bloqu /* p est le processus */ insrer p dans s.file /* qui excute P(s) */ finsi Fin V(s) : Dbut s.val := s.val + 1 Si s.val 0 alors sortir un processus q de s.file tat(q) := prt finsi Fin Remarque 1 : Les primitives P et V sont excutes de manire indivisible.

HABET M.S.

Synchronisation par smaphores - Leon 1

Remarque 2 : La valeur initiale du champ val dun smaphore doit tre un nombre non ngatif. Exemple : Utilisation des smaphores pour raliser lexclusion mutuelle Une ressource critique R est utilise par un nombre quelconque de processus. Processus Ayant__utiliser_R dbut <section non critique> <utilisation de R> <section restante> fin Lutilisation de R doit se faire en exclusion mutuelle pour tous les processus concerns. Pour raliser laccs en exclusion mutuelle pour laccs R , on utilisera un smaphore initialis 1: var s : smaphore init 1;
/* s est une variable globale de type smaphore */ /* dont la valeur est initialise 1 */

Processus Ayant__utiliser_R dbut <section non critique> P(s) <utilisation de R> /* section critique */ V(s) <section restante> fin

2. Exercices :
Exercice 1 : Soit s un smaphore , on note : i(s) : valeur initiale du smaphore s ( par dfinition i(s) 0 ) np(s) : nombre doprations P(s) excutes sur s nv(s) : V(s) s nf(s) : nombre de processus qui ont franchi la primitive P(s) ( on a donc nf(s) np(s) ) Vrifier que Solution : Initialement, np(s) = nv(s) = 0 et nf(s) = 0 = min(0,i(s)) Lorsquon agit la premire fois sur le smaphore , par une primitive , on a : - si P est xcute : np(s) devient gal 1 ; ( nv(s) reste = 0 ) si i(s) 1 alors (* excution de P sans blocage *) nf(s) = 1 = min(1,i(s)) = min(np(s),i(s)+nv(s)) sinon (* i(s) = 0 : excution de P avec blocage *) nf(s) = 0 = min(1,0) = min(np(s),i(s)+nv(s)) (finsi) nf(s) = min(np(s),i(s)+nv(s)) (1)

HABET M.S.

Synchronisation par smaphores - Leon 1

- si V est xcute : nv(s) devient gal 1 ; mais np(s) = 0 et ainsi nf(s) = 0 = min(0,i(s)+nv(s)) = min(np(s),i(s)+nv(s)) Remarque: s.val = i(s)+nv(s)-np(s) ( s.val < 0 ) ( des procs bloqus en s.file) Supposons maintenant que la formule (1) reste valide aprs lexcution dun certain nombre doprations sur s ; et voyons leffet de lexcution dune primitive P ou V sur (1). Effet de P : Avant Aprs (1) nf(s)=np(s)<i(s)+nv(s) nf(s)=i(s)+nv(s)np(s) s.val >0 0 effet sur np(s) np := np+1 np := np+1 s.val 0 <0 (1) nf(s)=np(s)i(s)+nv(s) nf(s)=i(s)+nv(s)<np(s)

Lexcution de P laisse invariante la formule (1) Effet de V : Avant (1) nf(s)=np(s)i(s)+nv(s) nf(s)=i(s)+nv(s)<np(s) s.val 0 <0 Aprs effet sur nv(s) nv := nv+1 nv := nv+1 s.val >0 0 (1) nf(s)=np(s)<i(s)+nv(s) nf(s)=i(s)+nv(s)np(s)

Lexcution de V laisse invariante la formule (1) conclusion: (1) est toujours valide Exercice 2 : On considre le programme parallle suivant : var n : entier init 0 ; Dbut Dbutpar Processus P1 Dbut n := n + 1 Fin Processus P2 Dbut n := n - 1 Fin Finpar Fin

/* n entier initialis 0 */

HABET M.S.

Synchronisation par smaphores - Leon 1

1) Quel le rsultat de son excution dans les cas suivants : a) on considre les oprations sur la variable n sont indivisibles b) les oprations sur n ne sont pas indivisibles : elles peuvent tre dcomposes. 2) Dans le cas b) comment faire pour que la mise--jour de n se fasse en exclusion mutuelle. Solution : 1) a) Dans le cas de lindivisibilit de laccs n , le rsultat obtenu (aprs la fin de lexcution des deux processus P1 et P2) est n = 0. b) Dans le cas o lon peut dcomposer les oprations sur n le rsultat nest pas unique : suivant la squence dexcution considre on peut obtenir n = 0 ou n = 1 ou n = -1. En effet : Processus P1 Dbut (1) LOAD R1,n /* charger le registre R1 par n */ (2) ADD R1,1 /* additionner 1 R1 */ (3) STORE n,R1 /* ranger (R1) dans la variable n */ Fin Processus P2 Dbut (1) LOAD R2,n /* charger le registre R2 par n */ (2) SUB R2,1 /* soustraire 1 de R2 */ (3) STORE n,R2 /* ranger (R2) dans la variable n */ Fin Avec la squence (1), (2), (3), (1), (2), (3) on obtient n = 0 avec la squence (1), (1), (2), (3), (2), (3) on obtient n = 1 avec la squence (1), (1), (2), (3), (2), (3) on obtient n = -1 2) Pour que la mise--jour de n se fasse en exclusion mutuelle , il existe de nombreux moyens. Un de ces moyens est lutilisation de smaphore : var n : entier init 0 ; s : smaphore init 1 ; Dbut Dbutpar Processus P1 Dbut P(s) LOAD R1,n ADD R1,1 STORE n,R1 V(s) Fin

HABET M.S.

Synchronisation par smaphores - Leon 1

Processus P2 Dbut P(s) LOAD R2,n SUB R2,1 STORE n,R2 V(s) Fin Finpar Fin De cette manire le seul rsultat quon peut obtenir est n = 0 ; car on exclue les squences dexcutions pouvant aboutir n = 1 ou n = -1 : ds quun processus fait P(s) , lautre processus ne pourra plus accder n jusqu ce que celui qui a fait P(s) la premire fois libre laccs n en faisant V(s). Remarque : Dans la pratique, les primitives P et V sont implmentes comme des appels systme.

2. Exercices supplmentaires :
Exercice 1 : Lalgorithme dun ensemble de processus est exprim ainsi : var S : smaphore init N Processus Pi (i0) Dbut P(S) Action A V(S) Fin A laide de la formule (1) de lexercice 1 prcdent, montrer que lon ne peut avoir , tout moment, quau plus N processus en train dexcuter leur Action A. Exercice 2 : Pour calculer la somme des lments dun tableau on utilise deux processus. Lun parcoure les lments dindice impair et lautre les lments dindice pair comme suit : Const M = /* nombre dlments du tableau */ var T : Tableau[1..M] de entier ; Somme : entier init 0 ; Processus P1 var i : entier /* i est une variable locale P1 */ Dbut i := 1 Tant que (i M) faire Somme := Somme + T[i] i := i + 2 FinTantque Fin

HABET M.S.

Synchronisation par smaphores - Leon 1

10

Processus P2 var j : entier /* j est une variable locale P2 */ Dbut j := 2 Tant que (j M) faire Somme := Somme + T[j] j := j + 2 FinTantque Fin Dbut /* bloc principal */ Dbutpar P1 P2 Finpar Fin 1) Montrer , laide dun exemple dexcution , qu cause des mises jour (m--j) simultanes de la variable Somme ; on peut obtenir un rsultat erron. (on considrera que les instructions dajout la variable Somme ne sont pas indivisibles). 2) Rsoudre le problme en utilisant un smaphore dexclusion mutuelle pour laccs la variable Somme. 3) Ecrire une autre solution o lon utilisera deux autres variables globales Somme1 et Somme2 lune pour calculer la somme des lments dindice impair (qui sera uniquement accde en m--j par P1) ; lautre pour calculer la somme des lments dindice pair (qui sera uniquement accde en m--j par P2). Le rsultat Somme sera calcul comme Somme1 + Somme2 dans le bloc principal lissue de lexcution de P1 et P2 : Dbut Dbutpar P1 P2 Finpar Somme := Somme1 + Somme2 Fin (Dans ce cas il ny a pas de synchronisation (pour laccs aux variables) raliser car il ny a pas de concurrence daccs en m--j aux diffrentes variables globales).

Leon Deux :

Classiques et autres

1. Prsentation :
Dans les paragraphes suivants, il sagira de prsenter quelques problmes classiques de synchronisation, ainsi que dautres plus ou moins classiques. 1.1 Exclusion mutuelle Considrons n processus P1,P2,.Pn sexcutant en parallle et utilisant une ressource critique R comme suit : Processus Pi /* i=1,n */ dbut <section non critique> <utilisation de R> <section restante> fin On doit garantir que lutilisation de R se fasse en exclusion mutuelle : la section <utilisation de R> doit tre une section critique (S.C). Les conditions de lexclusion mutuelle sont les suivantes : a) tout instant un processus au plus peut se trouver en section critique b) un processus qui excute du code hors section critique ne doit pas empcher dautres processus daccder en section critique c) si plusieurs processus sont bloqus en attente dentrer en section critique alors quaucun autre ne sy trouve , lun deux doit y accder au bout dun temps fini. d) toute demande dentre en section critique doit tre satisfaite. Pour ce faire on peut utiliser un smaphore mutex et exprimer les algorithmes des processus Pi ainsi : var mutex : smaphore init 1;
/* mutex est une variable globale de type smaphore */ /* dont la valeur est initialise 1 */ Processus Pi /* i=1,n */

dbut <section non critique> P(mutex) <utilisation de R> /* section critique */ V(mutex) <section restante> fin On peut aisment vrifier que les conditions de lexclusion mutuelle sont respectes. Soit nsc = nf(mutex)-nv(mutex) condition a) : Le nombre de processus en S.C est gal au nombre de processus qui ont franchi P(mutex) et qui nont pas encore excut V(mutex) : on sait dj que nf(mutex) = min(np(mutex),1+nv(mutex)) si nf(mutex)=np(mutex) : nf(mutex) 1+nv(mutex) , do nf(mutex)-nv(mutex) 1 ; si nf(mutex)=1+nv(mutex) : nf(mutex) - nv(mutex) = 1 ; dans les deux cas : nf(mutex)-nv(mutex) 1 .

HABET M.S.

Synchronisation par smaphores -

Leon 2

12

condition b) : tels quexprims les processus Pi nagissent pas sur le smaphore mutex en dehors du protocole dentre ou de sortie de la S.C. condition c) : il suffit de vrifier que sil y a des processus qui attendent alors il y a un processus en S.C : si au moins un processus attend alors nf(mutex)<np(mutex) et ainsi nsc = nf(mutex)-nv(mutex) = 1 processus en S.C condition d) : cette proprit est satisfaite si la file dattente du smaphore est gre en F.I.F.O (First In First Out) ; - si un processus bloqu est en tte de file ; ds que le processus qui est en S.C en sort en excutant V , le processus bloqu en tte de file est dbloqu pour accder la S.C - sinon : un processus quelconque dans la file finira par arriver en tte de file (lorsque les processus bloqus avant lui auront accd en S.C) ; et il sera rveill son tour ds que V(mutex) est excute. 1.2 Prcdence des tches Dans quelques applications , notamment les applications temps rel , certaines tches (processus) doivent avoir une relation de prcdence : une tche ne peut entamer son excution que lorsque dautres tches ont termin leurs excution. Exemple : Considrons un systme comportant deux tches T1 et T2 et o T1 doit prcder T2 T1

T2 La synchronisation peut tre ralise simplement comme suit : var s : smaphore init 0;
/* s est une variable globale de type smaphore */ /* dont la valeur est initialise 0 */

Processus T1 dbut <Excution> V(s) fin

Processus T2 dbut P(s) <Excution> fin

1.3 Lecteurs / Rdacteurs On considre un objet (un fichier par exemple) qui nest accessible que par deux catgories doprations : les lectures et les critures. Plusieurs lectures (consultations) peuvent avoir lieu simultanment ; par contre les critures (mises jour) doivent se faire en exclusion mutuelle. On appellera lecteur un processus faisant des lectures et rdacteur un processus faisant des critures. Il sagit donc de raliser la synchronisation entre lecteurs et rdacteurs en respectant les contraintes suivantes : - exclusion mutuelle entre lecteurs et rdacteurs : si un lecteur demande lire et quil y a une criture en cours , la demande est mise en attente. De mme que si un rdacteur demande crire et quil y a au moins une lecture en cours , la demande est mise en attente. - exclusion mutuelle entre rdacteurs : si un rdacteur demande crire et quil y a une criture en cours , la demande est mise en attente. Lattente dun processus lecteur / rdacteur peut tre assimile au blocage du processus dans une file de smaphore. Pour satisfaire les contraintes ci-dessus , on peut procder comme suit : var s,mutex : smaphore init 1,1 ; nl : entier init 0 ;

HABET M.S.

Synchronisation par smaphores -

Leon 2

13

Processus Lecteur Dbut . . . P(mutex) nl := nl + 1 si nl=1 alors P(s) finsi V(mutex) Lecture P(mutex) nl := nl 1 si nl=0 alors V(s) finsi V(mutex) . . . Fin

Processus Rdacteur Dbut . . . P(s) Ecriture V(s) . . . Fin

1.4 Producteurs / Consommateurs On considre deux classes de processus : - les producteurs : produisent des informations , - les consommateurs : consomment les informations produites par les producteurs. Pour que les producteurs et consommateurs puissent sexcuter en parallle , ils partagent un tampon dans lequel seront stockes les informations (messages) produites et en attente dtre consommes. La synchronisation peut sexprimer comme suit : var S1,S2,mutex : smaphore init N,0,1 ; /* N : taille du tampon */ Processus Producteur Processus Consommateur Dbut Dbut Cycle /* rpeter indfiniment */ Cycle <Produire un message> P(S2) P(S1) P(mutex) P(mutex) <Prelever un message> <Dposer le message> V(mutex) v(mutex) V(S1) V(S2) <Consommer le message> FinCycle FinCycle Fin Fin 1.5 Philosophes Cinq philosophes sont assis sur des chaises autour dune table ronde pour philosopher et manger des spaghettis.Sur la table sont disposes cinq assiettes , cinq fourchettes et un plat de spaghettis qui est toujours plein. Chaque philosophe passe son temps penser puis manger. Pour manger il doit utiliser les deux fourchettes situes de par et dautres de son assiette. Aprs avoir mang, le philosophe repose les deux fourchettes sur la table et se remet penser. Et ainsi de suite. C'est--dire que le schma dun philosophe est : Philosophe i (i=0,4) Dbut Cycle Penser Manger /* ncessite deux fourchettes */ FinCycle Fin

HABET M.S.

Synchronisation par smaphores -

Leon 2

14

2 La solution crire doit viter linterblocage.

type e_ph = (pensif,attendant,mangeant) ; var etat : tableau[0..4] de e_ph init (pensif, pensif, pensif, pensif, pensif) ; S : tableau[0..4] de smaphore init (0,0,0,0,0) ; mutex : smaphore init 1 ; Processus Philosophe i (i=0..4) Dbut Cycle <Penser> P(mutex) Si (etat[Droite(i)]=mangeant) ou (etat[Gauche(i)]=mangeant) Alors etat[i] := attendant V(mutex) P(S[i]) Sinon etat[i] := mangeant V(mutex) Finsi <Manger> P(mutex) etat[i] := pensif si (etat[Droite(i)]=attendant) et (etat[Droite(Droite(i))]<>mangeant) alors etat[Droite(i)] := mangeant V(S[Droite(i)]) finsi Si (etat[Gauche(i)]=attendant) et (etat[Gauche(Gauche(i))]<>mangeant) alors etat[Gauche(i)] := mangeant V(S[Gauche(i)]) Finsi V(mutex) FinCycle Fin

HABET M.S.

Synchronisation par smaphores -

Leon 2

15

fonction Droite(i : 0..4) : 0..4 ; var d : entier Dbut d := i 1 si d<0 alors d := 4 finsi Droite := d Fin fonction Gauche(i : 0..4) : 0..4 ; Dbut Gauche := (i+1) mod 5 Fin Remarque : la solution prsente prsente le risque de famine. Il serait intressant de trouver une solution quitable.

2. Exercices :
Exercice 1 : Soit N processus Pi (i=1..N) et un processus Ps. Les processus Pi (i=1..N) remplissent une zone tampon pouvant contenir M messages, un seul la fois tant autoris dposer son message. Le processus Pi qui remplit la dernire case du tampon active le processus Ps qui fait alors l'impression de tous les messages dposs dans le tampon. Durant cette impression, les processus Pi (i=1..N) ne sont pas autoriss accder au tampon. Ecrire les algorithmes des processus Pi (i=1..N) et Ps. Solution : Si on note : nm = nombre de messages contenus dans le tampon , le schma des processus considrs peut sexprimer comme suit : Processus Pi ( i = 1..N ) Processus Ps Dbut Dbut <Fabriquer un message> Cycle <si le tampon est occup <attendre jusqu tre alors attendre sinon reveill par un des bloquer laccs au tampon> processus Pi> <Dposer le message> <Imprimer tous les messages> nm := nm + 1 nm := 0 <si nm=M alors activer Ps <liberer laccs au tampon> sinon liberer laccs au FinCycle tampon> Fin Fin On peut assimiler lattente dun processus au blocage de celui-ci dans une file de smaphore. Soit Spriv un smaphore priv au processus Ps qui y se bloquera en attente dtre rveill ; et mutex un smaphore dexclusion mutuelle pour laccs au tampon. On peut crire les algorithmes des processus Pi et Ps comme suit : var Spriv,mutex : smaphore init 0,1 ; nm : entier init 0 ;

HABET M.S.

Synchronisation par smaphores -

Leon 2

16

Processus Pi ( i = 1..N ) Dbut <Fabriquer un message> P(mutex) <Dposer le message> nm := nm + 1 si nm=M alors V(Spriv) sinon V(mutex) finsi Fin

Processus Ps Dbut Cycle P(Spriv) <Imprimer tous les messages> nm := 0 V(mutex) FinCycle Fin

Exercice 2 : On considre trois processus P1, P2 et P3. Le processus P1 produit des messages qu'il dpose dans un tampon T1. P2 prlve les messages contenus dans T1, les traite puis dpose les rsultats dans un tampon T2. P3 prlve les messages contenus dans T2 et les consomme. 1) Ecrire les algorithmes de P1, P2 et P3 de faon garantir le non-interblocage. 2) On considre maintenant que les Pi (i=1..3) travaillent sur le mme tampon T (au lieu de T1 et T2). Rtudier la question 1). Solution : 1) Processus P1 /* producteur */ Processus P2 /* consommateur & */ Dbut Dbut /* producteur */ 1 : <Produire un message> 2 : <Prlever un message de T1> <Dpt du message dans T1> <Traiter le message> Aller_ 1 <Dpt du rsultat dans T2> Fin Aller_ 2 Processus P3 /* consommateur */ Fin Dbut 3 : <Prlever un message de T2> <Traitement du message> Aller_ 3 Fin La synchronisation peut sexprimer comme suit : var S1,S2,S3,S4,mutex1,mutex2 : smaphore init n1,0,n2,0,1,1 ;
/* ni=taille de Ti, i=1,2 */

Processus P1 Dbut 1 : <Produire un message> P(S1) P(mutex1) <Dpt du message dans T1> V(mutex1) V(S2) Aller_ 1 Fin

Processus P2 Dbut 2 : P(S2) P(mutex1) <Prlever un message de T1> V(mutex1) V(S1) <Traiter le message> P(S3) P(mutex2) <Dpt du rsultat dans T2> V(mutex2) V(S4) Aller_ 2 Fin

HABET M.S.

Synchronisation par smaphores -

Leon 2

17

Processus P3 Dbut 3 : P(S4) P(mutex2) <Prlever un message de T2> V(mutex2) V(S3) <Traitement du message> Aller_ 3 Fin 2) Si les trois processus P1, P2 et P3 travaillent sur le mme tampon T ; une situation dinterblocage peut se produire : si au dbut P1 remplit le tampon T ensuite P2 prlve un message de T pour le traiter. Avant que P2 ne termine le traitement , P1 dpose un autre message dans T (ce qui remplit T de nouveau). A ce moment aucun des trois processus ne peut plus progresser : P1 ne pourra plus dposer de nouveaux messages (T plein) ; P2 ne peut pas dposer le rsultat (T plein) ; P3 ne peut pas prlever des messages de T (T ne contient aucun message destin P3). Une solution ce problme serait de partager T en deux tampons T1 et T2 : T1 contiendra les messages destins P2 ; T2 contiendra les messages destins P3. Ce qui ramne la solution de 1). Exercice 3 : On considre un ensemble de six tches squentielles {A, B, C, D, E ,F}. La tche A doit prcder les tches B, C, D. Les tches B et C doivent prcder la tche E. Les tches D et E doivent prcder la tche F. Raliser la synchronisation de ces tches en utilisant les smaphores. Solution : On peut reprsenter le graphe de prcdence des tches {A,B,C,D,E,F.} comme suit : A

F La synchronisation des tches en question peut sexprimer comme suit : var SA,SB,SC,SD,SE : smaphore init 0,0,0,0,0 ; Tche A Dbut Excution V(SA) ; V(SA) ; Fin Tche B Dbut P(SA) Excution V(SB) Fin Tche C Dbut P(SA) Excution V(SC) Fin

V(SA)

HABET M.S.

Synchronisation par smaphores -

Leon 2 Tche F Dbut P(SE) ; P(SD) Excution Fin

18

Tche D Dbut P(SA) Excution V(SD) Fin

Tche E Dbut P(SB) ; P(SC) Excution V(SE) Fin

Exercice 4 : Soit P0 et P1 deux processus parallles se partageant deux ressources R1 et R2. Les algorithmes de ces deux processus sont crits comme suit : var s1,s2 : smaphore init 1,1 ; Processus P0 Processus P1 Dbut Dbut a0: (1) P(s1) (2) utiliser R1 (3) P(s2) utiliser R1 et R2 V(s1) V(s2) Aller_ a0 Fin Fin a1: (1) P(s2) (2) utiliser R2 (3) P(s1) utiliser R1 et R2 V(s2) V(s1) Aller_ a1

1) quelle situation anormale peut conduire lexcution de ces deux processus ? 2) donner une solution ce problme. Solution : 1) Considrons la squence dexcution : (1) , (1) , (2) , (2) , (3) , (3) aprs lexcution de (1) , (1) s1.val devient gal s2.val = 0 lorsque P0 excutera (3) il se bloquera , et P1 se bloquera lorsquil excutera (3) : les deux processus sont bloqus sans aucun moyen dtre rveills : interblocage. 2) Une solution ce problme est de procder comme suit : var s1,s2 : smaphore init 1,1 ; Processus P0 Processus P1 Dbut Dbut a0: P(s1) a1: P(s2) utiliser R1 utiliser R2 V(s1) V(s2) P(s1) P(s1) P(s2) P(s2) utiliser R1 et R2 utiliser R1 et R2 V(s2) V(s2) V(s1) V(s1) Aller_ a0 Aller_ a1 Fin Fin

19 Synchronisation par smaphores - Leon 2 Exercice 5 : Un magasin peut accueillir un nombre limit de clients. Cette limite est reprsente par le nombre N de chariots disponibles lentre du magasin. Un client qui arrive attend sil ny a aucun chariot disponible. Lorsquun client acquiert un chariot il entre au magasin pour effectuer ses achats. Ds quil termine, il libre son chariot en sortant du magasin. On peut assimiler les clients des processus parallles et les chariots des ressources partages. 1) Ecrire lalgorithme de chaque client. 2) On considre maintenant quil y a deux catgories de clients : les abonns et les non abonns . Il ny a pas dexclusion mutuelle entre abonns et non abonns , par contre les abonns ont la priorit pour lacquisition des chariots. Ecrire les algorithmes des processus abonns et non abonns . Solution : 1) Il suffit dutiliser un smaphore initialis N var S : smaphore init N ; /* S.val=N */ Processus Client Dbut P(S) /* prendre un chariot */ Effectuer les achats V(S) /* librer le chariot */ Fin 2) Dans ce cas, on utilisera un smaphore Si (i=1,2) pour chaque classe de processus : un processus qui doit attendre sera mis dans S1.file sil est abonn et dans S2.file sinon. Ainsi on pourra privilgier le rveil des processus bloqus dans la file de S1 : lorsquun processus quelconque rend son chariot il vrifiera dabord sil y a au moins un processus abonn qui attend auquel cas il en rveillera un ; sinon il rveillera un processus non abonn ventuellement. Pour cela, on utilisera galement les entiers suivants : uC : nombre dutilisateurs ,en cours, de chariots = nombre de clients dans le magasin ; na1 : nombre de processus abonns qui attendent ; na2 : nombre de processus non abonns qui attendent. Pour assurer laccs en exclusion mutuelle ces variables, il faudra utiliser un smaphore dexclusion mutuelle. Do les dclarations suivantes : var S1,S2,mutex : smaphore init 0,0,1 ; /* S1.val=0; S2.val=0;
HABET M.S. mutex.val=1 */

uC,na1,na2 : entier init 0,0,0 ; /* uC=0; na1=0; na2=0 */ Les algorithmes des processus en question seront exprims comme suit : Processus Client_Abonn Processus Client_Non_Abonn Dbut Dbut P(mutex) P(mutex) si uC < N alors si uC < N alors uC := uC + 1 uC := uC + 1 V(mutex) V(mutex) sinon sinon na1 := n1 + 1 na2 := na2 + 1 V(mutex) V(mutex) P(S1) P(S2) finsi finsi

HABET M.S.

Synchronisation par smaphores -

Leon 2 Effectuer les achats

20

Effectuer les achats P(mutex) si na1 > 0 alors na1 := na1 1 V(S1) sinon /* na1=0 */ si na2 > 0 alors na2 := na2 1 V(S2) sinon /* na1=na2=0 */ uC := uC 1 finsi finsi V(mutex) Fin

P(mutex) si na1>0 alors na1 := na1 1 V(S1) sinon /* na1=0 */ si na2 > 0 alors na2 := na2 1 V(S2) sinon /* na1=na2=0 */ uC := uC 1 finsi finsi V(mutex) Fin

Exercice 6 : Une piscine peut accueillir N nageurs au plus. Ce nombre N est le nombre de paniers disponibles pour les habits des nageurs. A lentre comme la sortie les nageurs entrent en comptition pour lacquisition dune cabine dhabillage/dshabillage, il y a C cabines (1 <= C << N). Chaque nageur effectue les oprations : Proc Nageur Dbut <se dshabiller> <nager> <se rhabiller> Fin On peut assimiler ces nageurs des processus concurrents; les cabines et les paniers tant des ressources partages. 1) Ecrire lalgorithme des processus Nageur synchroniss par smaphores. 2) On considre maintenant que les nageurs entrants sont prioritaires pour lacquisition des cabines. Recrire lalgorithme des processus Nageur. Solution : 1) var S1,S2 : smaphore init N,C ; Processus Nageur Dbut P(S1) /* prendre un panier */ P(S2) /* occuper une cabine */ <se dshabiller> V(S2) /* librer la cabine */ <nager> P(S2) /* occuper une cabine */ <se rhabiller> V(S2) /* librer la cabine */ V(S1) /* librer le panier */ Fin

HABET M.S.

Synchronisation par smaphores -

Leon 2

21

2) Une cabine libre nest alloue un nageur sortant que sil ny a aucun nageur entrant qui attend. Par contre il ny a pas dexclusion mutuelle entre entrants et sortants. var S1,Se,Ss,mutex : smaphore init N,0,0,1 ; Ucb,ne,ns : entier init 0,0,0; Processus Nageur Dbut P(S1) Demander_cabine(ne,Se) <se dshabiller> Liberer_Cabine <nager> Demander_cabine(ns,Ss) <se rhabiller> Liberer_Cabine V(S1) Fin La procdure Demander_Cabine est crite comme suit : Procedure Demander_Cabine(var n : entier ; var s : smaphore) Dbut P(mutex) si Ucb<C alors Ucb := Ucb + 1 V(mutex) sinon n := n + 1 V(mutex) P(s) finsi Fin La procdure Liberer_Cabine est crite comme suit : Procedure Liberer_Cabine Dbut P(mutex) si ne>0 alors ne := ne 1 V(Se) sinon si ns>0 alors ns := ns 1 V(Ss) sinon Ucb := Ucb -1 finsi finsi V(mutex) Fin

HABET M.S.

Synchronisation par smaphores -

Leon 2

22

Exercice 7 : Rsoudre le problme des lecteurs rdacteurs dans les cas suivants : 1) priorit aux Rdacteurs , 2) quit : toute demande de lecture / criture est satisfaite. Solution : 1) priorit aux rdacteurs : ds quun rdacteur fait sa demande dcriture , toutes les nouvelles demandes de lecture sont mises en attente ; elles ne seront prises compte que lorsquil ny a plus dcritures en cours et/ou en attente. var S,S2,S3,mutex,mutex2 : smaphore init 1,1,1,1,1 ; nl : entier init 0 ; Processus Lecteur Processus Rdacteur Dbut Dbut P(S3) P(mutex2) P(S2) nra := nra + 1 P(mutex) si nra=1 alors P(S2) finsi nl := nl + 1 V(mutex2) si nl=1 alors P(S) finsi P(S) V(mutex) Ecriture V(S2) V(S) V(S3) P(mutex2) Lecture nra := nra 1 P(mutex) si nra=0 alors V(S2) finsi nl := nl - 1 V(mutex2) si nl=0 alors V(S) finsi Fin V(mutex) Fin 2) Pour raliser lquit on reprendra la solution dcrite dans le paragraphe 1.3 laquelle on ajoutera un smaphore dattente commune Se. Remarque : Il est ncessaire que les files des smaphores utiliss soient gres de manire quitable , par exemple une gestion F.I.F.O. var S,Se,mutex : smaphore init 1,1,1 ; nl : entier init 0 ; Processus Lecteur Processus Rdacteur Dbut Dbut P(Se) P(Se) P(mutex) P(S) nl := nl + 1 V(Se) si nl=1 alors P(S) finsi Ecriture V(mutex) V(S) V(Se) Fin Lecture P(mutex) nl := nl 1 si nl=0 alors V(S) finsi V(mutex) Fin Exercice 8 : Soit un pont , voie unique, travers pas des vhicules en sens inverse (sens A et sens B). A tout moment, le pont ne doit contenir que des vhicules allant dans un sens uniquement. On assumera que le nombre de vhicules pouvant traverser le pont dans un sens est illimit. On assimilera les vhicules des processus parallles synchroniss par smaphores. Ecrire les algorithmes de chaque classe de processus.

HABET M.S.

Synchronisation par smaphores -

Leon 2

23

Solution : 1) Il y a exclusion mutuelle entre les deux classes de processus : tout moment le pont ne doit contenir que des vhicules allant dans le sens A ou des vhicules allant dans le sens B. Pour raliser cette exclusion mutuelle on considrera que lorsquun vhicule de type A (respectivement B) arrive lentre du pont trois situations peuvent se prsenter : - i l y a dj des vhicules de type A (respt B) sur le pont , auquel cas le vhicule peut sengager sur le pont ; - il y a au moins un vhicule de type B (respt A) sur le pont , dans ce cas il doit attendre jusqu ce que tous les vhicules de type B (respt A) soient sortis du pont ; - il ny a aucun vhicule sur le pont, le vhicule sengage sur le pont tout en assurant que sil y a des vhicules de type B (respt A) qui se prsenteront lentre le pont, il sarrteront jusqu ce tous les vhicules A (respt B) sortent du pont.

. . . A Sa pont : AA . . . oux BB . . . Sab : barrire daccs au pont Sa : barrire faisant attendre les A(s) sil y a au moins un B sur le pont Sb : idem pour les B(s) et A. oux : ou exclusif

Sab B . . . Sb

Ce qui donne la solution suivante : var Sa,Sb,Sab : smaphore init 1,1,1 ; na,nb : entier init 0 ; Processus A Processus B Dbut Dbut P(Sa) P(Sb) na := na + 1 nb := nb + 1 si na=1 alors P(Sab) finsi si nb=1 alors P(Sab) finsi V(Sa) V(Sb) Traverser le pont Traverser le pont P(Sa) P(Sb) na := na 1 nb := nb 1 si na=0 alors V(Sab) finsi si nb=0 alors V(Sab) finsi V(Sa) V(Sb) Fin Fin Exercice 9 : Rsoudre le problme du producteur/consommateur dans lhypothse que tampon est non born (tampon de taille infinie) .

HABET M.S.

Synchronisation par smaphores -

Leon 2

24

Solution : Les algorithmes des producteurs / consommateurs sexprimeront comme suit : var S,mutex : smaphore init 0,1 ; Processus Producteur Processus Consommateur Dbut Dbut Cycle Cycle <Produire un message> P(S) P(mutex) P(mutex) <Deposer le message> <Prelever un message> V(mutex) V(mutex) V(S) <Consommer le message> FinCycle FinCycle Fin Fin Exercice 10 : N processus ,non cycliques, travaillent par point de rendez-vous : Proc P1 . . . Proc Pi ... Proc PN Dbut Dbut Dbut . . . . . . . pt rdv . . . . . . . . . pt rdv . . . pt rdv . . . . . . . . Fin Fin Fin Programmer le rendez-vous de ces processus en utilisant les smaphores. Solution : var att,mutex : smaphore init 0,1 ; na : entier init 0 ; Processus Pi (1 i N) Dbut . . P(mutex) na := na + 1 si na < N alors V(mutex) P(att) sinon V(mutex) finsi V(att) /* rveil des processus bloqus */ . . . Fin

HABET M.S.

Synchronisation par smaphores -

Leon 2

25

Exercice 11 : Une ressource partageable R peut tre utilise par au plus N processus simultanment. Un processus voulant utiliser R alors que celle-ci nest pas disponible annule sa demande. Ecrire lalgorithme dun tel processus. Solution : var mutex : smaphore init 1 ; nd : entier init N ; Processus Utilisant_R Dbut P(mutex) si nd > 0 alors nd := nd 1 V(mutex) Utiliser R P(mutex) nd := nd + 1 finsi V(mutex) Fin Exercice 12 : Un systme dinterruption simple comporte deux bascules : - de masquage m (interruption masque si m=0, dmasque si m=1) - de demande dinterruption t fonctionnant ainsi : le signal dinterruption tente de faire t := t + 1 : si linterruption est dmasque , t passe immdiatement 1 sinon, t passera 1 au moment du dmasquage ; Raliser ce systme en utilisant les smaphores. Solution : var m,t,mutex : smaphore init 1,0,1 ; masque : boolen init faux ; A larrive du signal , le matriel fait P(m) /* demande de passage */ V(t) /* dclenchement de la routine dinterruption */ V(m) /* libration */ Pour masquer linterruption on fait : P(mutex) si (masque = faux) alors masque := vrai V(mutex) P(m) sinon V(mutex) finsi

HABET M.S.

Synchronisation par smaphores -

Leon 2

26

Pour dmasquer linterruption on fait : P(mutex) si (masque = vrai) alors masque := faux V(m) finsi V(mutex) Pour traiter linterruption on excute le processus : Processus Traitant_dinterruption Dbut Cycle P(t) Routine dinterruption Fincycle Fin Exercice 13 : On veut faire fonctionner deux processus P1 et P2 en coroutines. Raliser ce fonctionnement en utilisant les smaphores. Solution : Il suffit dutiliser , pour chacun des processus un smaphore priv o il sy bloquera lorsque lautre processus sexcute : var S1,S2: smaphore init 0,0 ; Linstruction reprise(P2) (excute par P1) sera ralise par : V(S2) P(S1) linstruction reprise(P1) (excute par P2) sera ralise par : V(S1) P(S2) Exercice 14 : On considre un ensemble de processus Pi (i0) o chaque processus est identifi par un entier unique ni (ni>0). Ces processus utilisent une ressource R avec la contrainte que le processus Pj demandeur de R ny accde que lorsque la somme des entiers ,associs aux processus en train dutiliser R, est divisible par nj. Raliser la synchronisation de ces processus en utilisant les smaphores.

HABET M.S.

Synchronisation par smaphores -

Leon 2

27

Solution : Une solution est de procder comme suit : var S : tableau[0..] de smaphore init (0,..,0) ; mutex : smaphore init 1 ; bloqu : tableau[0..] de boolen init (faux,..,faux) ; Somme,na : entier init 0,0 ; Procedure Reveil Dbut Tant que k tel que (bloqu[k] et ((Somme mod nk)=0)) faire Somme := Somme + nk na := na 1 bloqu[k] := faux V(S[k]) FinTantque Fin Processus Pj (j0) Dbut /* nj est lentier associ Pj */ P(mutex) si ((Somme mod nj)=0) alors Somme := Somme + nj Reveil V(mutex) sinon na := na + 1 bloqu[j] := vrai V(mutex) P(S[j]) finsi Utiliser R P(mutex) Somme := Somme nj Reveil V(mutex) Fin

3. Exercices Supplmentaires :
Exercice 1 : rivire Pour traverser une rivire, sont disposs N pavs espacs de telle sorte quune personne voulant traverser la rivire devra poser les pieds successivement sur tous ces pavs sans passer par dessus une personne qui se trouverait devant elle allant dans le mme sens ou venant dans le sens oppos. On distingue deux types de personnes voulant traverser cette rivire : les gens de la rive gauche et les gens de la rive droite. En assimilant ces personnes des processus parallles synchroniss par smaphores , crire les algorithmes des processus de chaque classe en garantissant le non interblocage.

HABET M.S.

Synchronisation par smaphores -

Leon 2

28

Exercice 2 : fumeurs On considre un systme avec trois processus fumeurs et un processus agent . Chaque fumeur roule une cigarette puis la fume et ce de faon continue. Pour fumer une cigarette trois ingrdients sont ncessaires : du tabac, du papier et des allumettes. Lun des fumeurs possde du tabac , lautre du papier , et le troisime des allumettes. Lagent a une rserve infinie de ces trois ingrdients. Lagent met sur la table deux des trois ingrdients. Le fumeur auquel manque le(s) ingrdient(s) supplmentaires peut rouler et fumer sa cigarette puis le signale lagent. Lagent met alors deux autres ingrdients sur la table et le cycle se rpte. Ecrire les algorithmes des processus fumeurs et agent. Exercice 3 : coiffeur Un salon de coiffure est compos dune salle dattente contenant n chaises , et de la pice de coiffure qui contient une chaise pour le coiffeur et une chaise pour le client. Sil ny a aucun client , le coiffeur sassied sur sa chaise et dort. Si un client entre dans le salon et trouve que toutes les chaises de la salle dattente sont occupes , il sen va. Si le coiffeur est occup , aprs que le client constate quil y a des chaises libres , le client sassied sur une chaise libre. Si le coiffeur est endormi, le client le rveille. En assimilant les clients et le coiffeur des processus parallles synchroniss par smaphores , crire les algorithmes de ces processus. Exercice 4 : rond point On considre un rond-point comportant N voies (N 3) numrotes de 0 N-1. Tous les vhicules empruntant le rond-point tournent dans le mme sens (sens croissant des indices des voies). En assimilant les vhicules des processus , et le rond-point une ressource partage crire les algorithmes des processus synchroniss pas smaphores ; en considrant que le nombre de vhicules pouvant se trouver dans le rond-point est illimit, mais doivent tre issus dune mme voie (exclusion mutuelle entre les vhicules de voies diffrentes). Exercice 5 : On considre deux producteurs P1 et P2 qui produisent des messages et les dposent dans deux tampons T1 et T2 respectivement (Ti pour Pi, i=1,2). Deux processus consommateurs C1 et C2 consomment les messages : C1 ceux de T1 , C2 ceux de T2 ; avec la contrainte que lorsquun processus Ci (i=1,2) consomme un message , il attendra que lautre processus Cj (j=3-i) ait consomm un message lui aussi pour continuer consommer un autre message (Rendez-vous entre C1 et C2 aprs chaque consommation). Synchroniser ces processus en utilisant les smaphores. Exercice 6 : Une ressource R peut tre utilise par au plus N processus simultanment. Un processus voulant utiliser R doit attendre si R n'est pas disponible. On considre qu'il y a m classes de processus Ci (i=1,..,m). Il n' y a pas d'exclusion mutuelle entre les diffrentes classes. Par contre, les processus de Ci (i<m) sont prioritaires sur ceux de Cj tel que j>i. Ecrire les algorithmes des processus de diffrentes classes synchroniss par smaphores.

Leon Trois :

Plus formellement

1. Prsentation : Formalisme de Boksenbaum


Soit { S k =

a
j1

kj

x j b k 0 , k=1,..,m } un systme dinquations dcrivant

les contraintes de synchronisation dun problme , avec : akj , bk : constantes entires ; bk 0 pour k=1,..,m xj : variables entires si on fait xj := xj + 1 , cela implique sk := sk + akj ce qui quivalent : faire sk := sk + 1 akj fois si akj>0 ou faire sk := sk 1 |akj| fois si akj<0 on assimile linquation sk un smaphore s initialis bk : et lorsquon fait xj := xj + 1 cela implique : faire akj fois V(s) si akj>0 , ou faire |akj| fois P(s) si akj<0 Remarque : Lorsquil faut faire une suite de |akj| fois P(s) (avec |akj| 2) il faut le faire en exclusion mutuelle ; sinon une situation dinterblocage peut se produire. Pour raliser cette exclusion mutuelle il suffit dutiliser un autre smaphore, par exemple mutex : P(mutex) pour k := 1 |akj| faire /* k est une variable locale */ P(s) finpour V(mutex) Dans ce qui suit , sera prsente lapplication du formalisme quelques problmes de synchronisation. 1.1 exclusion mutuelle On considre un ensemble de processus pi qui excutent une action A en exclusion mutuelle. Processus pi Dbut . . x1 := x1 + 1 Action A x2 := x2 + 1 . . Fin x1 : nombre dactions A commences depuis t 0 x2 : nombre dactions A termines depuis t 0 (t0 est un temps de rfrence, par exemple temps de dbut de premier processus concern par laction A)

HABET M.S.

Synchronisation par smaphores - Leon 3

30

contrainte : on doit avoir x1 x2 1 ce qui est quivalent avoir x2 x1 + 1 0 ; on associera donc cette inquation un smaphore s initialis 1. Les processus en question sexprimeront comme ainsi : Processus pi Dbut . . P(s) Action A V(s) . . Fin 1.2 Lecteurs / Rdacteurs Deux classes de processus se partagent en exclusion mutuelle une ressource : un fichier. contraintes : un lecteur ne fait que de lectures sur le fichier , le nombre de lectures simultanes est non born , un rdacteur ne fait que des critures sur un fichier , un seul rdacteur pouvant crire la fois , exclusion mutuelle entre lecteurs et rdacteurs pour laccs au fichier. Si on note : nl : nombre de lectures en cours , nr : nombre de rdactions en cours ; on doit avoir : nr + signe(nl) 1 ; signe(a) = 0 si a=0 1 si a1 Processus Lecteur Processus Rdacteur Dbut Dbut . . . . faire nl := nl + 1 faire nr := nr + 1 Lire Ecrire nl := nl 1 nr := nr 1 . . . . Fin Fin La contrainte 1 nr signe(nl) 0 sera reprsente par un smaphore s initialis 1. nl := nl + 1 : si nl passe de 0 1 on fait P(s) nl := nl 1 : si nl passe de 1 0 on fait V(s) nr := nr + 1 : on fait P(s) nr := nr 1 : on fait V(s) Et on utilisera , en plus du smaphore s , une variable entire nl et par consquent un smaphore dexclusion mutuelle pour la manipulation de celle-ci.

HABET M.S.

Synchronisation par smaphores - Leon 3

31

Ce qui donne la solution suivante : Processus Lecteur Dbut . . P(mutex) nl := nl + 1 si nl=1 alors P(s) finsi V(mutex) Lire P(mutex) nl := nl 1 si nl=0 alors V(s) finsi V(mutex) . . Fin

Processus Rdacteur Dbut . . P(s) Ecrire V(s) . . Fin

1.3 Producteurs / Consommateurs Un tampon de taille N est partag par deux classes de processus : les producteurs et les consommateurs. Les producteurs produisent des messages quil dposent dans le tampon. Les consommateurs prlvent les messages du tampon et les consomment. Notons : x : nombre de messages dposs depuis t 0 y : nombre de messages prlevs depuis t 0 Les contraintes sont : yx xy+N ce qui quivalent : xy0 : smaphore S1 init ialis 0 y x + N 0 : smaphore S2 initialis N Les processus producteur et consommateur procdent comme suit : Processus Producteur Processus Consommateur Dbut Dbut . . . . : Fabriquer un message : faire y := y + 1 faire x := x + 1 prlever un message dposer le message Traiter le message Aller_ Aller_ . . . . Fin Fin De lincrmentation x := x + 1 on obtient : P(S2) V(S1) de y := y + 1 on obtient : P(S1) V(S2)

HABET M.S.

Synchronisation par smaphores - Leon 3

32

Do : Processus Producteur Processus Consommateur Dbut Dbut . . . . : Fabriquer un message : P(S1) P(S2) prlever un message dposer le message V(S2) V(S1) Traiter le message Aller_ Aller_ . . . . Fin Fin Remarque : Pour laccs au tampon, il faut ajouter un smaphore dexclusion mutuelle : P(mutex) /* mutex init 1 */ Accs au tampon /*Dpt ou prlvement du message */ V(mutex)

2. Exercices :
Exercice 1 : On considre une ressource R utilise par N processus au plus simultanment. 1) Ecrire la (les) contrainte(s) (inquation(s) rgissant le problme). 2) En dduire la synchronisation des processus en question. Solution : 1) En notant : x le nombre de processus en train dutiliser R. La contrainte que lon doit avoir est : x N 2) Linquation de 1) est quivalente N x 0 qui sera traduite par smaphore S initialis N. Processus Utilisant_R Dbut . . x := x + 1 /* incrmenter le nombre dutilisateurs de R */ utiliser R x := x - 1 /* dcrmenter le nombre dutilisateurs de R */ . . Fin x := x + 1 x := x - 1 On aura donc : engendre la dcrmentation de N x , sera traduite par P(S) , engendre lincrmentation de N x , sera traduite par V(S) ; Processus Utilisant_R Dbut . . P(S) utiliser R V(S) . . Fin

HABET M.S.

Synchronisation par smaphores - Leon 3

33

Exercice 2 : On considre le problme des lecteurs/rdacteurs tel qunonc au paragraphe 1.2 avec lhypothse que le nombre de lectures simultanes est born. 1) Ecrire la (les) contrainte(s) (inquation(s) rgissant le problme). 2) En dduire les algorithmes des processus Lecteurs et Rdacteurs synchroniss par smaphores. Solution : 1) En notant : nl : nombre de lectures en cours , nr : nombre de rdactions en cours ; on doit avoir : nr + signe(nl) 1 nl N Les deux inquations ci-dessus peuvent tre rcrites en linquation : N . nr + nl N ou de manire quivalente N N . nr nl 0 : do lutilisation dun smaphore S initialis N. 2) Si on fait nl := nl + 1 : cela se traduit par P(S) nl := nl 1 : par V(S) nr := nr + 1 : par une suite de N fois P(S) nr := nr 1 : par une suite de N fois V(S) Remarque : Si plusieurs rdacteurs entament de faire la squence des N fois P(S) ; il peut y avoir interblocage ; exemple : deux rdacteurs ,lors de leur excution, font alternativement P(S) au bout de N/2 P(S) chacun , la valeur de S devient nulle et les deux rdacteurs se bloqueront sans aucun moyen dtre rveills. Do la ncessit de faire de la squence des N P(S) une section critique. Et on obtient : var S,mutex : smaphore init N,1 ; Processus Lecteur Processus Rdacteur Dbut var k : entier ; . Dbut . . P(S) . Lecture P(mutex) V(S) pour k := 1 N faire . P(S) . finpour Fin V(mutex) Ecriture pour k := 1 N faire V(S) finpour Fin Remarque : Il aurait t plus simple de conserver la solution du paragraphe 1.2 prcdent , en encadrant la section L i r e des processus lecteurs comme suit P(SN) Lire V(SN) o SN est un smaphore initialis N.

HABET M.S.

Synchronisation par smaphores - Leon 3

34

Exercice 3 : On considre une ressource R qui peut tre utilise par deux classes de processus A et B. Le nombre dutilisations simultanes est illimit. Par contre les deux classes A et B sont mutuellement exclusives. Et de plus, on considre que les processus de la classe B sont plus prioritaires que ceux de A pour laccs R. 1) Ecrire la (les) contrainte(s) (inquation(s) rgissant le problme). 2) En dduire les algorithmes des processus de A et B synchroniss par smaphores. Solution : 1) Pour reprsenter la priorit en question on introduit une antichambre (salle dattente !) par laquelle les processus de A et B doivent passer ; mais en autorisant uniquement un seul processus A de sy trouver. Pour cela on introduit une barrire supplmentaire pour les processus de A. En notant : na : nombre de processus de la classe A en cours dutilisation de la ressource R nb : nombre de processus de la classe B en cours dutilisation de la ressource R nat : nombre de processus de la classe A dans lantichambre nbt : nombre de processus de la classe B dans lantichambre nar : nombre de processus de la classe A pouvant franchir la barrire en mme temps on a les inquations : signe(na) + signe(nb) 1 nat + signe(nbt) 1 nar 1 qui sont quivalentes respectivement : 1 signe(na) signe(nb) 0 smaphore S1 initialis 1 1 nat signe(nbt) 0 smaphore S2 initialis 1 1 nar 0 smaphore S3 initialis 1

. . . un la fois A A oux BB . . . B . . . ressource R : AA . . . oux BB . . .

HABET M.S.

Synchronisation par smaphores - Leon 3

35

2) Processus A Dbut faire nar := nar + 1 faire nat := nat + 1 faire na := na + 1 nat := nat - 1 nar := nar 1 Utiliser R na := na - 1 Fin

Processus B Dbut faire nbt := nbt + 1 faire nb := nb + 1 Utiliser R nb := nb - 1 nbt := nbt 1 Fin

Les algorithmes des processus des deux classes sont comme suit var S1,S2,S3,mutex1,mutex2,mutex3 : smaphore init 1,1,1,1,1,1 ; na,nb,nbt : entier init 0,0,0 ; Processus A Processus B Dbut Dbut P(S3) P(mutex2) P(S2) nbt := nbt + 1 P(mutex1) si nbt=1 alors P(S2) finsi na := na + 1 V(mutex2) si na=1 alors P(S1) finsi P(mutex3) V(mutex1) nb := nb + 1 V(S2) si nb=1 alors P(S1) finsi V(S3) V(mutex3) Utiliser R Utiliser R P(mutex1) P(mutex3) na := na - 1 nb := nb 1 si na=0 alors V(S1) finsi si nb=0 alors V(S1) finsi V(mutex1) V(mutex3) Fin P(mutex2) nbt := nbt 1 si nbt=0 alors V(S2) finsi V(mutex2) Fin Exercice 3 : Cinq processus (trois producteurs P1 , P2 , P3 et deux consommateurs C1 , C2) se partagent un tampon de M cases en mmoire centrale. Les producteurs P1 et P2 fabriquent des messages qui seront consomms par C1 ; et le producteur P3 fabrique des messages qui seront consomms par C2. A tout instant le tampon ne doit contenir que des messages destins soit C1 seulement , soit C2 seulement. 1) Ecrire la (les) contrainte(s) (inquation(s) rgissant le problme). 2) Ecrire les algorithmes des diffrents processus synchroniss par smaphores. Solution : 1) Notons n1 : nombre de messages produits par P1 et/ou P2 contenus dans le tampon , n2 : nombre de messages produits par P3 contenus dans le tampon ; x : nombre de processus pouvant accder simultanment au tampon. Les contraintes respecter sont : 0 ni M ; i=1,2 signe(n1) + signe(n2) 1 0x1

HABET M.S.

Synchronisation par smaphores - Leon 3

36

2) Les processus en question sexpriment ainsi : Processus Pi (i=1,2) Dbut i: Fabriquer un message faire n1 := n1 + 1 faire x := x + 1 deposer le message x := x 1 Aller_ i Fin Processus P3 Dbut 3: Fabriquer un message faire n2 := n2 + 1 faire x := x + 1 deposer le message x := x 1 Aller_ 3 Fin

Processus C1 Dbut 1: faire n1 := n1 - 1 faire x := x + 1 retirer un message x := x 1 Traiter le message Aller_ 1 Fin Processus C2 Dbut 2: faire n2 := n2 - 1 faire x := x + 1 retirer un message x := x 1 Traiter le message Aller_ 2 Fin

Les inquations de 1) peuvent tre crites comme suit : n1 0 smaphore S1 initialis 0 M n1 0 smaphore S2 initialis M n2 0 smaphore S3 initialis 0 M n2 0 smaphore S4 initialis M 1 signe(n1) signe(n2) 0 smaphore S5 initialis 1 1x0 smaphore mutex initialis 1 Lincrmentation n1 := n1 + 1 engendre : V(S1) P(S2) si n1 passe de 0 1 alors P(S5) La dcrmentation n1 := n1 - 1 engendre : P(S1) V(S2) si n1 passe de 1 0 alors P(S5) Il en est de mme pour n2 (remplacer S1 par S3 et S2 par S4). Ce qui nous conduit la solution suivante : var S1,S2,S3,S4,S5,mutex,mutex1,mutex2 : smaphore init 0,M,0,M,1,1,1,1; Processus Pi (i=1,2) Processus C1 Dbut Dbut i: Fabriquer un message 1: P(S1) P(mutex1) P(mutex) n1 := n1 + 1 retirer un message si n1=1 alors P(S5) finsi V(mutex) V(mutex1) V(S2) P(S2) P(mutex1) P(mutex) n1 := n1 - 1 deposer le message si n1=0 alors V(S5) finsi V(mutex) V(mutex1) V(S1) Traiter le message Aller_ i Aller_ 1 Fin Fin

HABET M.S.

Synchronisation par smaphores - Leon 3

37

Processus P3 Dbut 3: Fabriquer un message P(mutex2) n2 := n2 + 1 si n2=1 alors P(S5) finsi V(mutex2) P(S4) P(mutex) deposer le message V(mutex) V(S3) Aller_ 3 Fin

Processus C2 Dbut 2: P(S3) P(mutex) retirer un message V(mutex) V(S4) P(mutex2) n2 := n2 - 1 si n2=0 alors V(S5) finsi V(mutex2) Traiter le message Aller_ 2 Fin

Exercice 4 : On considre trois classes de processus A=(ai) , B=(bi) , C=(ci) dans lesquelles le nombre de processus de chaque classe pouvant sexcuter simu ltanment est respectivement 1 , 2 et 3. Ces trois classes sont en exclusion mutuelle. 1) Ecrire la (les) contrainte(s) (inquation(s) rgissant le problme). 2) Ecrire les algorithmes des processus des diffrentes classes synchroniss par smaphores. Solution : 1) Soit n1 : nombre de processus de la classe A en train de sexcuter n2 : nombre de processus de la classe B en train de sexcuter n3 : nombre de processus de la classe C en train de sexcuter Les contraintes que lon doit avoir sont : ni i ; i=1,2,3 signe(n1) + signe(n2) + signe(n3) 1 quivalentes : i ni 0 ; i=1,2,3 1 signe(n1) signe(n2) signe(n3) 0 2) Les algorithmes des processus de A , B et C sont les suivants : var mutex1,mutex2,mutex3,Sc,S1,S2,S3 : semaphore init 1,1,1,1,1,2,3; n1,n2,n3 : entier init 0,0,0; Processus A Processus B Processus C Dbut Dbut Dbut P(mutex1) P(mutex2) P(mutex3) n1 := n1 + 1 n2 := n2 + 1 n3 := n3 + 1 si n1=1 alors si n2=1 alors si n3=1 alors P(Sc) P(Sc) P(Sc) finsi finsi finsi V(mutex1) V(mutex2) V(mutex3) P(S1) P(S2) P(S3) Execution Execution Execution V(S1) V(S2) V(S3) P(mutex1) P(mutex2) P(mutex3) n1 := n1 1 n2 := n2 1 n3 := n3 1 si n1=0 alors si n2=0 alors si n3=0 alors V(Sc) V(Sc) V(Sc) finsi finsi finsi V(mutex1) V(mutex2) V(mutex3) Fin Fin Fin

HABET M.S.

Synchronisation par smaphores - Leon 3

38

Exercice 5 : On considre le problme des cinq philosophes (paragraphe 1.5 de la leon 2) , o lon ajoute la condition supplmentaire qu tout moment quatre philosophes au plus sont assis autour de la table ; cela pour viter le risque dinterblocage d au nombre et la disposition des fourchettes autour de la table. Ainsi le schma dun philosophe est : Philosophe i (i=0,4) Dbut Cycle Sasseoir Penser Prendre les fourchettes (la droite puis la gauche) Manger Reposer les fourchettes Se lever FinCycle Fin 1) Ecrire la (les) contrainte(s) (inquation(s) rgissant le problme). 2) Ecrire les algorithmes des processus philosophes synchroniss par smaphores. Solution : 1) Soit n : nombre de philosophes assis autour de la table ni : dtenteurs de la fourchette i (i=0,..,4) Les contraintes que lon doit avoir sont : n4 ni 1 ; i=0,..,4 desquelles on peut obtenir : 4n0 1 ni 0 ; i=0,..,4 2) var accs : smaphore init 4 ; S : tableau[0..4] de smaphore init 1 ::0..4 ; Processus Philosophe i (i=0..4) Dbut Cycle P(accs) /* 4 philosophes au plus sont assis autour de la table */ <Penser> P(S[i]) /* prendre la fourchette i */ P(S[(i+1) mod 5]) /* prendre la fourchette (i+1) mod 5 */ <Manger> V(S[i]) /* reposer la fourchette i */ V(S[(i+1) mod 5]) /* reposer la fourchette (i+1) mod 5 */ V(accs) FinCycle Fin

HABET M.S.

Synchronisation par smaphores - Leon 3

39

3. Exercices Supplmentaires :
Exercice 1 : Un parking pour automobiles comporte N places. On considre que les vhicules (entrants ou sortants) sont des processus. 1) a) Ecrire la (les) contrainte(s) (inquation(s) rgissant le problme). b) Ecrire les algorithmes des processus automobiles synchroniss par smaphores. 2) On considre maintenant que lentre au parking , ou la sortie de celui-ci se fait par une longue passerelle pouvant contenir plusieurs vhicules , mais allant dans une seule voie (entre ou sortie). Lorsque des vhicules dsirent entrer au parking alors que dautres vhicules dsirent en sortir on donnera la priorit ceux qui sortent. a) Ecrire la (les) contrainte(s) (inquation(s) rgissant le problme). b) Ecrire les algorithmes des processus automobiles synchroniss par smaphores. Exercice 2 : On considre une ressource R utilises par trois classes C1,C2 et C3 en exclusion mutuelle (entre les classes). Le nombre de processus de chaque classe utilisant la ressource un instant donn est illimit. 1) On considre que la classe C1 est prioritaire sur les deux autres. a) Ecrire la (les) contrainte(s) (inquation(s) rgissant le problme). b) Ecrire les algorithmes des processus des classes C1 , C2 et C3 synchroniss par smaphores. 2) Mmes questions que prcdemment en considrant quil ny a pas de priorit entre les classes , et il y a quit (toute demande dutilisation de la ressource R doit tre satisfaite). Exercice 3 : On considre le problme du pont (exercice 8 de la leon 2) ; o lon ajoute les hypothses suivantes : nombre de vhicules allant dans le se ns A N nombre de vhicules allant dans le sens B M priorit des vhicules allant dans le sens B 1) Ecrire la (les) contrainte(s) (inquation(s) rgissant le problme). 2) Ecrire les algorithmes des processus des classes A et B synchroniss par smaphores. Exercice 4 : On considre le problme du lecteurs/rdacteurs (paragraphe 1.3 de la leon 2) , o lon dcide de donner la priorit aux lecteurs : une lecture nest pas retarde par une criture en attente mais seulement par une criture en cours. 1) Ecrire la (les) contrainte(s) (inquation(s) rgissant le problme). 2) Ecrire les algorithmes des processus lecteurs et rdacteurs synchroniss par smaphores.

Leon Quatre :

Variantes

1. Prsentation :
Il existe de nombreuses variantes des smaphores (dits simples ou smaphores de Dijkstra). Dans ce qui suit on prsentera les smaphores de Vantilborgh, de Patil et les smaphores binaires. 1.1 Smaphores de Vantilborgh Le franchissement de lopration P (dans les smaphores simples) par un processus p peut tre vu comme lacquisition dun ticket par celui-ci. Lexcution de V par p est ,ainsi, la restitution dun ticket par le processus p. Vantilborgh a dfini une variante des smaphores qui permet un processus de prciser le nombre de tickets quil dsire obtenir ou quil restitue. Les primitives P et V sexcutent comme suit : P(n,s) : Dbut Si n s.val alors s.val := s.val n sinon tat(p) := bloqu /* p est le processus qui excute P(n,s) */ rang(p) := n insrer p dans s.file finsi Fin V(n,s) : Dbut s.val := s.val + n Tant que ( q s.file) et (rang(q) s.val) faire s.val := s.val rang(q) sortir le processus q de s.file tat(q) := prt finTantque Fin Exemple : Lecteurs / Rdacteurs On considre le problme des lecteurs/rdacteurs (paragraphe 1.3 de la leon 2) auquel on ajoute la condition que le nombre de lectures simultanes est limit N. En notant : nl : nombre de lectures en cours , nr : nombre de rdactions en cours ; on doit avoir : N . nr + nl N ou de manire quivalente N N . nr nl 0 : do lutilisation dun smaphore S initialis N.

HABET M.S.

Synchronisation par smaphores -

Leon 4

41

Si on fait nl := nl + 1 : cela se traduit par P(1,S) nl := nl 1 : par V(1,S) Si on fait nr := nr + 1 : cela se traduit par P(N,S) nr := nr 1 : par V(N,S) Et on aura donc : var S : smaphore init N; Processus Lecteur Processus Rdacteur Dbut Dbut . . . . P(1,S) P(N,S) Lecture Ecriture V(1,S) V(N,S) . . . . Fin Fin Remarque : En conservant lalgorithme des lecteurs tel quel et en rcrivant lalgorithme des rdacteurs ainsi : Processus Rdacteur Dbut . . P(N,S) Ecriture V(1,S) V(N-1,S) . . Fin on donne la priorit aux lecteurs : si un rdacteur est en train dcrire et quil y a des lecteurs et des rdacteurs en attente ; alors lorsquil termine dcrire il fera dabord V(1,S) , ce qui libre un lecteur, puis V(N-1,S) , ce qui peut librer N-1 lecteurs.

1.2 Smaphores de Patil La primitive P multiple a t dfinie ,par Patil, comme suit : P(S1,...,Sk) : Dbut Si ( j tel que Sj.val0) alors Se bloquer jusqu ce que ( j Sj.val>0) finsi Pour j := 1 k Faire Sj.val := Sj.val - 1 FinPour Fin

HABET M.S.

Synchronisation par smaphores -

Leon 4

42

Remarque 1 : La primitive V(s) conserve sa dfinition habituelle , savoir lincrmentation de s.val (ce qui peut ,ventuellement, rveiller un processus bloqu cause dun P sur s). Remarque 2 : Limportance des smaphores de Patil rside dans le fait que dans quelques applications un processus peut avoir besoin dexcuter successivement plusieurs primitives P (simples) sur des smaphores diffrents : cest le cas par exemple dun processus qui a besoin de plusieurs ressources. En procdant par la primitive P de Patil on peut viter ,dans certains cas, linterblocage. Soit , par exemple, deux processus P1 et P2 sexcutant comme suit : var s1,s2 : smaphore init 1,1 ; Processus P1 Processus P2 Dbut Dbut P(s1) P(s2) P(s2) P(s1) utiliser R1 et R2 utiliser R2 et R1 V(s2) V(s2) V(s1) V(s1) Fin Fin On constate que lon peut tomber dans une situation dinterblocage (considrer la squence P(s1) (proc. P1) P(s2) (proc. P2) P(s2) (proc. P1) P(s1) (proc. P2)). En utilisant la primitive P de Patil on peut viter cet interblocage. On crit donc : Processus P1 Processus P2 Dbut Dbut P(s1,s2) P(s2,s1) utiliser R1 et R2 utiliser R2 et R1 V(s1) V(s2) V(s2) V(s1) Fin Fin Exemple : Fumeurs On considre le problme des fumeurs de cigarettes (tel qunonc dans lexercice supplmentaire 2 de la leon 2). En associant chaque ingrdient un smaphore , plus un smaphore priv pour le processus agent, on obtient la solution suivante : var Tabac,Papier,Allumettes,S : smaphore init 0,0,0,1 ; Processus Fumeur_0 Dbut 0: P(papier,Allumettes) <Rouler et Fumer une cigarette> V(S) Aller_ 0 Fin Processus Fumeur_1 Dbut 1: P(Tabac,Allumettes) <Rouler et Fumer une cigarette> V(S) Aller_ 1 Fin

HABET M.S.

Synchronisation par smaphores -

Leon 4

43

Processus Fumeur_2 Dbut 2: P(Tabac,papier) <Rouler et Fumer une cigarette> V(S) Aller_ 2 Fin Processus Agent var i : entier Dbut : P(S) i := Random(0,2)
/* nombre alatoire

0..2 selon i faire 0 : dbut <mettre sur la V(papier) V(Allumettes) fin 1 : dbut <mettre sur la V(Tabac) V(Allumettes) fin 2 : dbut <mettre sur la V(Tabac) V(papier) fin finselon Aller_ Fin

*/

table du papier et des allumettes>

table du tabac et des allumettes>

table du tabac et du papier>

1.3 Smaphores binaires : les verrous Un smaphore binaire est un smaphore (simple) dont le champ val (valeur) ne peut prendre que les valeurs 0 ou 1. Un concept quivalent est le verrou dont le champ val est de type boolen ; c'est--dire quil ne peut prendre que les valeurs faux ou vrai. Si v est un verrou , les primitives ENQ et DEQ manipulant ce verrou sexcutent , de manire indivisible , comme suit : ENQ(v) : Dbut /* p est le processus qui excute ENQ(v) */ Si v.val=vrai alors v.val := faux Sinon < Insrer p dans v.file > tat(p) := bloqu FinSi Fin

HABET M.S.

Synchronisation par smaphores -

Leon 4

44

DEQ(v) : Dbut Si (v.file non vide) alors < extraire un processus q de v.file > tat(q) := prt Sinon v.val := vrai FinSi Fin Remarque : Les primitives ENQ et DEQ sont aussi dnommes Lock et Unlock respectivement. Exemple : ressource critique Lexclusion mutuelle pour lutilisation dune ressource critique peut sexprimer comme suit : var mutex : verrou init vrai;
/* mutex est une variable globale de type verrou */ /* dont la valeur est initialise vrai */ Processus Pi /* i=1,n */

dbut <section non critique> ENQ(mutex) <utilisation de R> /* section critique */ DEQ(mutex) <section restante> fin Remarque : Lutilisation dENQ et DEQ la place de P et V ne donne pas toujours le mme rsultat , par exemple : var s : smaphore init 0 ; Processus p Dbut V(s) V(s) P(s) P(s) Action A Fin le processus p arrive excuter son Action A.

En faisant le remplacement : var s : verrou init faux ; Processus p Dbut DEQ(s) DEQ(s) ENQ(s) ENQ(s) Action A Fin le processus p narrive pas excuter son Action A : il est bloqu en excutant le second ENQ(s).

HABET M.S.

Synchronisation par smaphores -

Leon 4

45

2. Exercices :
Exercice 1 : On considre un ensemble de (n+1) processus P1 ,......, Pn, Pn+1 o les Pi ,i=1..n prcdent Pn+1 dans lexcution : Pn+1 ne peut sexcuter effectivement que lorsque tous les Pi ,i=1..n se sont achevs. Raliser la synchronisation de ces processus en utilisant les smaphores de Vantilborgh. Solution : On peut exprimer la synchronisation des processus Pi ,i=1..n+1 comme suit : var s : smaphore init 0 ; Processus Pi (i=1..n) Processus Pn+1 Dbut Dbut Execution V(1,s) Fin P(n,s) Execution Fin

Exercice 2 : Programmer le problme des lecteurs / rdacteurs laide des smaphores de Vantilborgh avec les contraintes suivantes : exclusion mutuelle entre lecteurs et rdacteurs , exclusion mutuelle entre rdacteurs , nombre de lectures simultanes limit N (N 1) , priorit aux rdacteurs. Solution : On procde comme dans lexercice 2 de la leon 3. On obtient les contraintes suivantes : N nl N . nr 0 smaphore S1 initialis N smaphore S2 initialis N N N . nlt nrt 0 1 nlr 0 smaphore S3 initialis 1 Les lecteurs et rdacteurs font : Processus Lecteur Processus Rdacteur Dbut Dbut faire nlr := nlr + 1 faire nrt := nrt + 1 faire nlt := nlt + 1 faire nr := nr + 1 faire nl := nlr + 1 Ecriture nlt := nlt - 1 nr := nr - 1 nlr := nlr 1 nrt := nrt 1 Lecture Fin nlr := nlr - 1 Fin Les algorithmes des processus des deux classes sont donc comme suit : var S1,S2,S3 : smaphore init N,N,1 ; Processus Lecteur Processus Redacteur Dbut Dbut P(1,S3) P(1,S2) P(N,S2) P(N,S1) P(1,S1) Ecriture V(N,S2) V(N,S1) V(1,S3) V(1,S2) Lecture Fin

HABET M.S.

Synchronisation par smaphores -

Leon 4

46

V(1,S1) Fin Exercice 3 : On considre le problme du producteur/consommateur , o le tampon est de longueur N (N cases). Les producteurs produisent des messages de taille variable (pouvant varier de 1 N cases). Les consommateurs consomment les messages indiffremment de leur taille. Ecrire les algorithmes des processus producteur et consommateur synchroniss par smaphores de Vantilborgh. Solution : Les processus producteurs/consommateurs excutent : Processus Producteur Processus Consommateur Dbut Dbut : <Produire un message : <Retirer du tampon un de taille i> /* 1 i N */ message de taille j> <Dpt du message dans le tampon> Aller_ Fin Fin <Traiter le message (de taille j)> Aller_

Pour assurer la synchronisation on procdera comme suit : var S1, mutex : smaphore init N,1; S2 : tableau[1..N] de smaphore init (0,..,0);
/* S1.val reprsente le nombre de cases vides du tampon */ /* S2[k] smaphore pour les consommateurs de messages de taille k */

Processus Producteur Dbut : <Produire un message de taille i> /* 1 i N */ P(i,S1) P(1,mutex) <Dpt du message dans le tampon> V(1,mutex) V(1,S2[i]) Aller_ Fin

Processus Consommateur Dbut : P(1,S2[j]) P(1,mutex) <Retirer du tampon un message de taille j> V(1,mutex) V(j,S1) <Traiter le message (de taille j)> Aller_ Fin

Exercice 4 : Rsoudre le problme des cinq philosophes (paragraphe 1.5 de la leon 2) en utilisant les smaphores de Patil. Solution : On peut associer chaque fourchette un smaphore dexclusion mutuelle : var Fourchette : tableau[0..4] de smaphore init (1,1,1,1,1) ; Processus Philosophe i (i=0..4)

HABET M.S.

Synchronisation par smaphores - Leon 4 Dbut Cycle <Penser> P(Fourchette[i],Fourchette[(i+1) mod 5]) <Manger> V(Fourchette[i]) V(Fourchette[(i+1) mod 5]) FinCycle Fin

47

Exercice 5 : Rsoudre lexercice 3 de la leon 2 en utilisant les smaphores de Patil. Solution : La synchronisation peut tre ralise comme suit : var SA, SB, SC, SD, SE : smaphore init 0,0,0,0,0 ; Tche A Tche B Tche C Dbut Dbut Dbut Excution P(SA) P(SA) V(SA) ; V(SA) ; V(SA) Excution Excution Fin V(SB) V(SC) Fin Fin Tche D Dbut P(SA) Excution V(SD) Fin Tche E Dbut P(SB,SC) Excution V(SE) Fin Tche F Dbut P(SE,SD) Excution Fin

Exercice 6 : Rsoudre le problme des producteurs/consommateurs (paragraphe 1.4 de la leon 2) en utilisant les verrous. Solution : Soit N le nombre de messages que peut contenir le tampon. On peut utiliser une variable entire nm pour compter le nombre messages contenus dans le tampon. On bloquera laccs au tampon pour les producteurs lorsque nm devient suprieur ou gal N. Et on bloquera laccs au tampon pour les consommateurs lorsque nm devient nul. var S1,S2,m,mutex : vrou init vrai,faux,vrai,vrai ; nm : entier init 0 ;

HABET M.S.

Synchronisation par smaphores -

Leon 4

48

Processus Prod Dbut : <Produire un message> ENQ(S1) ENQ(m) nm := nm + 1 Si nm<N alors DEQ(S1) finsi DEQ(m) ENQ(mutex) <Dpt du message> DEQ(mutex) DEQ(S2) Aller_ Fin

Processus Cons Dbut : ENQ(S2) ENQ(m) nm := nm 1 Si nm>0 alors DEQ(S2) finsi DEQ(m) ENQ(mutex) <Prlever un message> DEQ(mutex) DEQ(S1) <Traitement du message> Aller_ Fin

Exercice 7 : Implmenter les verrous laide des smaphores de Dijkstra. Solution : Pour implmenter un verrou v on lui associera les variables suivantes : var S,mutex : smaphore init 0,1 ; n : entier init 0 ; b : boolean init valeur_initiale(v) ; les primitives ENQ et DEQ peuvent sexprimer comme suit : ENQ(v) : Dbut P(mutex) Si b alors b := faux V(mutex) Sinon n := n + 1 V(mutex) P(S) FinSi Fin DEQ(v) : Dbut P(mutex) Si n>0 alors n := n 1 V(S) Sinon b := vrai FinSi V(mutex) Fin

HABET M.S.

Synchronisation par smaphores -

Leon 4

49

3. Exercices Supplmentaires :
Exercice 1 : Soit deux classes de processus L et R qui sexcutent comme suit : var Sa,Sb : smaphore init n,n; /* n >= 1 */ Processus i de L Processus j de R Dbut Dbut P(n,Sb) P(1,Sb) P(1,Sa) P(n,Sa) V(n-1,Sb) Action A V(1,Sb) V(n,Sa) Action A V(1,Sb) V(1,Sa) Fin Fin 1) Discuter les proprits : dabsence dinterblocage , dabsence de famine (quit), de priorit ; pour les processus de L et R. 2) Mme question si lon remplace , dans lalgorithme des L , les deux instructions V(n-1,Sb) et V(1,Sb) par V(n,Sb) uniquement.

Exercice 2 : Implmenter les primitives de Vantilborgh en utilisant les smaphores de Dijkstra. Exercice 3 : Rsoudre lexercice 3 (sur la prcdence de tches) de la leon 2 en utilisant les smaphores de Patil. Exercice 4 : Rsoudre le problme des lecteurs / rdacteurs (1.3 de la leon 2) en utilisant les verrous (smaphores binaires). Exercice 5 : Implmenter les smaphores (simples) laide des verrous. Exercice 6 : Lorsque la file dattente dun smaphore est gre en F.I.F.O on parle de dfinition forte des smaphores. Lorsque la file est gre comme un ensemble (choix alatoire du processus dbloquer) on parle de dfinition faible des smaphores. Trouver une solution , qui soit quitable, au problme de lexclusion mutuelle en utilisant la dfinition faible des smaphores. Exercice 7 : On dfinit une primitive P : P(s,p) : s : smaphore , p : paramtre = 0 . . 1 P fonctionne de la mme manire que le P simple ; sauf que lorsque le processus qui lexcute se bloque, il est insr en tte de s.file lorsque p = 0 , et en queue de s.file lorsque p = 1.

HABET M.S.

Synchronisation par smaphores -

Leon 4

50

On considre une ressource R qui peut tre utilise par au plus N processus simultanment. Un processus voulant utiliser R attend si celle-ci nest pas disponible. 1) Ecrire lalgorithme dun processus ayant utiliser R en utilisant les primitives P et V. 2) On considre maintenant quil y a deux classes C1 et C2 de processus ayant utiliser R. Il ny a pas dexclusion mutuelle entre C1 et C2, par contre les processus de C1 sont prioritaires sur ceux de C2 pour laccs R. Ecrire les algorithmes des processus de C1 et C2 en utilisant les primitives P et V. N.B. : Dans 1) et 2) on suppose que la primitive V rveille toujours le processus qui se trouve en tte de file, lorsque celle-ci nest pas vide.

Bibliographie

Andr F. , Herman D. , Verjus J.-P. Synchronisation de programmes parallles Dunod , 1984 Beauquier J. , Brard B. Systmes dexploitation , concepts et algo rithmes Ediscience international , 1993 Ben-Ari M. Processus concurrents (traduction franaise) Masson , 1986 Bouzefrane S. Les systmes dexploitation Dunod , 2003 Crocus Systmes dexploitation des ordinateurs Dunod , 1975 Kaiser C. Cours Systmes informatiques B (polycopi) Conservatoire National des Arts et Mtiers - Paris , 2000 Krakowiak S. Principes des systmes dexploitation Dunod , 1987 Lucas M. Paralllisme (support de cours) Ecole Nationale Suprieure de Mcanique de Nantes , 1989 Padiou G. , Sayah A. Techniques de synchronisation pour les applications parallles Cepadues , 1990 Peterson J.L. , Silberschatz A. Operating system concepts Addison Wesley , 1985 Raynal M. Algorithmique du paralllisme le problme de lexclusion mutuelle Dunod , 1984

Schiper A. Programmation concurrente Presses polytechniques romandes , 1986 Tanenbaum A.S. Operating systems , design and implementation Prentice-Hall , 1987 Thorin M. Paralllisme : gnie logiciel temps rel Dunod , 1990