Ce support est associé au support de cours partagé ici : https://www.slideshare.net/lodieDescharmes/cours-dalgorithmique-distribue-20102011 Support de cours réalisé pour les étudiants en IMR (Informatique Multimédia et Réseau) de l'ENSSAT (http://www.enssat.fr/), année scolaire 2010-2011. Bien que j'aie été amenée à faire ce cours, je ne me considère vraiment pas comme une experte dans le domaine : si vous y voyez une erreur surtout n'hésitez pas à me le signaler, je mettrai le support à jour pour essayer de continuer à partager quelque-chose de correct.

1. Annexe 1
Exemple de la recette
Autre expression distribuée
Exemple séquentiel : la recette de la mousse au chocolat
1. Chauffer le chocolat
2. Casser les œufs
3. Battre les blancs
4. Mélanger les jaunes et le sucre
5. Mélanger le chocolat et le résultat de (4)
6. Mélanger les blancs et le résultat de (5)
Première décomposition possible : en fonction des ressources nécessaires à l’exécution du
programme (Four, Batteur, Mixeur)  exemple du cours
Autre proposition de décomposition du même exemple : en fonction d’un autre type de
ressources, les « cuisiniers » disponibles
• Un adulte qui peut manipuler les appareils électriques et avec la dextérité nécessaire
aux opérations « délicates » : casser les œufs et incorporer les blancs
• Un enfant qui peut aider aux autres tâches
 2 processus A, E
Processus A « adulte » Processus E « enfant »
(A1) chauffer_chocolat (A2)
casser_oeufs (A3)
battre_blancs (A4)
mélanger_blancs_ b (A5)
(E1) a = mélanger_jaunes_sucre (E2)
b = mélanger_chocolat_ a (E3)
Expression de synchronisation
A3 ≤ E2
E3 ≤ A5
Si i < j, Ai ≤ Aj, Ei ≤ Ei
@elodescharmes

2. Annexe 1.1
Exemple de la recette
Autre expression distribuée
Exemple séquentiel : la recette de la mousse au chocolat
Idée : distribuer l’exemple en fonction des ressources disponibles en termes de « mains
libres ». Quand le chocolat est en train de fondre, le cuisinier peut en profiter pour faire
d’autres tâches. Idem pour le temps pendant lequel les œufs sont montés en neige à l’aide du
batteur (on suppose que l’on utilise un modèle qui ne nécessite pas de tenir l’appareil).
Pour modéliser cela, il faut détailler la tâche « chauffer le chocolat » en deux parties : celle
qui nécessite une manipulation, et celle qui correspond à la tâche de chauffe, sans
manipulation nécessaire.
Les « ressources » disponibles sont donc les différents éléments actifs et autonomes du
système : le four, le batteur, le(s) cuisinier(s). Afin d’être réellement efficace dans la
parallélisation, je propose de considérer un système avec deux cuisiniers.
Voici une proposition de mise en œuvre et l’expression de synchronisation associée :
@elodescharmes

3. Annexe 2
Exemples simples en CSP
Exemple 1
Ecrire le processus p cherchant dans un tableau t de 100 éléments (indicés de 1 à 100) la place
du « 0 » de plus petit indice
p ::
i : integer ;
t : array[1..100] of integer;
i := 1 ;
*[
i ≤ 100 ; t[i] ≠ 0 
i := i+1
]
fin p
Exemple 2
Ecrire le processus X qui reçoit des caractères d’un processus « gauche » et les transmet, à
l’exception des blancs, au processus « droite » (réception synchrone, émission asynchrone)
X ::
*[
c : char ;
gauche ? c 
[
c = " "  skip
[]
c ≠ " "  droite !! c
]
]
fin X
Remarque : quand "gauche" se termine, gauche ? c échoue et entraine l'arrêt de la boucle et
du processus X. La commande X ? c du processus "droite" échouera alors aussi.
@elodescharmes

