Algorithme distribué

09/01/2017
M2‐ILC – Parallélisme, systèmes distribués et grille
Algorithmique distribuée
Stéphane Vialle
[email protected] http://www.metz.supelec.fr/~vialle
Algorithmique Distribuée
1. Produit de matrices sur tore de P processeurs
2. N‐corps sur un anneau de P = q×q processeurs
3. Quick‐sort sur hypercube de P = 2d processeurs
Produit de matrices sur tore de P proc
Algorithme distribué
A, B, C : n x n = N éléments
n
c   (a .b )
C = A . B
ij k 1 ik kj
O(Nbr d’opérations) = O(N3/2)
B
A
Quels partitionnement
et circulation ?
C
N  N éléments
P  P processeurs
1
09/01/2017
Produit de matrices sur tore de P proc
Algorithme distribué
Partitionnement 2D unique
(opérandes et résultats au même format)
0;0 0;1 0;2
1;0 1;1 1;2
2;0 2;1 2;2
0;0
0;1
0;2
1;0
1;1
1;2
2;0
2;1
2;2
P  P blocs de
N  N éléments
P
P
N  N éléments
P  P processeurs
Produit de matrices sur tore de P proc
Algorithme distribué
Schémas de circulation :
Circulation des blocs de A en ligne
Circulation des blocs de B en colonne
B
A
C
 Chaque processeur voit passer toutes les données utiles à ses calculs
Produit de matrices sur tore de P proc
Algorithme distribué
Problème de séquencement :
besoin simultané des blocs
A et B
i, k
k, j
n
c   (a .b )
ij k 1 ik kj
C = A . B
Seuls les processeurs de la première diagonale sont satisfaits !
0;0
1;1
1;0
1;0
2;0
C
1;2
1;2
1;1
2;1
2;0
A
0;2
0;1
0;0
B
0;2
0;1
2;1
2;2
2;2
 Modifier le partitionnement initial
2
09/01/2017
Produit de matrices sur tore de P proc
Algorithme distribué
Démarche :
On conserve le principe du partitionnement en 2D
On conserve le schéma de circulation (A en ligne, B en colonne)
Mais on cherche un partitionnement initial adapté …
… on place les données de PE(0;0), et on propage les contraintes
PE(0;0)
Blocs A(0;0)
et B(0;0)
placés sur PE(0;0)
0;0
0;0
Produit de matrices sur tore de P proc
Algorithme distribué
Les schémas de circulation imposent :
• les blocs de A sur la première ligne de processeurs
• les blocs de B sur la première colonne de processeurs
Circulation en
colonne vers le haut
0;0
Circulation en ligne
vers la gauche
0;2
0;1
0;0
1;0
2;0
Produit de matrices sur tore de P proc
Algorithme distribué
L’algorithme de produit matriciel impose :
• les blocs de B sur la première ligne de processeurs
• les blocs de A sur la première colonne de processeurs
0;0
Blocs compatibles







A et B 
i, k
k , j 
2;2
1;1
0;1
0;0
0;2
Blocs compatibles






A et B 
i,k
k , j 
1;0
1;1
2;0
2;2
3
09/01/2017
Produit de matrices sur tore de P proc
Algorithme distribué
Les schémas de circulation imposent :
• les blocs de A sur les lignes de processeurs restantes
• les blocs de B sur les colonnes de processeurs restantes
1;1
0;0
3;3
2;2
2;2
1;1
0;2
0;1
1;1
0;0
2;1
1;0
2;2
1;1
0;1
2;0
… Oui! On a toujours :





0;2
1;0
1;2
2;0
3;3
2;2
On vérifie si les nouveaux couples sont compatibles…
1;2


