Algorithmique

parallèle
 1.Modèle parallèle.

1. Définitions de bases.
2. Description de modèles.
3. Comparaison des puissances des modèles.
 Définition
Machine parallèle: ensemble de processeurs qui
sont capables de coopérer afin de résoudre un
problème.
Ceci inclut:
– les super ordinateurs parallèles (milliers de processeurs).
• connection Machine-5: 32 à 65536 nœuds
• Cray T3E : 128 à 2048 nœuds
• Top 500 : http://www.top500.org
– les grappes (ou clusters).
 Machines Parallèles
• Mémoires
– Partagée.
– ou distribuée.
• Types de commutation (communications de
circuits, de paquets, wormhole)
• Mode synchrone ou asynchrone.
Comment évaluer les algorithmes ?
• Temps d’exécution (Tp ): Différence entre le
moment où le premier processeur commence de
l’algorithme et le moment où le dernier
processeur termine.

j j j
Tp= max (Tcalculs +Tcoms +T attente )
Comment évaluer les algorithmes ?
• Facteur d’accélération (speed up) Ap:
rapport entre le temps d’exécution de l’algorithme
séquentiel optimal Ts et le temps d’exécution de
l’algorithme parallèle sur p processeurs.

• Efficacité: rapport entre le facteur d’accélération

et le nombre de processeurs
 Comment évaluer les algorithmes ?
• Le travail (work) Wp :
Wp = p* Tp.
Temps exécution

Optimal si la surface
du rectangle vaut T s

Nombre de processeurs
1.2 Description des modèles
 Modèle P-RAM
• P-RAM: Parallel Random Access Machine.
– Mémoire centrale partagée.
– Nombre non borné de processeurs
– Taille de la mémoire infinie.

Comment accéder à la mémoire?

 P-RAM: gestion de la mémoire
• CREW (Concurrent Read Exclusive Write)
– Nombre non borné de lectures simultanées.
– Écriture d’un SEUL processeur dans une case
mémoire.
• EREW (Exclusive Read Exclusive Write)
– Modèle restrictif mais proche des machines réels.
 CRCW (Concurrent Read Concurrent Write)
• Accès lecture: plusieurs processeurs simultanément.
• Accès écriture: plusieurs processeurs simultanément.
– Mode consistant: tous les processeurs doivent écrire la
même valeur.
– Mode arbitraire: valeur du dernier processeur qui écrit.
– Mode fusion: valeur obtenue par une fonction appliquée
aux différentes valeurs écrites.
 Exemple: somme préfixe
Définition:
– Entrée: table A de n = 2k éléments
– Sortie: table B de n = 2k éléments tel que
i
B[i]=Σj=1 A[j]

Exemple:
Tableau : 1 3 2 7
Résultat: 1 4 6 13
 Algorithme sur une P-RAM
(EREW).
•Algorithme récursif:
A = 1 2 3 4 5 6 7 8
Donnée:
A’ = 3 7 11 15

de A : X 3 X 10 X 21 X 36
Résultat:
de A’: 3 10 21 36
 Algorithme sur une P-RAM
(EREW).
A = 1 2 3 4 5 6 7 8
Donnée:
A’ = 3 7 11 15

de A : 1 3 6 10 15 21 28 36
Résultat:
de A’: 3 10 21 36
 Formalisation de l’algorithme
Entrée: table A de n = 2 kéléments
Sortie: table B de n = 2 kéléments tel que B[i]=Σ j=1
i A[j]

Pour tout i=1 à n en parallèle faire C[0,i] := A[i]

Pour tout (j=1; j < log n; j++) faire
Pour tout i=1 à n/2 j en parallèle faire
C[j,i] := C[j-1,2i-1]+ C[j-1,2i]
Pour tout (j=log n; 1 <=j ; j--) faire
Pour tout i=1 à n/2 j en parallèle faire
B[j-1,2i] := C[j,i]
B[j-1,2i+1] := C[j,i]+C[j-1,2i+1]
B[j-1,1] := C[j-1,1]
 Remarque sur l’algorithme
• Pour tout i=α à β en parallèle faire
instructions...
– Les instructions sont faites en parallèle pour
toutes les valeurs i allant de α à β.
• Évaluation de l’algorithme:
– Chaque boucle prend un temps O(1).
– Temps: O(log n).
 Autre exemple: calcul du rang.
Définition:
– Entrée: une liste chaînée de taille n
– Sortie: tableau d tel que d[i] vaut la distance
entre l’élément i et la fin de la chaîne.
0 si next[i]=nil
d[i]=
d[next[i]] +1 si next[i]=nil
 Algorithme P-RAM CRCW
/* phase d’initialisation */
Pour tout i=1 à n en parallèle faire
Si next[i] = nil alors d[i] := 0 sinon d[i] := 1
/* phase de calcul */
Pour toute étape=1 à log n faire
Pour tout i=1 à n en parallèle faire
si next[i]=nil alors d[i] := d[i] +d[next[i]]
next[i]:= next[next[i]]
 Modèle CGM
• Ensemble de p processeurs interconnectés par un réseau.
• Mémoire locale: taille =O(n/p) où n taille du problème.
• Algorithme = une séquence de super-étapes.
• Une super-étape :
– Calculs locaux
– Temps de communication.
– Synchronisation.
 Modèle CGM: algorithme en deux
phases.
1. Phase de calcul local sur les données locales.
Utilisation de l’algorithme optimal en séquentiel

2. Phase d’échange de données: redistribution.

