2.

Systmes synchrones
Nous avons vu quun systme synchrone est compos de phases qui sexcutent simultanment. Nous
tudions tout dabord les mcanismes de base des phases de communication avant dtudier des
systmes synchrones particuliers.
2.1 Accs synchrone ou asynchrone des ressources partages
Considrons des processus Pi qui ont accs des variables partages stockes dans une mmoire M. Le
code des processus est schmatiquement le suivant
Processus Pi
Rpter
Calculer R(i)
Lire M[R(i)]
Calculer R(i)
Ecrire M[R(i)]
Chaque processus est compos de quatre phases. Les phases de lecture et dcriture sont les celles
pendant lesquelles les processus interagissent. Cette interaction peut poser des difficults si les
processus veulent lire ou crire simultanment la mme variable.
Dans le cas synchrone, on distinguera deux politiques daccs : exclusive ou concurrente. La
politique daccs exclusif doit garantir que deux processus naccderons pas simultanment une
variable. Une telle garantie, en gnral, ne pourra tre assure que par le programmeur. Dans le cas
daccs concurrent, la politique daccs doit offrir une garantie de rsultat. Par exemple, si deux
processeurs veulent crire des valeurs diffrentes dans la mme variable, on peut garantir que lune
des deux sera crite (mais on ne sait pas laquelle) ou bien quaucune ne le sera.
Dans le cas asynchrone, on doit garantir que les accs nont pas lieu simultanment. Dans ce cas, il ne
faut autoriser quun seul processeur accder la variable. Le problme correspondant est appel
exclusion mutuelle. Ce problme sera trait dans un prochain chapitre
2.2 Communication synchrone ou asynchrone
Considrons tout dabord le cas de deux processus qui interagissent par changes de donnes (ou de
messages). Les primitives Lire et Ecrire sont remplaces par Recevoir et Envoyer. Lenvoi consiste
placer une donne dans une mmoire de communication (buffer), la rception rcuprer la donne
dans cette mmoire.
Dans le cas synchrone, lenvoi dun message interrompt lactivit du processus metteur jusqu la
rception par le processus destinataire. On parle de communication synchrone ou par rendez-vous.
Un exemple est la communication tlphonique (sans messagerie).
Dans le cas asynchrone, lmetteur envoie le message et entame une autre phase (de calcul ou de
communication) indpendamment de laction du destinataire. Un exemple est la communication par
courrier postal.
2.3 Parallel Random Access Machine (PRAM)
Une PRAM est un modle de systme parallle synchrone communiquant par une mmoire partage.

Dfinition 2.1 : Une PRAM est un ensemble de n processus identiques, numrots de 0 n-1, qui
accdent de manire synchrone une mmoire partage compose de n cases, numrotes de 0 n-1.

M0

P0

M1

Mm-1

Pn-1

P1

Figure 2.1 : PRAM

Selon les politiques daccs la mmoire, on peut obtenir quatre types de PRAM :
- EREW (Excluvive Read Exclusive Write) : deux processus ne peuvent pas lire ou crire
simultanment dans la mme case mmoire
- CRCW (Concurrent Read Concurrent Write) : deux processus peuvent lire ou crire
simultanment dans la mme case mmoire
- CREW : deux processus peuvent lire mais ne crire simultanment dans la mme case
mmoire
- ERCW
Les modles les plus couramment utiliss dont EREW et CREW.
Dfinition 2.2 : La complexit dun programme PRAM est donne par la valeur de lhorloge lors de
lexcution de la dernire phase des processus.
2.4 Rseaux de processus
Un rseau de processus est un modle de systme parallle synchrone communiquant par changes de
messages. On suppose donc que les processus sont les sommets dun graphe G = (V,E). Si (i,j) est un
arc entre les sommets i et j, alors le processus Pi peut envoyer un message Pj . Le systme
fonctionne de manire synchrone en enchanant les oprations Envoi-Rception de message (phase de
communication) et Calcul (phase de calcul). Si les buffers denvoi ou de rception sont vides, aucune
donne nest envoye ou reue (nul). Sinon un message est un lment non nul de lensemble des
messages possibles, not M.

La phase de calcul est dfinie par la fonction de transition qui, tant donn ltat du processus et les
messages reus au temps t-1, associe ltat au temps t. Lensemble des tats de Pi sera not Si. La
fonction de transition se modlise donc par :
i : Si x Min(i) Si
o in(i) est le degr entrant de Vi.
La phase de communication est dfinie par la fonction de transition qui, tant donns ltat du
processus au temps t-1 et un nud successeur, construit le message envoy au temps t ce successeur.
Lensemble des successeurs de Pi sera not Succi. La fonction de transition se modlise donc par :
i : Si x Succi M
Une excution du rseau de processus sera donc caractrise par la suite de lensemble des tats des
processus et de lensemble des messages. Si nous notons S(t), Env(t) et Rec(t) ces ensembles au
temps t, une excution sera donc dfinie par :
S(0), Env(0), Rec(0), S(1), Env(1), Rec(1), , S(t), Env(t), Rec(t)
Exemple : Gnrateur des nombres entiers pairs.