4. Exemple 3
A et B envoient des entiers à C qui les cumule par « paquets ». Dès qu’un paquet est ≥ 1000,
C envoi la somme correspondante à D. Ecrire le processus C.
C ::
s, x : integer ;
s := 0 ;
*[
A ? x 
[
s ≥ 1000 
D ! s ;
s := x
[]
s < 1000 
s := s + x
]
[]
B ? x 
[
s ≥ 1000 
D ! s ;
s := x
[]
s < 1000 
s := s + x
]
]
fin C
@elodescharmes

5. Annexe 3
1 producteur – 1 consommateur
Conditions de production et de consommation
Variables
DEBPROD nombre de productions commencées
FINPROD nombre de productions terminées
DEBCONS nombre de consommations commencées
FINCONS nombre de consommations terminées
IFINCONS image retardée de FINCONS locale au site du producteur
IFINPROD image retardée de FINPROD locale au site du consommateur
Conditions initiales de production (Cp) et de consommation (Cc)
(Cp) DEBPROD - FINCONS < N
(Cc) DEBCONS - FINPROD < 0
Conditions de production et de consommation dans le cas d’une mise en œuvre répartie de
l’exemple
(Cp’) DEBPROD – IFINCONS < N
(Cc’) DEBCONS - IFINPROD < 0
De plus,
IFINCONS ≤ FINCONS
IFINPROD ≤ FINPROD
(Cp’) DEBPROD - IFINCONS < N
DEBPROD – N < IFINCONS
DEBPROD – N < IFINCONS ≤ FINCONS
DEBPROD – N < FINCONS
(Cp) DEBPROD – FINCONS < N
Donc (Cp’) ⇒ (Cp)
(Cc’) DEBCONS - IFINPROD < 0
DEBCONS < IFINPROD
DEBCONS < IFINPROD ≤ FINPROD
DEBCONS < FINPROD
(Cc) DEBCONS – FINPROD < 0
Donc (Cc’) ⇒ (Cc)
@elodescharmes

6. Annexe 4
1 producteur – 1 consommateur
Algorithme
-- aspect contrôle du producteur
P ::
-- déclarations
debprod, finprod, ifincons : entier ;
req_en_cours, prod_en_cours : booleen ;
-- initialisations
debprod, finprod, ifincons := 0, 0, 0 ;
req_en_cours, prod_en_cours := faux, faux ;
*[
-- ACQUISITION
¬ req_en_cours ; Prod ?? "dem_prod" 
req_en_cours := vrai
[]
-- SECTION CRITIQUE
req_en_cours ; ¬ prod_en_cours ; debprod - ifincons < n 
debprod := debprod + 1 ;
prod_en_cours := vrai ;
Prod !! "ok_prod"
[]
-- LIBERATION
prod_en_cours ; Prod ?? "term_prod" 
finprod := finprod + 1 ;
C !! <finprod> ;
req_en_cours, prod_en_cours := faux, faux
[]
-- réception de ifincons
C ?? <ifincons> 
skip
]
fin P ;
@elodescharmes

7. -- aspect contrôle du consommateur
C ::
-- déclarations
debcons, fincons, ifinprod : entier ;
req_en_cours, cons_en_cours : booleen ;
-- initialisations
debcons, fincons, ifinprod := 0, 0, 0 ;
req_en_cours, cons_en_cours := faux, faux ;
*[
-- ACQUISITION
¬ req_en_cours ; Cons ?? "dem_cons" 
req_en_cours := vrai
[]
-- SECTION CRITIQUE
req_en_cours ; ¬ cons_en_cours ; debcons-ifinprod < 0 
debcons := debcons + 1 ;
cons_en_cours := vrai ;
Cons !! "ok_cons"
[]
-- LIBERATION
cons_en_cours ; Cons ?? "term_cons" 
fincons := fincons + 1 ;
P !! <fincons> ;
req_en_cours, cons_en_cours := faux, faux
[]
-- réception de ifinprod
P ?? <ifinprod> 
skip
]
fin C ;
@elodescharmes

8. Annexe 5
m producteurs – 1 consommateur
Technique du jeton circulant – exercice
@elodescharmes

9. @elodescharmes

10. Annexe 5
m producteurs – 1 consommateur
Technique du jeton circulant – exercice
@elodescharmes

11. @elodescharmes