Envoi et réception des données de taille O(n/p)
 Algorithme: somme parallèle.
P(2) P(2) P(3)
Donnée: 1 2 3 4 5 6 7 8 9
Algo seq 1 3 6 4 9 15 7 15 24

Envoi 6 6 + 15
=21

Résultat: 1 3 6 10 15 21 28 36 45
 Formalisation de l’algorithme
Entrée: tableau T de n/p éléments.
Sortie: somme préfixe effectué sur les éléments de T.

• Pour tout (j=2; j <= n/p ; j++) faire

somme préfixe locale sur T
• Envoyer T(n/p) aux processeurs num+1,num+2,…,p
• Recevoir les valeurs des processeurs 1,2,…,num-1 et
les mettre dans aux [1], aux[2],…,aux[num-1]
• Pour tout (i=2; j <num ; i++) faire
somme préfixe locale sur aux
• Pour tout (i=1; j <= n/p ; i++) faire
T[i]:=T[i]+aux[num-1]
 Évaluation de l’algorithme.
• Coût de la phase séquentiel : O(n/p)
• Coût de la communication globale:
– Coût du tri globale de O(n) données de p
processeurs noté Tg

• Coût global: O(n/p) +Tg

1.3 Comparaison des puissances
des modèles
 Notion: Puissance des modèles.
• Question : une P-RAM CRCW est-elle plus puissante
qu’une P-RAM CREW ?
• Plus précisément,
Peut-on trouver un algorithme tel que, pour un même
nombre de processeurs, on obtienne avec une P-
RAM CRCW un temps d’exécution qu’il est
impossible d’atteindre pour une P-RAM CREW ?

• Oui, en considérant le problème de la recherche d’un

maximum d’un tableau.
Calcul du maximum d’un tableau A.
• Algorithme en temps constant
– sur une P-RAM CRCW en mode consistant.
– avec O(n 2 ) processeurs.

Pour tout i=1 à n en parallèle faire O(1)

m[i] := true
Pour tout i,j=1 à n en parallèle faire
Si A[i] < A[j] alors m[i] := false
O(1)
Pour tout i=1 à n en parallèle faire
Si m[i] = TRUE alors max :=A[i] O(1)
 Et sur une P-RAM en mode CREW?
• Dans ce modèle on ne peut pas fusionner une
liste de n éléments en moins de O(log n) étapes.
• Coût de l’algorithme: O(log n) étapes.

Pour tout i=1 à n en parallèle faire O(1)

m[i] := TRUE
Pour tout i,j=1 à n en parallèle faire
Si A[i] < A[j] alors m[i] := TRUE
O(1)
Pour tout i=1 à n en parallèle faire
Si m[i] = TRUE alors max :=A[i] O(log n)
Séparation des modèles CREW et EREW.

• Problème: déterminer si un élément e se

trouve dans un ensemble de n éléments
distincts.
• Coût de l’algorithme optimale
– pour une P-RAM CREW (n processeurs)
Temps constant
– pour une P-RAM EREW (n processeurs)

O(log n) étapes
 Théorème sur les puissances.
• Théorème: Tout algorithme sur une machine P-RAM
CRCW à p processeurs ne peut pas plus de O(log p)
fois plus rapide que le meilleur algorithme P-RAM
EREW.

• Idée de la preuve:
– Un pas d’un algorithme P-RAM CRCW à p
processeurs peut être simuler en O(log p) pas d’un
algorithme P-RAM EREW.
 Récapitulatif.
Tout algorithme sur une machine P-RAM CRCW à p
processeurs ne peut pas plus de O(log n) fois plus
rapide que le meilleur algorithme P-RAM CREW.

Même résultat:
• pour les machines CREW et EREW.
• pour les machines CRCW et EREW.
 Théorème de Brent
Soit A un algorithme
– comportant un nombre total m d’opérations,
– qui s’exécute en temps t,
– sur une P-RAM avec un nombre indéterminé de
processeurs,

Alors on peut simuler A en temps O(m/p + t) sur

une P-RAM avec p processeurs.
 Application du théorème de Brent
• Prédire les performances si nbre de processeurs diminue.
• Par exemple :calcul du max sur P-RAM EREW

Pour tout i=log n à 0 faire

k
Pour tout j=0 à 2 -1 en parallèle faire
A[j]= max(A[2j],A[2j+1])

• Temps : O(log n) avec n processeurs.

• Temps : O(n/p + log n) avec p processeurs.
• Temps : O(log n) avec n/log n processeurs.
 2.Tri parallèle.
1. Réseau de tri.
2. Algorithme de tri dans le modèle CREW.

Cours inspiré d’un chapitre du livre Introduction to

algorithms de Cormen, Leiserson et Rivest.
2.1 Réseau de tri.
 Introduction: Réseau de tri
• Modèle de calcul plus réaliste.

Liste non triée Réseau de tri liste triée

• Architecture dépendant du nombre d’éléments à

trier.
• Réseau de fusion pair-impaire, réseau bitonique.
 Réseau de tri
• Réseaux composés de comparateurs et
d’échangeurs :
a b

min(a,b) max(a,b)
 Réseau de tri-fusion
• Simplification: trier des listes de n=2 k éléments.
Algorithme de tri sur une suite (c1 ,c2 ,…,cn )
– trier(c1 ,c2 ,…,cn/2 ) et trier(cn/2+1,cn/2+2,…,cn ) en //.
– Fusionner les deux listes triées.

• Construction des réseaux TRIER(k) et FUSION(k)

à partir des réseaux TRIER(k-1) et FUSION(k-1).
 Réseau de tri-fusion de petite taille.