A et B 
i, k
k , j 
Blocs compatibles
2;1
Produit de matrices sur tore de P proc
Algorithme distribué
Finalement : • Partitionnement fixé sur tous les processeurs
• Tous les couples de blocs sont compatibles à la première étape
• Tous les couples de blocs sont compatibles après chaque circulation
1;1
0;0
2;1
1;0
2;2
1;1
0;2
0;1
2;0
Colonne 0 décalée de 0 cran vers le haut
Colonne 1 décalée de 1 cran vers le haut
Colonne 2 décalée de 2 cran vers le haut
Généralisation …
1;0
1;2
2;0
3;3
2;2
0;2
0;1
1;1
0;0
3;3
2;2
2;2
1;1
1;2
Puis Calcul complet en étapes
P
2;1
Produit de matrices sur tore de P proc
Algorithme distribué
Algorithme de Canon :
Produit de matrices de éléments sur un tore de procs. N N
P P
1 – Partitionnement des matrices en
P  P blocs de N  N éléments
P
P
0;00;10;2
1;01;11;2
2;02;12;2
1 2
2 – Pré‐décalages initiaux des blocs sur le tore de proc : - ligne i ([0; P -1]) : décalage de i crans ,
1
- colonne j ([0; P -1]) : décalage de j crans .
2
3 ‐ P étapes {calculs : somme partielle de C(i,j);
circulations : A(i,j) 1 cran , et B(i,j) 1 cran }
4 – Dernière circulation ou post décalages de A et B si nécessaire.
4
09/01/2017
Produit de matrices sur tore de P proc
Algorithme distribué
Pseudo‐Code de l’algorithme de Canon sur chaque processeur :
main()
{
partitionnement();
predecalage();
barriere();
for (step=0; step < SQRT_P-1; step++) {
multiplication_locale();
circulation_ligne_colone();
barriere();
}
multiplication_locale();
postdecalage();
}
Post‐décalage : • nécessaire si on souhaite réutiliser les matrices pour des opérations variées (+, x, …)
Produit de matrices sur tore de P proc
Modélisation des performances
1 ‐ Performances avec messages bloquants et sans recouvrement :
pré - décalages; P étapes de calcul et P -1 circulations; postdécalage
Hyp : Toutes les communications peuvent se faire en parallèle
Modélisation en « ts+Q.tw »
 2. P 1. N .tw

 P
‐ dans un vrai tore unidirectionnel : 

 2. P 1. N .tw
t
post  decal 
 P
• Pré et Post décalages :
‐ dans un cluster :
t

pre  decal

 2. N .tw
P
t
 2. N .tw
post  decal
P
t
pre  decal
Produit de matrices sur tore de P proc
Modélisation des performances
1 ‐ Performances avec messages bloquants et sans recouvrement :
pré - décalages; P étapes de calcul et P -1 circulations; postdécalage
N
N
• Pré et post décalage : t pre  decal  2. .tw et : t post  decal  2. .tw
P
P
N
t
 2. .tw
• Circulation :
1 circ
P
3/ 2
 2. N .t
t
• Calcul :
1 calc
P3/2 flop
Donc sur un cluster,
avec des msgs bloquants :
T par (P)  2. N
3/ 2
P
.t
 2. P 1 N .tw

 P

flop

5
09/01/2017
Produit de matrices sur tore de P proc
Modélisation des performances
1 ‐ Performances avec messages bloquants et sans recouvrement :
pré - décalages; P étapes de calcul et P -1 circulations; postdécalage
• Temps parallèle sur cluster :
T par (P)  2. N
3/ 2
P
 2. P 1. N .tw
 P



.t
flop
• Temps séquentiel : T  2.N 3/ 2.t
seq
flop
• Speed up sur cluster
1
S (P)  P. 

avec msgs bloquants :
1  P 1.tw

N .t

flop
On retrouve l’asymptote idéale
Donc : S (P)  P
N 
Produit de matrices sur tore de P proc
Modélisation des performances
2 ‐ Performances avec msgs non bloquants et sans recouvrement :
pré - décalages; P étapes de calcul et P -1 circulations; postdécalage
Hyp : Toutes les communications peuvent se faire en parallèle
Modélisation en « ts+Q.tw »
  P 1. N .tw

 P
‐ dans un vrai tore unidirectionnel : 

t
  P 1. N .tw
post  decal 
 P
• Pré et Post décalages :
t
pre  decal


 N .t
pre  decal P w
 N .t