12. Annexe 6
m producteurs – 1 consommateur
Technique du jeton circulant
Pi possède deux variables booléennes req_en_cours et rang_pris.
- req_en_cours vaut vrai quand le contrôleur de production sait que le producteur qui lui est associé
désire produire.
- rang_pris vaut vrai quand le contrôleur a pris son rang dans la file des contrôleurs désirant produire, ce
qui ne peut se faire que si req_en_cours est vrai.
Initialement le jeton est détenu par le contrôleur C qui le lance sur l’anneau avec
debprod = 0
finprod = 0
comptereq = 0
@elodescharmes

13. -- aspect contrôleur du processus n°i
P[i][i :1..m] ::
req_en_cours, rang_pris : booleen ;
rang, debprod, ifincons, comptereq : entier ;
req_en_cours := faux ;
-- définition du processus suivant[i]
[
i ≠ m 
suivant[i] := P[i+1]
[]
i = m 
suivant[i] := C
]
*[
-- ACQUISITION
¬ req_en_cours ; Prod[i] ?? "dem_prod" 
req_en_cours := vrai ;
rang_pris := faux
[]
-- réception du jeton
P[i-1] ?? Jeton(debprod, ifincons, comptereq) 
-- première étape : mise à jour du rang si nécessaire
[
-- Pi prend son rang si une requête de production est en cours et si aucun rang n’est
déjà pris.
req_en_cours ; ¬ rang_pris 
comptereq := comptereq + 1 ;
rang := comptereq ;
rang_pris := vrai
[]
-- Dans le cas contraire (ie. si aucune requête de production n’est en cours ou si le
rang est déjà pris), on ne fait rien.
¬ req_en_cours ou rang_pris 
skip
] ;
-- deuxième étape : entrée en SC si les conditions sont vérifiées, sinon transfert du jeton
[
-- SECTION CRITIQUE
rang_pris ; rang – ifincons ≤ n 
debprod := debprod + 1 ;
Prod[i] !! "ok_prod"
[]
-- Si les conditions d’entrée en SC ne sont pas vérifiées, on transfère le jeton au
processus suivant
¬ rang_pris ou rang – ifincons > n 
Suivant[i] !! Jeton(debprod, ifincons, comptereq)
]
[]
-- LIBERATION
req_en_cours ; Prod[i] ?? "term_prod" 
req_en_cours := faux ;
rang_pris := faux ;
suivant[i] !! Jeton(debprod, ifincons, comptereq)
]
fin P[i] ;
@elodescharmes

14. -- aspect contrôleur du consommateur
C ::
debcons, ifinprod, fincons : entier ;
req_en_cours : booleen ;
debcons, ifinprod, fincons := 0, 0, 0 ;
req_en_cours := faux ;
*[
-- ACQUISITION
¬ req_en_cours ; Cons ?? "dem_cons" 
req_en_cours := vrai
[]
-- Réception du jeton
P[m] ?? Jeton(ifinprod, fincons, comptereq) 
[
-- SECTION CRITIQUE
req_en_cours ; debcons - ifinprod < 0 
debcons := debcons + 1 ;
Cons !! "ok_cons"
[]
-- Si les conditions d’entrée en SC ne sont pas vérifiées, on transfère le jeton au
processus suivant
¬ req_en_cours ou debcons – ifincons ≥ 0 
P[1] !! Jeton(ifinprod, fincons, comptereq)
]
[]
-- LIBERATION
req_en_cours ; Cons ?? "term_cons" 
req_en_cours := faux ;
fincons := fincons + 1 ;
P[1] !! Jeton(debprod, fincons, comptereq)
]
fin C ;
@elodescharmes

15. Lamport : chronogramme vierge
@elodescharmes

16. Annexe 7
m producteurs – 1 consommateur
Algorithme de Lamport – exemples
Exemple 1
@elodescharmes

17. Exemple 2
@elodescharmes