• Réseau de TRI(0) • Réseau FUSION(1)
a(1)
a(1)
b(1)
a(2)

• Réseau TRI(1) a(2)

TRI(0) b(2)

a(1)
a(2)

b(1)
b(2)
FUSION(1)
Construction du réseau fusion de deux
listes de même taille et déjà triées.
a(1) d(1) c(1)
a(2) d(2) c(2)
a(3) d(3) c(3)
a(4) d(4) c(4)
c(5)
a(2i-1) d(i+1)
a(2i)
:
c(2i)
b(1) e(1)
c(2i+1)
b(2) e(2)
b(3) e(3)
b(4) e(4)
FUSION(m)
b(2i-1) e(i)
FUSION(m+1)
b(2i) :
 Construction du réseau tri.

TRI(n-1)

FUSION(n)
TRI(n)=

TRI(n-1)
 Coût du réseau tri-fusion
• Pour un réseau de taille n=2m ,

• Temps = O(log n 2 )
2
• Nombre de comparateur = O(nlog n )
• Travail = O(nlog n 4)
 Tri par transposition pair-impair
Réseau formé de lignes de comparateurs
a b

min(a,b) max(a,b)
 Réseau de tri
de taille n=2p
Description : p copies de 2 lignes
• Ligne 1: p comparateurs
• Ligne 2: p-1 comparateurs
prenant en entrée p-1 paires de
fils 2i et 2i+1, 1  i  p-1
• #de comparateurs =n(n-1)/2
 8 7 6 5 4 3 2 1
Exemple:
7 8 5 6 3 4 1 2
7 5 8 3 6 1 4 2

5 7 3 8 1 6 2 4
5 3 7 1 8 2 6 4
3 5 1 7 2 8 4 6
3 1 5 2 7 4 8 6
1 3 2 5 4 7 6 8

1 2 3 4 5 6 7 8
 Min

Réalise-t-il un tri?
Min

Min
Oui, car:
• Parcours du minimum Min
– Étape 1:0 ou 1 déplacement
vers la gauche. Min

– Chaque étape:
Min
1 déplacement vers la gauche.
Min

Min
 A A

Réalise-t-il un tri? A A
Oui, car:
• Parcours du « 2ieme élément » Min A
– Étape 1: 0 ou 1 vers la
gauche, 1 vers la droite lors
de la rencontre du min.
– Chaque étape : 1
déplacement vers la gauche.
– Sauf deux, 0 déplacement
lors de la comparaison entre
lui et le min.
• Évaluation du parcours.
 Coût du réseau tri pair-impair
• Pour un réseau de taille n=2m ,

• Temps de calcul= O(n)

• Nombre de comparateur = O(n(n-1)/2 )
• Travail = O(n 3 )
 Tri pair-impair sur un réseau
linéaire de processeurs.
• p processeurs, n éléments à trier.
• n divisible par p (simplification)
• Adaptation du précédent réseau de tri sur un un
réseau linéaire.
1.Tri local en parallèle sur les p processeurs O(n logn/p)
2. p étapes d’échange alternées entre deux processeurs
voisin selon le réseau de tri pair-impair. Mais chaque
processeur envoi n/p données
 Exemple: 5 processeurs, 15 données

Init 8,7,0 15,2,24 19,1,22 11,9,3 6,12,13

tri 0,7,8 2,15,24 1,19,22 3,911, 6,12,13

impaire 0,2,7 8,15,24 1,3,9 11,19,22 6,12,13

paire 0,2,7 1,3,8 9,15,24 6,11,12 13,19,22

impaire 0,1,2, 3,7,8 6,9,11 12,15,24 13,19,22

paire 0,1,2, 3,6,7, 8,9,11 12,13,15 19,22,24

 Coût
• Coût_calcul(Tri local) = O(n log n/p)
• Coût_calcul(échange)=O(p*n/p)=O(n)

• Temps de calcul = O(n log n/p +n)

• Travail = O(n (p +log n))
2.2 Algorithme de tri dans
le modèle CREW.
 Principe de l’algorithme de Cole
12345678
Fusion 3
5678 1234
Fusion 2
78 56 34 12
Fusion 1
8 7 6 5 4 3 2 1
 Algorithme de Cole
• basé sur l’algorithme de tri-fusion séquentiel
de complexité O(n log n) .

• de complexité O(log n) sur un machine P-

RAM de n processeurs.

• avec n le nombre d’éléments à trier.

 Partie délicate: la fusion.
• Manipulation de suites d’entiers.
• Définition:
– Un entier x est entre a et b si a <x  b.
– Rang d’un élément de x dans une suite L:
rang(x,L)=card {j  L, j <x}
– Rang croisé de A dans B:
R[A,B](e)=rang(e,B)
 Exemple:
• J =[ 2, 3, 7, 8, 10, 14, 15, 17, 18, 21 ]
• L=[ 5, 10, 12, 17 ]

• On obtient
Rang(5, J ) = 2, rang(10, J ) = 4,
Rang(12, J ) =4, rang(17, J ) = 7
R[ L, J ]=[ 2, 4, 4, 7 ]
 Échantillonnage
• Une suite L est un bon échantillonnage (BE) d’
une suite J si pour tout k  1 éléments consécutifs
arbitraires de {-}  L {+}, il y a au plus 2k+1
éléments de J.
• Exemple:
– J=[ 2, 3, 7, 8, 10, 14, 15, 17, 18, 21 ], L=[ 5, 10, 12, 17 ]
– L est un BE de J car pour k=1, il y a au plus 3 éléments
de J entre (-,5), (5,10), (10,12), (12,17), (17,-), pour
k=2,….
 Fusion_assistée(J,K,L)