t
post  decal P w
t
‐ dans un cluster :
Produit de matrices sur tore de P proc
Modélisation des performances
2 ‐ Performances avec msgs non bloquants et sans recouvrement :
pré - décalages; P étapes de calcul et P -1 circulations; postdécalage
N
N
• Pré et post décalage : t pre  decal  .tw et : t post  decal  .tw
P
P
• Circulation :
t
1 circ
• Calcul :
t
1 calc
Donc sur un cluster, avec
des msgs non‐bloquants :
 N .tw
P
3/ 2
 2. N .t
P3/ 2 flop
T par (P)  2. N
3/ 2
P
.t
  P 1 N .tw

 P

flop

6
09/01/2017
Produit de matrices sur tore de P proc
Modélisation des performances
2 ‐ Performances avec msgs non bloquants et sans recouvrement :
pré - décalages; P étapes de calcul et P -1 circulations; postdécalage
• Temps parallèle sur cluster :
T par (P)  2. N
3/ 2
P
.t
  P 1 N .tw

 P

flop

• Temps séquentiel : T  2.N 3/ 2.t
seq
flop
• Speed up sur cluster 1
S (P)  P. 

avec msgs non‐bloquants :
1  P 1.tw 2. N .t

Donc : S (P)  P
N 

flop
On retrouve l’asymptote idéale
Produit de matrices sur tore de P proc
Modélisation des performances
3 ‐ Performances avec msgs non bloquants et avec recouvrement :
pré - déc; P -1 calculs et P -1 circulations; 1 calcul et postdec
Hyp : Toutes les communications peuvent se faire en parallèle
Modélisation en « ts+Q.tw »
  P 1. N .tw

 P
‐ dans un vrai tore unidirectionnel : 

t
  P 1. N .tw
post  decal 
 P
• Pré et Post décalages :
t
pre  decal


 N .t
pre  decal P w
 N .t
t
post  decal P w
t
‐ dans un cluster :
Produit de matrices sur tore de P proc
Modélisation des performances
3 ‐ Performances avec msgs non bloquants et avec recouvrement :
pré - déc; P -1 calculs et P -1 circulations; 1 calcul et postdec
N
N
• Pré et post décalage : t pre  decal  .tw et : t post  decal  .tw
P
P
N .t
t

• Circulation :
w
1 circ
P
3/ 2
N
t
 2.
.t
• Calcul :
1 calc
P3/ 2 flop
T par (P)  t


pre  dec
   .max(t
  P 1. .max t
;t
;t
)

1 calc post  dec


 1 calc 1 circ 


3/ 2
T par (P)  N .tw  P . .max 2. N
.t
; N .tw 
3
/
2
flop
P
P


P




7
09/01/2017
Produit de matrices sur tore de P proc
Modélisation des performances
3 ‐ Performances avec msgs non bloquants et avec recouvrement :
pré - déc; P -1 calculs et P -1 circulations; 1 calcul et postdec
• Temps parallèle sur cluster :
Rappel : Calculs prépondérants, donc :
3/ 2
N / N  N T par  2.. N
.t
 N tw
0
0
P flop P
• Temps séquentiel :
Tseq  2.N 3/ 2.t
flop
• Speed up sur cluster avec
msgs non‐bloquants et
recouvrement :
N / N  N  S (P)  P.
0
0
 t
Hyp :    ( N , P) 1 Donc : S (P)  P
N 
N 
1
w 2 N .t flop
On retrouve l’asymptote idéale
Produit de matrices sur tore de P proc
Modélisation des performances
Expérimentation du produit de matrices en tore sur cluster de PC
• 12 x P3 ‐ 700MHz
• Fast Ethernet
• 3 switchs
• Cluster « Beowulf »
• 3 implants. en MPI
(voir chap MPI) • Performances correctes
Mflops
• L’envoi de messages
non‐bloquant est
efficace.
• Le recouvrement est
encore plus efficace,
il gomme le passage
à 3 switchs.
1300
1200
1100
1000
900
800
700
600
500
400
300
200
100
0
Torus-Sendrecv-replace
Torus-Irsend
Torus-Irsend+overlapp
1
2
3
4
5
6
7
8
9 10 11 12 13
Number of nodes
Produit de matrices sur tore de P proc
Modélisation des performances
Comparaison Anneau/Tore pour le produit de matrices :
Anneau
Bloquant
Non‐bloquant
Recouvrement
Tore
3/ 2
3/ 2
T par (P)  2. N
.t
 N .tw T par (P)  2. N
 2. P 1 N .tw