+1

x2

Les processus sont :

- P1 : dbut z := 0 ; rpter z := z+1 ; (envoyer z ; recevoir z) fin.
- P2 : dbut t := 0 ; rpter t := 2 t ; (envoyer t ; recevoir t) fin.
Les fonctions de transition correspondantes sont :
- V = {1,2,Out} , E = {(1,1), (1,2), (2,Out)}, Succ1 = {1,2}, Succ2 = {Out}
- S1 = S2 = N , M = N {nul}
- 1(s,m) = m ; 1(s,1) = 1(s,2) = s+1 ; 2(s,m) = m ; 2(s,1) = 2s ;
Dfinition 2.3 : La complexit en temps dun rseau de processus est donne par la valeur de lhorloge
lors de lexcution de la dernire phase des processus. La complexit en espace est le nombre de
processus.
Dans lexemple prcdent, on voit quun rseau de processus peut avoir une dure dexcution non
borne. Pour ce gnrateur, on constate facilement que la gnration des n premiers entiers pairs prend
un temps proportionnel n et un nombre de processus constant (2).
2.5 Election dun dirigeant (leader) sur un anneau synchrone
Llection dun dirigeant dans un rseau synchrone de processus consiste distinguer un processus
parmi n. Un tel problme se rencontre dans de nombreuses applications, la plus connue tant celle de
reconstruction du jeton dans le cas dune perte de jeton dans un systme faisant circuler un tel jeton
pour avoir accs des ressources. Le processus distingu cre un nouveau jeton de manire unique.
Supposons que les processus de notre rseau soient connects sous la forme dun anneau, c'est--dire
que G(V,E) est dfini par :

Cas unidirectionnel : E = {(Vi,Vi+1), i = 0, , n-1}

Cas bidirectionnel : E = {(Vi,Vi+1) et (Vi,Vi-1), i = 0, , n-1}
o les calculs dindice sont faits modulo n.
Supposons que les processus nont aucune information globale sur leur environnement : ils ne
connaissent pas n, ni la topologie du graphe, mais uniquement leur(s) voisin(s) par exemple en
envoyant (ou en recevant) un message gauche ou droite. Pour se distinguer les uns des autres, les
processus ne peuvent donc utiliser que leur Identit Unique (IU). Nous supposons que ces IU sont
choisies parmi un ensemble de trs grands nombres entiers et que deux processus ne possdent pas la
mme UI. Les processus possdent une variable dtat, nomme Etat, qui peut prendre deux valeurs
d et nd et est initialise nd (non dirigeant). Il possde une deuxime variable nomme Dir, prenant
des valeurs entires et initialise 0.
Ltat initial du rseau est donc caractris par :
(EI) i = 0, , n-1, Etati (0) = nd et Diri (0) = 0.
Ltat final du rseau est caractris par :
(EF) k, 0 k n-1, Etatk (T) = d et Dirk (T) = IUk et i k, Etati (T) = nd et Diri (T) = IUk.
Avant daborder la rsolution de ce problme, nous allons constater quil est impossible rsoudre
dans sa plus grande gnralit.
Thorme 2.1 : Soit PROG un rseau de n processus connects selon un anneau bidirectionnel. Si tous
les processus sont compltement identiques, en particulier ne possdent pas didentits uniques, alors
PROG ne rsoud pas le problme de llection du dirigeant.
Dmonstration : Supposons que PROG rsolve le problme et montrons que cest impossible. Soit
donc lexcution de PROG partir de (EI) et se terminant en (EF). Par induction sur t, on peut montrer
que les variables Etat et Dir de tous les processus sont identiques :
t, i,j = 0, , n-1, Etati (t) = Etatj (t) et Diri (t) = Dirj (t).
Par consquent, si un processus est tel que Etatk (T) = d, alors i k, Etati (T) = d, ce qui viole la
condition dunicit de (EF). %
Nous dduisons quil faut introduire une dissymtrie dans les processus. Le plus simple est de
demander ce que les IU soient diffrentes. Nous montrons dans la suite quil suffit alors de pouvoir
comparer les UI deux deux pour rsoudre le problme sans aucune autre connaissance sur le rseau.
Le rseau LCR (Le Lann, Chang et Roberts) rsoud le problme de llection dun dirigeant sur un
anneau en calculant le nud didentit maximum : ce nud sera le dirigeant. Informellement,
lalgorithme est le suivant : chaque processus envoie son IU et reoit celle de son voisin; il compare
cette IU la sienne ; si lIU reue est suprieure la sienne, il lenvoie au processeur suivant ; si elle
est infrieure, il ne fait rien ; si elle est gale la sienne, alors il se dclare dirigeant.
Formellement, chaque processus excute de manire synchrone lalgorithme LCR suivant :
Algorithme LCR :
Pi :
dbut
choisir IU ; /H := 0/
Etat := nd ;
Dir := IU ;
envoyer Dir droite ;