1. Partitionner J et K en |L|+1 sous-ensembles
J(i) et K(i) tel que, 1  i  |L|+1
1. J(i)={j  J, l i-1< j  l i }
2. K(i)={k  k, li-1< k  li }
Exemple:
J =[ 2, 3, 7, 8, 10, 14, 15, 17, 18, 21 ]
L=[ 5, 10, 12, 17 ]
J(1)=[ 2, 3 ], J(2)=[ 7, 8, 10 ], J(3)=,
J(4)=[ 14, 15, 17 ], J(5)=[ 18, 21 ]
 Fusion_assistée(J,K,L)
1. Partitionner J et K en |L|+1 sous-ensembles
J(i) et K(i) tel que, 1  i  |L|+1
1. J(i)={j  J, l i-1< j  l i }
2. K(i)={k  k, li-1< k  li }
2. Fusionner en parallèle les sous-ensembles.
Pour tout i, 1  i  |L|+1 faire en //
res i:= Fusion(J(i),K(i))
 J =[ 2, 3, 7, 8, 10, 14, 15, 17, 18, 21 ]
Exemple: K=[ 1, 4, 6, 9, 11, 12, 13, 16, 19, 20]
L=[ 5, 10, 12, 17 ]

• L est
1 un BE de J et de K.
J(1)=[2,3] K(1)=[1,4] res1 =Fusion([2,3], [1,4] )
=[1,2,3,4],
J(2)=[7,8,10] K(2)=[6,9] res2 =Fusion([7,8,10], [6,9] )
=[7,8,9,10],
J(3)=, K(3)=[11,12] res 3 =Fusion(, [11,12] )
=[11,12],
J(4)=[14,15,17], K(4)= [13,16] res =Fusion([14,15,17], [13,16] )
4
=[13,14,15,16,17],
J(5)=[18,21], K(5)=[19,20] res5 =Fusion([18,21], [19,20])
 Fusion_assistée(J,K,L)
1. Partitionner J et K en |L|+1 sous-ensembles
J(i) et K(i) tel que, 1  i  |L|+1
1. J(i)={j  J, l i-1< j  l i }
2. K(i)={k  k, li-1< k  li }
2. Fusionner en parallèle les sous-ensembles.
Pour tout i, 1  i  |L|+1 faire en //
res i:= Fusion(J(i),K(i))
3. Concaténer les résultats partiels.
J|K :=res1 res 2…res |L|+1
 Évaluation du coût des trois
étapes de la fonction
Fusion_assistée(J,K,L).
• En supposant qu’on connaît
R[L, J], R[L, K], R[J, L], R[K, L] ,

les trois étapes se font en temps constant.

 Évaluation du coût.
1. Partitionner J et K en |L|+1 sous-ensembles
J(i) et K(i) tel que, 1  i  |L|+1
1. J(i)={j  J, l i-1< j  l i }
2. K(i)={k  k, li-1< k  li }

Partition de J (ou de K): |J| processeurs.

• j  J, P(j) lit rang(j,L)(=r)
insère j dans J(r)
O(1)
 Évaluation du coût.
2. Fusionner en parallèle les sous-ensembles.
Pour tout i, 1  i  |L|+1 faire en //
res i:= Fusion(J(i),K(i))

Coût: O(1).
 Évaluation du coût.
3. Concaténer les résultats partiels.
J|K :=res1 res2…res|L|+1
– Concaténation:
Hypothèse: connaissance R[L,J], R[L,K]
– Chaque élément l iL a un processeur
responsable P(li )de lui.
rang(li ,J|K)=rang(li ,J) +rang(li ,K) ;
range les éléments de resi à partir du
rang rang(li-1 ,J|K)+1.
 Évaluation du coût des trois
étapes de la fonction
Fusion_assistée(J,K,L).
• En supposant qu’on connaît
R[L, J], R[L, K], R[J, L], R[K, L] ,

les trois étapes se font en temps constant, avec

|J|+|K|+|L| processeurs sur une P-RAM CREW.
 Algorithme globale.
• Simplification: n est une puissance de 2.
• Basé sur l’arbre binaire de «tri».

12345678

5678 1234

78 56 34 12

8 7 6 5 4 3 2 1
 Au top 0, tous les nœuds
stockent une liste  sauf les
Initialisation: feuilles qui stockent leur
élément.


 

   

8 7 6 5 4 3 2 1
 Algorithme global.
• Au top 0, phase initialisation.
• Opération d’un nœud au top t+1,
– Recevoir X(t+1) et Y(t+1) de ses fils.
– val(t+1) = Fusion_assistée(X(t), Y(t),val(t))
• Envoyer à son père Z(t+1) ={z4 , z8 , z12 ,….} où
val(t+1)= {z1 , z2 , z3 ,…,zn }
 Déroulement de l’algorithme.
• Dès qu’un nœud a reçu toute sa liste au top t
alors, il envoi, à son père,
– d’un élément sur 4 de val(t+1) au top t+1,
– d’un élément sur 2 de val(t+1) au top t+2,
– envoi de val(t+1) au top t+3.
• Et au top t+4, il ne fait plus rien….
 Exemple du déroulement l’algorithme
de Cole
Vision locale
de l’algorithme 0
sur ce nœud Au top 0, les feuilles ont des listes triées de taille 2
Au top 1, ne rien faire
Au top 2, ne rien faire
val (3) Au top 3, val (3)= Fusion_assistée([8],[7],)