.t
 P
P flop 
P flop
T par  2. . N
3/ 2
P
.t
flop
T par  2. . N
3/ 2
P
.t
Nt
flop P w
Bilan :
bloquant → P = 4 : tore plus lent, P = 9 : tore plus rapide
Le tore est plus rapide pour P > 7
non bloquant → L’anneau est toujours plus rapide !
Même temps de boucle calcul‐circulation, mais
prédécalage à faire en plus sur le tore!
8
09/01/2017
Produit de matrices sur tore de P proc
Modélisation des performances
MFlops
Tests sur cluster « Beowulf » :
1200
1000
800
600
400
200
0
Ring-Sendrecv-replace
Ring-Irsend+overlapp
1
12 x P3 ‐ 700MHz
Fast Ethernet & 3 switchs
2
3
4
5 6 7 8 9 10 11 12 13
Number of nodes
1200
• bloquant (sans recouvrement) :
P= 4 : tore plus lent
P= 9 : tore plus rapide
 normal !
400
Torus-Sendrecv-replace
200
Torus-Irsend
Mflops
• non‐bloquant + recouvrement :
(presque) pas de différence
 normal !
1000
800
600
Torus-Irsend+overlapp
0
1
2
3
4
5
6
7
8
9
10 11 12 13
Number of nodes
Algorithmique Distribuée
1. Produit de matrices sur tore de P processeurs
2. N‐corps sur un anneau de P = q×q processeurs
3. Quick‐sort sur hypercube de P = 2d processeurs
Problème des N‐Corps sur anneau de processeurs
Définition
Calcul des trajectoires de N corps en attraction mutuelle: • N molécules en interaction électrostatique
• N planètes en interaction gravitationnelle
•…

 
A t : N triplets ( Pos n , V n , a n )
i i i
n
 G.m P os n  Pos n 

j
j
i 
n
Avec : a   
.

i
j  i  (d n ) 2

dn
ij
 ij




D' où : V n1  V n  a n .t
i
i
i
 n1  n  n

 Pos  V .t  a n .(t ) 2
Pos
i
i
i
i
m
i
Vn
i
f
f
ij
f
il
m
i
m
j
ik m
k
m
l
V n 1
i
9
09/01/2017
Problème des N‐Corps sur anneau de processeurs
Définition
Dans sa forme initiale :
• Tous les corps interagissent avec tous les autres
 Long range data interaction
 O(N²) : plus complexe qu’un produit de matrices (O(N3/2))
Dans sa forme usuelle :
• On ignore les influences trop lointaines (trop faibles) : on se limite à un rayon d’influence
 perte de précision, mais : α.N².t1‐influence  α.n².t1‐influence