18. Annexe 8
m producteurs – 1 consommateur
Algorithme de Lamport
-- aspect contrôle du producteur n°i
P[i][i :1..m] ::
hl, he, debprod, finprod, ifincons : entier ;
-- hl = heure locale
-- he = heure externe (reçus dans une estampille)
tab[1..m] : tableau de ({req, rel, ack}, entier) ;
-- tableau à m lignes (m = nombre de processus producteurs) d’éléments de type (type, date)
req_en_cours, sc_en_cours : booléen ;
-- initialisation
hl, he, debprod, finprod := 0, 0, 0, 0 ;
tab[*] := (rel, 0) ;
req_en_cours, sc_en_cours := faux, faux ;
DIFFUSER (msg, hl, i) ;
-- procédure permettant de diffuser à l’ensemble des autres contrôleurs un message msg (hl, i). Ce
message est de type req ou rel.
MAJ_H (hl, he) ;
@elodescharmes

19. -- procédure permettant de mettre à jour l’horloge locale hl d’une date he reçue via une estampille
DEBUT_SC (i) booléen ;
-- renvoie vrai si Pi peut entrer en SC, c'est-à-dire si tab[i].type = req et si∀ j ∈ [1..m] j ≠ i, (tab[i].date
< tab[j].date) ou (tab[i].date = tab[j].date et i < j)
*[
-- réception d’un message de type req
P[j] ?? req (he, j) 
MAJ_H (hl, he) ;
-- envoi de l’acquittement uniquement si le message précédent de Pj n’était pas déjà
de type req
[
tab[j].type ≠ req 
hl := hl + 1 ;
P[j] !! acq (hl, i)
[]
tab[j].type = req 
skip
]
tab[j] := (req, he) ;
[]
-- réception d’un message de type ack
P[j] ?? ack (he, j) 
MAJ_H (hl, he) ;
-- mise à jour du tableau sauf si le message précédent de Pj est de type req
[
tab[j].type ≠ req 
tab[j] := (ack, he)
[]
tab[j].type = req 
skip
]
[]
-- réception d’un message de type rel
P[j] ?? rel (he, j) 
MAJ_H (hl, he) ;
tab[i] := (rel, he) ;
-- mise à jour des compteurs debprod et finprod car j a produit et a fini de produire
debprod := debprod + 1 ;
finprod := finprod + 1 ;
[]
-- ACQUISITION
¬ req_en_cours ; Prod[i] ?? "Besoin_SC" 
hl := hl + 1 ;
req_en_cours := vrai ;
DIFFUSER (req, hl, i) ;
tab[i] := (req, hl)
[]
-- SECTION CRITIQUE
req_en_cours ; ¬ sc_en_cours ; DEBUT_SC(i) ; debprod – ifincons < n 
debprod := debprod + 1 ;
Prod[i] !! "Début_SC" ;
sc_en_cours := vrai
[]
-- LIBERATION
req_en_cours ; sc_en_cours ; Prod[i] ?? "Fin_SC" 
finprod := finprod + 1 ;
C !! (finprod) ;
@elodescharmes

20. sc_en_cours := faux ;
hl := hl + 1 ;
DIFFUSER (rel, hl, i) ;
tab[i] := (rel, hl) ;
req_en_cours := faux
[]
-- réception de ifincons
C ?? ifincons 
skip
]
fin P[i] ;
-- aspect contrôle du consommateur
C ::
debcons, fincons, ifinprod : entier ;
req_en_cours, sc_en_cours : booléen ;
debcons, fincons, ifinprod := 0, 0, 0 ;
req_en_cours, sc_en_cours := faux, faux ;
*[
-- ACQUISITION
¬ req_en_cours ; Cons ?? "Besoin_SC" 
req_en_cours := vrai
[]
-- SECTION CRITIQUE
req_en_cours : ¬ sc_en_cours ; debcons – ifinprod < 0 
debcons := debcons + 1 ;
Cons !! "Début_SC" ;
sc_en_cours := vrai
[]
-- LIBERATION
req_en_cours ; sc_en_cours ; Cons ?? "Fin_SC" 
fincons := fincons + 1 ;
k := 1 ;
*[
k < n + 1 
P[k] !! (fincons) ;
k := k + 1 ;
] ;
sc_en_cours := faux ;
req_en_cours := faux
[]
-- réception de ifinprod
P[j] ?? (ifinprod) 
skip
]
fin C ;
@elodescharmes