8 7
8 7 6 5 4 3 2 1
Exemple du déroulement l’algorithme
de Cole

Au top 3, calculer la Fusion_assistée([X],[X],)

78 56 34 12
8 7 6 5 4 3 2 1
8 7 6 5 4 3 2 1
Vision locale
de l’algorithme Au top 4, ne rien faire
sur ce nœud
Au top 5, il reçoit [8] et [6]
+ val(5) =Fusion_assistée([8],[6],)


8 6
78 56 34 12

8 7 6 5 4 3 2 1
Vision locale
de l’algorithme Au top 4, ne rien faire
sur ce nœud
Au top 5, il reçoit [8] et [6]
+ val(5) =Fusion_assistée([8],[6],)
val(5)=[6,8]
6,8
8 6
78 56 34 12

8 7 6 5 4 3 2 1
Vision locale
de l’algorithme Au top 4, ne rien faire
sur ce nœud
Au top 5, il reçoit [8] et [6]
+ val(5) =Fusion_assistée([8],[6],)

Au top 6, il reçoit [7,8] et [5,6]

6,8
7, 8 5,6
78 56 34 12

8 7 6 5 4 3 2 1
 Remarque
• val(5) =Fusion_assistée([8],[6],) =[6,8]
• val(5) est un bon échantillonnage de
[7,8],[5,6].
Vision locale
de l’algorithme Au top 4, ne rien faire
sur ce nœud
Au top 5, il reçoit [8] et [6]
+ val(5) =Fusion_assistée([8],[6],)

Au top 6, il reçoit [7,8] et [5,6]

6,8
7, 8 5,6
78 56 34 12

8 7 6 5 4 3 2 1
Vision locale
de l’algorithme Au top 4, ne rien faire
sur ce nœud
Au top 5, il reçoit [8] et [6]
+ val(5) =Fusion_assistée([8],[6],)

Au top 6, il reçoit [7,8] et [5,6]

[5,6,7,8] + val(6) =Fusion_assistée([7,8],[5,6],val(5))
7, 8 5,6
78 56 34 12

8 7 6 5 4 3 2 1
 Après le top 6, chaque nœud de niveau 3 a
calculé sa propre liste.

[5,6,7,8] [1,2,3,4]

78 56 34 12

8 7 6 5 4 3 2 1
 Au top 7, il reçoit 8 et 4.
Au top 8, il reçoit [6,8] et [2,4]
Vision locale Au top 9, il reçoit [5,6,7,8] et
de l’algorithme  [1,2,3,4].
sur ce nœud puis plus rien….

[5,6,7,8] [1,2,3,4]

78 56 34 12

8 7 6 5 4 3 2 1
Au top 7, il reçoit 8 et 4,
val(7)= Fusion_assistée([8],[4],) = [4,8]


[8] [4]
[5,6,7,8] [1,2,3,4]
Au top 7, il reçoit 8 et 4, val(7) = [4,8]
Au top 8, il reçoit [6,8] et [2,4]
val(8)= Fusion_assistée([6,8],[2,4],val(7)) = [2,4,6,8]

[4,8]
[6,8] [2,4]

[5,6,7,8] [1,2,3,4]
Au top 7, il reçoit 8 et 4, val(7) = [4,8]
Au top 8, il reçoit [6,8] et [2,4], val(8)= [2,4,6,8]
Au top 9, il reçoit [5,6,7,8] et [1,2,3,4]
val(9) = Fusion_assistée([5,6,7,8] , [1,2,3,4],val(8))
= [1,2,3,4, 5,6,7,8]

[2,4,6,8]
[5,6,7,8] [1,2,3,4]

[5,6,7,8] [1,2,3,4]
Au top 7, il reçoit 8 et 4, val(7) = [4,8]
Au top 8, il reçoit [6,8] et [2,4], val(8)= [2,4,6,8]
Au top 9, il reçoit [5,6,7,8] et [1,2,3,4]
val(9) = Fusion_assistée([5,6,7,8] , [1,2,3,4],val(8))
= [1,2,3,4, 5,6,7,8]

[1,2, 3,4,5,6,7,8]

[5,6,7,8] [1,2,3,4]
Au top 8, val(8)= [2,4,6,8], val(8)= [2,4,6,8],
Au top 9, envoi [8] et [16]


16 8

[10,12,14,16] [2,4,6,8]
Au top 8, val(8)= [2,4,6,8], val(8)= [2,4,6,8],
Au top 9, envoi [8] et [16]
val(9) = Fusion_assistée([8],[16],) =[8,16]
val(9) =[9,10,11,12,13,14,15,16] val(9)=[1,2,3,4, 5,6,7,8]

8,16

[9,10,11,12,13,14,15,16] [1,2,3,4, 5,6,7,8]

Au top 8, val(8)= [2,4,6,8], val(8)= [2,4,6,8],
Au top 9, envoi [8] et [16]
val(9) = Fusion_assistée([8],[16],) =[8,16]
val(9) =[9,10,11,12,13,14,15,16] val(9)=[1,2,3,4, 5,6,7,8]
Au top 10, envoi [4,8] et [12,16]
val(10) = Fusion_assistée([4,8],[12,16],[8,16])
=[4,8,12,16]

8,16 [4,8,12,16]
12,16 4,8

[9,10,11,12,13,14,15,16] [1,2,3,4, 5,6,7,8]

 Algorithme global.