avec : n << N
Dans tous les cas :
Le problème des N‐corps reste un problème très lourd (O(N²))
qui sature très vite les ordinateurs  besoin de parallélisation
Problème des N‐Corps sur anneau de processeurs
Algorithme distribué
Principe de parallélisation :
• Chaque processeur « gère » l’évolution de N/P corps.
• On fait circuler les coordonnées courante des N corps sur l’anneau.
• A chaque étape : chaque processeur accumule l’influence des N/P corps dont il reçoit les coordonnées sur ses N/P corps.
• Après P étapes, chaque processeur calcule les nouvelles coordonnées
de ses N/P corps.
Réalisation : On utilise une partition fixe et une partition circulante
Coord. courantes des N corps :
partition circulante par bloc de N/P
Influences subies par les N/P corps : partition fixe par bloc de N/P
PE‐i
Problème des N‐Corps sur anneau de processeurs
Algorithme distribué
• Calculs partiels
• Permutation
des buffers
• Sauvegarde des derniers calculs
Cycles
• Calculs partiels
• Circulation
P‐1 étapes
• Partitionnement initial ‐ N/P corps par PE
‐ duplication locale
PE‐0
PE‐1
PE‐(P‐1)
PE‐0
PE‐1
PE‐(P‐1)
PE‐0
PE‐1
PE‐(P‐1)
PE‐0
PE‐1
PE‐(P‐1)
10
09/01/2017
Problème des N‐Corps sur anneau de processeurs
Modélisation
Performances avec msgs bloquants (sans recouvrement) :
Hyp : Toutes les communications peuvent se faire en parallèle ;
Modélisation en « ts+Q.tw »
• Temps séquentiel : Tseq ( N )  Cycle.N 2.k.t
• Temps parallèle :
flop
t
 ( N )2.k.t
1calc P
flop
 N .tw
t
1circ P
T par (P, N )  Cycle.(P.t
 (P 1).t
)
1 circ
1 calcul
Donc, avec des N2
P 1
msgs bloquants : T par (P, N )  Cycle.( P .k.t flop  P .N .tw)
Problème des N‐Corps sur anneau de processeurs
Modélisation
Performances avec msgs bloquants (sans recouvrement) :
• Accélération :
1
S (P, N )  P.
(P 1).tw
1
N .k.t
flop
Donc : S (P)  P
N 
On retrouve l’asymptote idéale
• Rapport Calculs/Communications :
Calculs O ( N 2 )

 O( N )
Comms O( N )
Très bon rapport ! Encore meilleur que celui du produit de matrices
En augmentant N les performances finiront toujours par être bonnes !
Problème des N‐Corps sur anneau de processeurs
Modélisation
Performances avec msgs non‐bloquants et avec recouvrement :
Hyp : Toutes les communications peuvent se faire en parallèle ;
Modélisation en « ts+Q.tw »
• Temps séquentiel : Tseq ( N )  Cycle.N 2.k.t
flop
• Temps parallèle :



T par (P, N )  Cycle. .(P 1).Max(t
,t
)t

1 calcul 1 circ 1 calcul 

2
N / N  N  T par (P, N )  Cycle.( .(P 1) 1). N .k.t
0
0
flop
P2
Donc, avec des msgs
N2
non‐bloquants et du N / N  N T
par (P, N )  Cycle. . .k.t flop
0
0
recouvrement :
P
11
09/01/2017
Problème des N‐Corps sur anneau de processeurs
Modélisation
Performances avec msgs non‐bloquants et avec recouvrement :
• Accélération :
S ( P, N ) 
Cycle.N 2.k.t
flop
2
Cycle. N .k.t
P
flop
S (P, N )  P. 1

Hyp :    ( N , P) 1
N 
Donc : S (P)  P
N 
On retrouve (encore) l’asymptote idéale
Algorithmique Distribuée
1. Produit de matrices sur tore de P processeurs
2. N‐corps sur un anneau de P = q×q processeurs
3. Quick‐sort sur hypercube de P = 2d processeurs
Quick‐sort sur hypercube de processeurs
Algorithme séquentiel
Principe :
• Tri récursif
• Diviser-pour-régner
• Séparation des données
selon des valeurs pivots
p21
<
p1
<
<
p22
<
Performances :
pire cas :
moyen cas (Knuth) :
meilleur cas :
 N.(N - 1) 

.t
2

 comp
 O( N 2 )
N.log2 ( N )  2.N  1.tcomp
 O (2.N . log( N ))
 O( N . log( N ))