recevoir m de gauche ;
rpter : /H := H+1/
si m > Dir alors Dir := m ; envoyer Dir droite ; recevoir m de gauche ;
si m < Dir alors envoyer Nul droite ; recevoir m de gauche ;
si m = Dir alors Etat := d ; envoyer Nul droite ; recevoir m de gauche ;
fin.
Thorme 2.2 : Aprs H(LCR) = n tapes de communication, lalgorithme LCR rsoud le problme
de llection dun dirigeant pour n processus connects par un anneau unidirectionnel avec
connaissance rduite aux voisins. Le nombre maximum de messages non nuls changs est O(n2).
Dmonstration : Appelons Predi(t) lensemble des processus qui peuvent atteindre le processus Pi en
au plus t tapes de communication. On peut dfinir par rcurrence Predi(t) par Predi(0) = {i} et Predi(t)
= Predi-1(t-1) Predi(t-1). Aprs t tapes de communication de lalgorithme LCR, on a linvariant
suivant
Diri(t) = max {IUk , k Predi(t)}
mi(t) = Diri(t) ou Nul.
La proprit est vraie pour t=0. Supposons l vraie en t-1. Si ltape t, le processus Pi reoit un
message m alors, par construction,
m = mi-1(t-1) = Diri-1(t-1) = max {IUk , k Predi-1(t-1)}
De lalgorithme, on dduit :
Diri(t) = max{m, Diri(t-1)} = max{ Diri-1(t-1), Diri(t-1)}
= max{ max {IUk , k Predi-1(t-1)}, max {IUk , k Predi(t-1)}} = max {IUk , k Predi(t)}
Si ltape t, le processus Pi reoit un message Nul alors, par construction,
Diri(t) = Diri(t-1) = Diri-1(t-1) = { Diri-1(t-1), Diri(t-1)}
Ce qui conclut la rcurrence.
Plaons nous maintenant ltape n. On a alors :
Diri(n) = max {IUk , k Predi(n)} = IUmax
Soit imax le numro du processus possdant lIU maximum. On a alors
Dirimax-1(n-1) = max {IUk , k Predi(n-1)} = IUmax
mi-1(n-1) = IUmax
A ltape n, le processus imax reoit le message mi-1(n-1) = IUmax et donc affecte d sa variable Etat.
Le nombre de message ne peut pas dpasser O(n2) puisquil y a au maximum n tapes de
communication. Si les nuds sont ordonns par IU dcroissante de gauche droite alors le nombre de
messages non nuls est de O(n2). %
2.6 Election dun dirigeant sur un rseau synchrone quelconque
Supposons que G soit maintenant un graphe orient fortement connexe :
G = (V,E) ; i,j chemin de Vi Vj
Llection dun dirigeant dans un rseau synchrone de processus reprend le principe de lalgorithme
LCR en inondant les successeurs avec les identits maximales. Pour chaque Vi on note Succi
lensemble des successeurs et Predi lensemble des prdcesseurs. Chaque processus envoie lidentit
du dirigeant courant (ou nul) et reoit de chacun de ses prdcesseurs lidentit de leurs dirigeants
courants (ou nul), lensemble correspondant est not M. On obtient lalgorithme IM (inondation
maximale) :
Pi :

dbut
choisir IU ; /H := 0/

Etat := nd ;
Dir := IU ;
envoyer Dir Succ ;
recevoir M de Pred;
rpter : /H := H+1/
m := max M ;
si m > Dir alors Dir := m ; envoyer Dir Succ ; recevoir M de Pred;
si m < Dir alors envoyer Nul Succ ; recevoir M de Pred;
si m = Dir alors Etat := d ; envoyer Nul Succ ; recevoir M de Pred;
fin.
Malheureusement cet algorithme est faux. En effet, il est possible que m = Dir sans tre le maximum
global. Pour avoir le maximum global, il faut tre sr que linformation soit passe par tous les
sommets. Il y a diffrentes faons de rsoudre ce problme, lune des plus simples tant de rpter la
boucle autant de fois que le diamtre du rseau. Rappelons que le diamtre dun graphe G est :
Diam(G) = maxi,j min (chemin de Vi Vj)
Algorithme IM :
Pi :
dbut
choisir IU ; /H := 0/
Etat := nd ;
Dir := IU ;
envoyer Dir Succ ;
recevoir M de Pred;
rpter diam(G) fois: /H := H+1/
m := max M ;
si m > Dir alors Etat := nd ; Dir := m ; envoyer Dir Succ ; recevoir M de
Predi;
si m < Dir alors envoyer Nul Succi ; recevoir M de Predi;
si m = Dir alors Etat := d ; envoyer Nul Succ ; recevoir M de Pred;
fin.
Thorme 2.2 : Lalgorithme IM rsoud le problme de llection dun dirigeant pour n processus
connects par un rseau fortement connexe quelconque avec connaissance rduite aux voisins. Le
nombre maximum de messages non nuls changs est O(diam(G).n2).
Dmonstration : La dmonstration est proche de la prcdente. Elle se base sur un invariant : aprs r
tours, le maximum a atteint tous les sommets distance r. %