• Au top 0, phase initialisation.
• Opération d’un nœud au top t+1,
– Recevoir X(t+1) et Y(t+1) de ses fils.
– val(t+1) = Fusion_assistée(X(t), Y(t),val(t))
• Envoyer à son père Z(t+1) ={z4 , z8 , z12 ,….} où
val(t+1)= {z1 , z2 , z3 ,…,zn }
 Déroulement de l’algorithme.
• Dès qu’un nœud a reçu toute sa liste au top t
alors, il envoi, à son père,
– d’un élément sur 4 de val(t+1) au top t+1,
– d’un élément sur 2 de val(t+1) au top t+2,
– envoi de val(t+1) au top t+3.
• Et au top t+4, il ne fait plus rien….
 Coût
• L’arbre fonctionne O(log n) avec O(n) processeurs.

Un sommet du niveau k reçoit tous les 2 k éléments de sa liste

au top t=3k : 3 tops à ses fils pour envoyer toutes leurs
données à son père.
Calcul du processeurs =
– chaque nœud de l’arbre binaire a lu une fusion_assistée
k k
– Niveau k, n/2 nœuds, taille de la liste= 2 .
– # de processeurs: O(2 k* n/2k ) =O(n).
 Coût
• L’arbre fonctionne O(log n) avec O(n) processeurs.

• Temps séquentiel = O(n log n)

• Facteur d’accélération= O(n).

• Efficacité =1
 4. Ordonnancement
1. Définition de bases.
2. Problème d’ordonnancements classiques
3. Ordonnancement avec les communications.
4.1 Définition de bases.
 Graphe de tâches: Exemple.
• Résoudre le système linéaire: Ax=b
– Avec A=

• Pour chaque i=1 à n faire

x(i) =b(i)/a(i,i) tâche T(i,i)
Pour chaque j=i+1 à n faire
b(i) =b(i) - x(i)*a(j,i) tâche T(i,j)
 Remarque (1/2).
• Pour chaque i=1 à n faire
x(i) =b(i)/a(i,i)
Pour chaque j=i+1 à n faire
b(i) =b(i) - x(i)*a(j,i)
• T < T’ : la tâche T doit s’effectuer avant T’.
• T(1,1) < T(1,2) < …< T(1,n) <T(2,2)<…<T(n,n)
 Remarque (2/2).
• Pour chaque i=1 à n faire
x(i) =b(i)/a(i,i)
Pour chaque j=i+1 à n faire
b(i) =b(i) - x(i)*a(j,i)
• T(1,1) < T(1,2) < …< T(1,n) <T(2,2)<…<T(n,n)
• Chaque tâche T a un ensemble de variables
d’entrée In(T), et de sortie Out(T).
• Ex: In(T(i,i))={b(i),a(i,i)}, Out(T(i,i))={x(i)} .
In(T(i,j))={b(j),a(j,i),x(i)}, Out(T(i,j))={b(i)}.
 Graphe de tâches: Définition.
• Un graphe (ou système) de tâches est un
graphe orienté G=(V,E,w) où
– V: ensemble fini de tâches.
– E: contraintes de précédence entre les tâches.
– w: V  correspond à la durée de la tâche.
 Retour à l’exemple.
T(1,1)
T(1,2) T(1,3) T(1,4) T(1,5)
T(2,2)
T(2,3) T(2,4) T(2,5)
T(3,3)
T(3,4) T(3,5)
T(4,4)
T(4,5)

T(5,5)
 Définitions
• Soit G=(V,E,w) d’un graphe de tâches,
Sommets d’entrée Sommets de sortie

Prédécesseurs Successeurs
 Ordonnancement: définition
• Un ordonnancement d’un graphe de tâches
G=(V,E,w) est une fonction  de V 
telle que, pour tout arc [u,v]  E dans G,
on a (u)+ w(u)  (v).

(respect des contraintes de dépendances)

 Conséquence:
Soit G=(V,E,w) d’un graphe de tâches,
il existe un ordonnancement dans G si
et seulement si G est sans cycle.

• Illustration:

tâche 1 tâche 2
 Conséquence:
Soit G=(V,E,w) d’un graphe de tâches,
il existe un ordonnancement dans G si
et seulement si G est sans cycle.

Graphe de tâches = DAG (Directed Acyclic Graph).

 Latence: Définition
• Soit G=(V,E,w) d’un graphe de tâches,
• Soit  un ordonnancement pour G utilisant p
processeurs (en posant p= si ressources
illimitées).

La latence MS(,p) (MakeSpan) de  est son

temps d’exécution total:
MS(,p)= max {(v)+w(v)} - min ((v))
v V v V
4.2 Problème d’ordonnancements
classiques
 Énoncé des problèmes.
• Soit G=(V,E,w) d’un graphe de tâches,
• Soit  un ordonnancement pour G sur p
processeurs (en posant p= si ressources
illimitées).

Pb(p): déterminer un ordonnancement  de latence

minimale MS(,p) sur p processeurs.
Pb( ): déterminer un ordonnancement  de latence
minimale MS(,  ) ayant des ressources illimités
 Remarque:
• Soit G=(V,E,w) d’un graphe de tâches,
• Soit  un ordonnancement pour G sur p processeurs.
• Soit C=(T(1),T(2),…,T(k)) un chemin dans G.
• Alors,
MS(,  )  w(C)
 Paramètres de mesures.
• Soit G=(V,E,w) d’un graphe de tâches,
• Soit  un ordonnancement pour G sur p
processeurs.
Seq = v V w(v)
Facteur d’accélération s( ,p)=Seq/MS( ,p)
Efficacité e( ,p)= s( ,p)/p  1
 Résolution de Pb( ).