12
09/01/2017
Quick‐sort sur hypercube de processeurs
Algorithme séquentiel
Implantation séquentielle :
void QuickSort(double *A, int q, int r)
{
int s, i;
double pivot;
}
if (q < r) {
/* Partitionement
*/
pivot = A[q];
/* Choix du pivot … */
s = q;
for (i = q+1; i <= r; i++) {
if (A[i] <= pivot) {
s = s+1;
exchange(A,s,i);
}
}
exchange(A,q,s);
QuickSort(A,q,s-1); /* Appels recursifs */
QuickSort(A,s+1,r);
}
Quick‐sort sur hypercube de processeurs
Parallélisation naïve
Principe :
p21
<
p1
<
<
P0
P0
p22
<
P0
P1
P2
P1
P3
On crée un nouveau processus et on utilise un nouveau processeur
à chaque appel récursif (en réutilisant les anciens).
Bilan :
• Simple, facile à implanter en mémoire partagée
• Mais inefficace !
Quick‐sort sur hypercube de processeurs
Parallélisation naïve
1 - Faiblesse conceptuelle :
Algorithme pas pleinement parallèle
 Trouver plus parallèle !
P
t
2 - Faiblesse de mise en œuvre :
Ressources (CPU) partagées :
 Temps de création dynamique et
de re-répartition de processus
Ressources (CPU) allouées au
lancement de l’application :
 Gaspillage !
P
t
P
t
13
09/01/2017
Quick‐sort sur hypercube de processeurs
Propriétés des hypercubes
• Construction récursive :
…………
Dim 1
Dim 2
Dim 3
Dim 4
• Numérotation récursive binaire :
00
0
01
1
10
Dim 1
Dim 2
11
000
100
001
101
010
110
011
111
Dim 3
Quick‐sort sur hypercube de processeurs
Propriétés des hypercubes
• Décomposition en sous-hypercube :
1 hypercube de dimension n coupé par un hyper-plan donne 2
sous-hypercubes de dimension n-1 :
ou
1 x dim 3
2 x dim 2
ou
2 x dim 2
2 x dim 2
 Les algorithmes de routages restent les mêmes dans toutes
les parties de l’hyper-cube
Quick‐sort sur hypercube de processeurs
Propriétés des hypercubes
• Distance entre nœuds :
Le nombre de bits différents dans les adresses de deux nœuds donne
leur distance (si la numérotation a suivi la construction récursive)
000
100
A
001
Ex :
A : 000, B : 011
d(M,N) = 2
B
011
Ex :
M : 110, N : 001
d(M,N) = 3
101
010
110
N
M
111
 Les algorithmes de routages seront à base de calculs simples
(et rapides)
14
09/01/2017
Quick‐sort sur hypercube de processeurs
Algorithme sur hypercube
Objectif :
• Tous les processeurs doivent travailler tout le temps !
• S’inspirer d’un tri séquentiel rapide (O(N.log(N))) : quick-sort
 Trouver un schéma de parallélisation avec comm. optimisées
(peu de comm, ou comm locales)
Idée : Quick-sort : algo récursif  topologie récursive : Hyper-cube
p11
p12
p0
…….
Quick‐sort sur hypercube de processeurs
Algorithme sur hypercube
Init : Chaque nœud charge N/P données en local
Etape 0 :
• Choix de 20 pivots pour les 20 hypercubes de dimension d-0
• Séparation selon le pivot sur chaque nœud de l’hypercube
• Echange des listes inférieures et supérieures en dimension d-0
• Fusions locales des listes conservées et des listes reçues
000
100
001
Pivot0
101
010
110
011
111
Communication avec voisin en dimension d‐0 : seul le bit d‐0 diffère
Quick‐sort sur hypercube de processeurs
Algorithme sur hypercube
Détails de l’étape 0 sur PE-000 et PE-100 :
100
000
Pivot0
000
x < Pivot0
x > Pivot0
100
x < Pivot0
x > Pivot0
Séparations
locales
000
100
000
100
000
Fusion des sous100 listes
conservées
et reçues
Echanges de
sous-listes
15
09/01/2017
Quick‐sort sur hypercube de processeurs
Algorithme sur hypercube
Etape 1 :
• Choix de 21 pivots pour les 21 hypercubes de dimension d-1
• Séparation selon un pivot sur chaque nœud des 21 hypercubes
• Echange des listes inférieures et supérieures en dimension d-1
• Fusions locales des listes conservées et des listes reçues
000
001
Pivot12
100
101
010
Pivot11
110
111
011 Communication avec voisin en dimension d‐1 : seul le bit d‐1 diffère
Quick‐sort sur hypercube de processeurs
Algorithme sur hypercube
Etape 2 :
• Choix de 22 pivots pour les 22 hypercubes de dimension d-2
• Séparation selon un pivot sur chaque nœud des 22 hypercubes
• Echange des listes inférieures et supérieures en dimension d-2
• Fusions locales des listes conservées et des listes reçues
Pivot21
000
001
100
Pivot23
010
110
101
Pivot22
Pivot24
011
Communication avec voisin en dimension d‐2 : seul le bit d‐2 diffère
111
Quick‐sort sur hypercube de processeurs
Algorithme sur hypercube
Etape finale :
Chaque processeur tri en local sa liste finale
 ex : quick-sort local et séquentiel sur chaque processeur