• Soit G=(V,E,w) d’un graphe de tâches,
• Pour tout sommet v,
– Le niveau supérieur NS(v) est le plus grand
poids d’un chemin menant d’un sommet
d’entrée à v.
– Le niveau inférieur NI(v) est le plus grand
poids d’un chemin menant d’un sommet de
sortie de v.
 En d’autres termes,
• Soit G=(V,E,w) d’un graphe de tâches,
Sommets d’entrée Sommets de sortie

Niveau supérieur NS(v) Niveau inférieur NI(v)

 Retour à l’exemple.
T(1,1)
T(1,2) T(1,3) T(1,4) T(1,5)
T(2,2)
T(2,3) T(2,4) T(2,5)
T(3,3)
NS(T(1,1))=0 T(3,4) T(3,5)
NS(T(2,4))=3 T(4,4)
NI(T(2,4))=5 T(4,5)

T(5,5)
 Résolution de Pb( ).
• Soit G=(V,E,w) d’un graphe de tâches,
• On définit un ordonnancement ASAP tel que
pour tout sommet v de V ,
ASAP (v)= NS(v)

 ASAP respecte les contraintes de précédence

et est optimal.

ASAP: As soon as possible.

 Retour à l’exemple.
T(1,1)
T(1,2) T(1,3) T(1,4) T(1,5)
T(2,2)
T(2,3) T(2,4) T(2,5)
T(3,3)
T(3,4) T(3,5)

Poids de chaque tâche = 1 T(4,4)

Chemin le + long: T(1,1)  T(n,n) T(4,5)
de poids 2n-1.

T(5,5)
 Conclusion de Pb( ).
• Construction d’une solution optimale de
Pb( ).
– calcul du paramètre NS pour chaque sommet.

• Soit G=(V,E,w) un graphe de tâches,

Pb( ) peut être résolu en temps O(|V| +|E|).
 Résolution de Pb(p).
Le problème Pb(p) est NP-complet, contrairement
au problème Pb( ),

Recherche d’heuristiques
 Heuristiques gloutonnes.
• Stratégie « ne pas laisser délibérément un
processeur inactif » : c’est-à-dire, à chaque
instant, on alloue autant de tâches que
possible aux processeurs disponibles.

• Cette stratégie donne de bon résultats.

 Retour à l’exemple: 3 processeurs
T(1,1)
T(1,2) T(1,3) T(1,4) T(1,5)
T(2,2)
T(2,3) T(2,4) T(2,5)
T(3,3)
T(3,4) T(3,5)
T(4,4)
T(1,1) T(1,2) T(2,3)….
T(4,5)
T(1,3) T(2,2) T(2,4)….
T(1,4) T(1,5) T(2,5) T(3,3)….. T(5,5)
 Définition: tâche libre.
• Soit G=(V,E,w) d’un graphe de tâches,

Une tâche v V est libre au temps t si et

seulement si son exécution n’a pas encore
commencé et si tous ces prédécesseurs ont
été exécutés au temps t.
 Retour à l’exemple: 3 processeurs
T(1,1)
T(1,2) T(1,3) T(1,4) T(1,5)
T(2,2)
T(2,3) T(2,4) T(2,5)
T(3,3)
Tâches libres T(3,4) T(3,5)
T(4,4)
T(1,1) T(1,2) T(2,3)….
T(4,5)
T(1,3) T(2,2) T(2,4)….
T(1,4) T(1,5) T(2,5) T(3,3)….. T(5,5)
 Ordonnancement de listes.
• Stratégie: « ne pas laisser délibérément un
processeur inactif ».
• à tout instant t,
– si nombre de tâches libres = r
– si nombre de processeurs disponibles = q,

Alors au temps t, min(r,q) tâches libres

débutent leur exécution.
 Ordonnancement de listes.
1. Initialisation:
1. Calculer les priorités de toutes les tâches.
2. Construire une file de priorité des tâches libres triées en
ordre de priorité décroissant.
3. Temps courant t=0.
2. tant qu’il reste des tâches à exécuter…
1. Réactualiser la file des tâches libres.
2. S’il y a q processeurs libres, et r tâches libres, exécuter
les min(r,q) premières tâches libres (et les supprimer
dans la file des tâches libres).
3. Incrémenter t.
 Garantir des performances.
• Soit G=(V,E,w) d’un graphe de tâches,
• Soit  un ordonnancement de listes.
• Soit MSopt ( ,p) la latence d’ordonnancement
optimal pour G sur p processeurs,
• alors
MS( ,p)  (2-1/p)MSopt( ,p)
 p*MS(,p)=Idle +Seq
Remarque: Seq= v Vw(v)
Idle=temps inactif.

actif

P(1)
P(2)
P(3)
P(4)
 Remarque
• Pour tout ordonnancement ,
p*MS(,p)=Idle +Seq

Avec Seq= v Vw(v)

Idle=temps inactif.
• Seq  p * MSopt (p)
 Remarque:
• Pourquoi T(1) n’a-t-il pas été exécuté avant ?
Car l’éxécution de la tâche T(2) n’est pas finie.
Ainsi de suite avec la tâche T(2), T(3)…

T(6) T(4) T(7) T(1)

P(1)
P(2)
P(3) actif

P(4)
T(5) T(3) T(2)
 Remarque:
• Pourquoi T(1) n’a-t-il pas été exécuté avant ?
Car l’éxécution de la tâche T(2) n’est pas finie.
Ainsi de suite avec la tâche T(2), T(3)…

• Par récurrence, on obtient un chemin de dépendance à

partir de T(1) : C=T(1),T(2), T(3),…,T(r)

• L’inactivité de certains processeurs peut se produire

pendant l’exécution de ces r tâches.
r
Idle (p-1) j=1w(T(j))  (p-1) w(C)
 Remarque
1. Pour tout ordonnancement ,
p*MS(,p)=Idle +Seq
Avec Seq= v Vw(v)
Idle=temps inactif.
2. Seq  p * MS opt(p)
3. Il existe un chemin C dans G Idle (p-1) w(C).
4. Donc p*MS(,p)  (p+p-1)* MS opt(p)
 Garantir des performances.
• Soit G=(V,E,w) d’un graphe de tâches,
• Soit  un ordonnancement de listes.
• Soit MSopt ( ,p) la latence d’ordonnancement
optimal pour G sur p processeurs,
• Alors,
MS( ,p)  (2-1/p)MSopt( ,p)
 Ordonnancement basé sur le
chemin critique.

• Principe sur l’ordonnancement de listes.

•Principe : l’ordre de priorité dépend de la

valeur du niveau inférieur de la tâche

+ NS(T) est grand, + T est prioritaire.

 Ordonnancement basé sur le
chemin critique.
3 1
2
T(1) T(2) T(3)

3 6
3 4 4
T(4) T(5) T(6) T(7) T(8)

tâche T(1) T(2) T(3) T(4) T(5) T(6) T(7) T(8)

poids 3 2 1 3 4 4 3 6
Chemin 3 6 7 3 4 3 3 6
 T(3) T(8) T(7)
Ordonnancement
T(2) T(5) T(4)
de liste :
T(1) T(6)

T(3) T(6) T(7)

Ordonnancement T(2) T(5) T(4)

optimal:
T(1) T(8)

T(1) T(2) T(3) T(4) T(5) T(6) T(7) T(8)

poids 3 2 1 3 4 4 3 6
Chemin 3 6 7 3 4 3 3 6
4.3. Ordonnancement avec
communications
 Graphe de tâches avec
communications.
• Un graphe (ou système) de tâches avec
communication est un DAG G=(V,E,w,c) où
– V: ensemble fini de tâches.
– E: contraintes de précédence entre les tâches.
– w: V  correspond à la durée de la tâche.
– c: E  : coût de communication.
 Ordonnancement: définition
• Un ordonnancement d’un graphe de tâches
G=(V,E,w,c) doit préserver les dépendances:
– pour tout arc [u,v]  E dans G,
(u)+ w(u)  (v) si u,v s’exécute sur le même processeur.
(u)+ w(u) +c(u,v)  (v) sinon
Ordonnancement avec communications

Pb(p): déterminer un ordonnancement  de

latence minimale MS(,p) sur p processeurs.
Pb( ): déterminer un ordonnancement  de
latence minimale MS(,  ) ayant des
ressources illimités.
Les deux problèmes sont des
problèmes NP-complet.
 Exemple: énoncé
1
T(1) 1
5 1
5
T(3)
4 3
T(2)
2 2
T(4) T(5)
1
1,5
2 T(6) 1,5
1
T(7) 1
XX: coût de communication.
XX: durée d’une tâche
 1
T(1) 1
5
1
5
T(3)
4 3
T(2)
2 2
T(4) T(5)
1
1,5
2 T(6) 1,5
1
T(7) 1
Solution optimale :

T(3) T(4) T(5) T(6) T(7)

P(2)
T(1) T(2)
P(1)
0 1 2 3 4 5 6 7 8 9
 Heuristiques de liste pour Pb(p)
• Version naïve du chemin critique.
Principe : l’ordre de priorité dépend de la valeur du
niveau inférieur de la tâche.
Mais comment calculer le niveau inférieur ?
• Version du chemin critique modifié.
Version naïve du chemin critique
(CP).

• Principe : l’ordre de priorité dépend de la

valeur du niveau inférieur de la tâche.

• Calcul du niveau inférieur : en supposant

que toutes les tâches vont être affectées sur
des processeurs différentes.
 Retour à d’exemple.
T(1) 1 1
5
T(3)
5 4 3
T(2)
T(4) 2 T(5) 2 1
1,5 1
2 1,5
1
T(6)
1
T(7)

tâche T(1) T(2) T(3) T(4) T(5) T(6) T(7)

Chemin 14 8 11,5 6,5 6,5 3 1
critique
 Version du chemin critique
modifié (MCP).
• Principe: allouer une tâche libre au processeur
qui permet de débuter son exécution au plus
tôt, en fonction de précédentes affectations.

• Application sur l’exemple.

 Comment comparer les deux
heuristiques?
• En utilisant des exemples:
– Meilleur résultat pour CP que pour MCP.

T(1) 5
1 6
5
T(2) T(3) 3
3
2
T(4)
 Comment comparer les deux
heuristiques?
• Fork Graph :
T(1) w
– CP : 2w+c c c
w
– MCP: 2w+c si w>c T(2) T(3) w

3w si w<c
• Join Graph :
w
– Même solution : 2w+c T(2) c T(3)
c
– Non optimal pour w<c
T(1)w
 Comparaison des heuristiques.
• Théorique: garantir l’heuristique avec un
facteur d’approximation.

• Expérimentale : générer des graphes

aléatoires de tâches.

• Étude de cas: optimaliser pour certains

types de graphes.