000
100
101
010
110
000
001
100
011
111
001
101
010
110
011
111
16
09/01/2017
Quick‐sort sur hypercube de processeurs
1ère implantation
HcubeQuickSort(double *A, int d)
{
int i;
/*
double *Ainf, *Asup, *Abuf; /*
double x;
/*
for (i = d-1; i >= 0; i--) { /*
x = choix_pivot(me,i);
/*
partitioner(A,x,Ainf,Asup);
if (me & exp2(i) == 0) {
/*
asend(Asup,me | exp2(i));
recv(Abuf,me | exp2(i));
union(Ainf,Abuf,&A);
} else {
asend(Ainf,me & ~exp2(i));
recv(Abuf,me & ~exp2(i));
union(Abuf,Asup,&A);
}
}
QuickSortSequentiel(A);
/*
}
/*
Compteur de dimension. */
Tables de données.
*/
Pivot.
*/
Pour chaque dimension: */
- Partitionnement local*/
- Communications
*/
Tri final des donnes
locales
*/
*/
Quick‐sort sur hypercube de processeurs
1ère implantation
Faiblesse de ce premier hyper-quicksort :
Si mauvais choix de pivot : déséquilibre définitif !
 processeurs surchargés et processeurs à vide
[]
[]
Pivot0
[]
[]
 Soigner le choix du pivot.
Quick‐sort sur hypercube de processeurs
Algorithme optimisé
Choix de pivot optimisé :
Pivot idéal :
élément médian
En séquentiel : on approxime l’élément médian, ex :
• l’élément médian des 5 premiers,
• l’élément médian d’un échantillonnage, ….
En parallèle :
• on trie initialement les éléments locaux
 on prend l’élément médian ! LocalTab[N/P/2]
• on suppose une distribution homogène sur tous les PEs
 le pivot idéal d’un PE est un très bon pivot pour tous !
17
09/01/2017
Quick‐sort sur hypercube de processeurs
Algorithme optimisé
Principe de l’hyper-quicksort optimisé :
Manipulation de listes ordonnées !
Chargement de N/P
données par proc.
Tris initiaux locaux
Séparation & échanges Séparation & échanges Séparation & échanges
de listes ordonnées
de listes ordonnées
de listes ordonnées
Quick‐sort sur hypercube de processeurs
2ème implantation
Implantation de l’hyper-quicksort optimisé :
HcubeQuickSort(double *A, int
{
int i;
double *Ainf, *Asup, *Abuf;
double x;
QuickSortSequentiel(A);
}
d)
/* Compteur de dimension. */
/* Tables de données.
*/
/* Pivot.
*/
/* Tri initial des donnes */
/* locales.
*/
for (i = d-1; i >= 0; i--) { /* Pour chaque dimension: */
x = choix_pivot(me,i);
/* - Partitionnement local*/
partitioner(A,x,Ainf,Asup);
if (me & exp2(i) == 0) {
/* - Communications
*/
asend(Asup,me | exp2(i));
recv(Abuf,me | exp2(i));
union_ordonne(Ainf,Abuf,&A);
} else {
asend(Ainf,me & ~exp2(i));
recv(Abuf,me & ~exp2(i));
union_ordonne(Abuf,Asup,&A);
}
}
Quick‐sort sur hypercube de processeurs
Modélisation simple des perfs.
Etapes de l’algorithme final :
Complexité de chaque étape :
N
N
O( . log( ))
P
P
O(1)
1 - Tris initiaux-locaux
3 - Diffusion d’un pivot à un
hypercube de dimension d-i
4 - Partitionnements locaux :
dichotomie selon pivot
5 - Echange de listes ordonnées
6 - Fusion de listes ordonnées
log2(P) itérations
2 - Calcul de pivot : A[N/(2P)]
O(d  i )  O (log( P )  i )
N
O(log( ))
P
N
O( )
2P
N
O( )
P
18
09/01/2017
Quick‐sort sur hypercube de processeurs
Modélisation simple des perfs.
O(T
par
( N , P )) 
N
N
. log( )) 
P
P

 log ( P )  1

 2
N
O(log( P ))  O
(log ( P )  i )   O(log( P ). log( )) 

2
P

 i0


N
N
O(log( P ).
)  O (log( P ). )
2.P
P
O(
O(T
par
N
N
( N , P ))  O ( . log( )) 
P
P
N
N
log 2 ( P)
O (log( P))  O (
)  O(log( P ). log( ))  O(log( P ). )
P
P
2
Quick‐sort sur hypercube de processeurs
Modélisation simple des perfs.
O(T
par
N
N
( N , P ))  O ( . log( )) 
P
P
log 2 ( P)
N
N
)  O(log( P ). log( ))  O(log( P ). )
O (log( P))  O (
2
P
P
Pour P fixé (sur une machine parallèle donnée) :
O(T
par
( N ))  O( N . log( N ))  O (log( N ))  O ( N )
O(T
par
( N ))  O( N . log( N ))
Idem tri
séquentiel !!
Quick‐sort sur hypercube de processeurs
Modélisation simple des perfs.
Bilan de la modélisation rapide de l’hyper-quick-sort:
O(T
par
( N ))  O( N . log( N ))
• Le tri séquentiel initial des données locales masque encore tout !
 Tri séquentiel  Hyper-Quicksort !
• Raisonner plus finement sur des ordres de grandeurs est délicat !
ex : O(N/P.log(N/P)) + O(log(P)) <?> O(N.log2(P))
 Faire une modélisation plus précise – ne pas se contenter des
ordres de grandeur : calculer les TEMPS d’exécution
Rappel : Une parallélisation réelle sur une machine à P processeurs :
• Ne change pas la complexité du problème
• Divise juste le temps par une valeur fixe (le speed up!)
19
09/01/2017
Quick‐sort sur hypercube de processeurs
Modélisation détaillée des perfs.
T
T
par
par
N
N
(log( P )  1). log( P)
. log( ).t

.(t s  t w ) 
P comp
P
2
N
N

log( P). log( ).t
 log( P ). t 
.t  
P comp
 s 2.P w 
N
log( P). .t
P comp
( N , P)   .
( N , P) 
N
N
N
N
 log( P ). log( ).t
 log( P). .t

P comp
P comp
P
P comp
(log( P )  1). log( P)
N
.(t s  t w )  log( P ). t 
.t 
2
 s 2 .P w 
 . . log( ).t
 Sera utile plus loin (pour comparaison au tri bitonique parallèle)
Quick‐sort sur hypercube de processeurs
Bilan de la modélisation des perfs.
Démarche :
1 - Modélisation du temps d’exécution de l’hyper-quicksort :
• hyp sur le réseau d’interconnexion des processeurs
• modélisation de base des communications
• hyp sur la distribution des données et la qualité des pivots
hqs
T
( N , P )  ...
par
2 - Comparaison aux temps d’exécution d’autres tris parallèle :
hqs
T
( N , P )  ?  T bs ( N , P )
par
par
3 - Confrontation à l’expérimentation
Problèmes : beaucoup d’hypothèses  manque de précision
• Modéliser pour classifier les solutions,
• Expérimenter pour connaître les temps d’exécution
Algorithmique distribuée
Fin
20