Cours 2. Algorithmes Parallèles sans communication

(1)

Cours 2. Algorithmes Parallèles sans communication

Machine UMA Noeud SMP

Problèmes de gros grain

1

www-id.imag.fr/Laboratoire/Membres/Roch_Jean-Louis/perso.html/enseignement.html/

(2)

Fichier compressé

Fichier en entrée

Compression à la volée

Gzip séquentiel

Partition dynamique en blocs

Comment paralléliser gzip ?

Parallélisation

Blocs

compressés Compression

parallèle

Partition en blocs

2

(3)

● Comment choisir les blocs ?

● Objectif cours 2: programme parallèle tel que Tp ≈ (Tseq/ p ) + ε

● Base : algo parallèle + ordt “glouton” [cours 1]

Tp < (T1/ p ) + T∞

... mais T1 >> Tseq ☹

● Techniques pour limiter le surcoût dû au parallélisme

3

(4)

Cours 2. Algorithmes Parallèles sans communication

I. Introduction

II. Contrôle de la granularité

III. Mise en oeuvre de l'ordonnancement

IV. Application: recherche arborescente Contrôle de l'espace mémoire

4 Machine UMA

Noeud SMP

(5)

1. Contrôle de la granularité

● Limiter le surcoût dû au parallélisme :

 T

1 : temps de l'algorithme parallèle

 T

seq : temps du « meilleur » algo séquentiel

 Objectif : T

1 = T

seq

● Mais en gardant T_∞ aussi petit que possible

5

C. Leiserson : « A minicourse on multithreaded algorithms »

supertech.lcs.mit.edu/cilk/papers ftp://theory.lcs.mit.edu/pub/cilk/minicourse.ps.gz J.L. Roch : « Parallel efficient algorithms and their programming »

www-id.imag.fr/~jlroch/perso.html/ps/polycop-algo-par.ps.gz p.4-22

(6)

Adapter la granularité

● Utiliser un algorithme séquentiel pour limiter le parallélisme

● Découpe récursive parallèle

● => Stopper la découpe récursive à un seuil K

● Exemple : produit itéré en Cilk

Cilk void ParProduit (int i, int j, int& res ) { if ( j-i < K ) { res = SeqProduit(i,j) ; } else {

int r1, r2 ;

spawn ParProduit ( i, (i+j)/2, r1 ) ; spawn ParProduit ( (i+j)/2+1; j , r2 ) ; sync ;

res = r1 * r2 ; }

}

int SeqProduit (int i, int j) { int r = 1;

for (int s = i ; s <j; s++ ) r = r*s ; return r ;

}

6

(7)

Choix du seuil K

● Compromis séquentiel/parallèle

● Expérimentalement

● Théoriquement :

 K le plus grand possible sans perte de parallélisme

• K qui minimise T

1

(Κ) avec T_∞^(Κ)=Θ(T_∞)

 Exemple : produit itéré

7

(8)

Exemple 2 : Préfixe parallèle

● Entrée : X[0..n-1] un tableau d'éléments * : loi associative

● Sortie : Π[0..n-1] avec Π[k] = X[0] * ... *X[k]

● Démarche :

 1/ Algorithme séquentiel de référence : SeqPrefixe

 2/ Parallélisation : algorithme ParPref1

 3/ Adaptation de granularité : algorithme ParPrefK

 4/ Choix de K : compromis théorie - pratique

8

(9)

Exemple 3 : gzip

● TailleBloc := ... ;

for( i=0; i<n/TailleBloc ; i++)

Fork<gzip>( Fich[i*TailleBloc ... min (n, (i+1)*TailleBloc -1 ] ;

● Choix de K :

 Expérimental

• TailleBloc ~ 0.5 Mo

 Théorique :

• TailleBloc ~

 Théorique :

• TailleBloc ~

9

4 processors computer

0 10 20 30 40 50 60 70 80 90

1,106 2,089 2,263 4,260 6,769 7,905 8,960 10,957 15,962 19,298 21,914 Size of file (Ko)

Time (in seconds)

Sequential gzip Athapascan gzip

(10)

Exemple 4 : exercice Tri par fusion

10

C. Leiserson : « A minicourse on multithreaded algorithms » ftp://theory.lcs.mit.edu/pub/cilk/minicourse.ps.gz p 9-12

(11)

Cours 2. Algorithmes Parallèles sans communication

I. Introduction

=> Généralisation : algorithmes en cacade

III. Mise en oeuvre de l'ordonnancement

11 Machine UMA

Noeud SMP

(12)

Jeu : Calculer le maximum

● But : construire le circuit le plus rapide possible pour calculer le maximum :

- Entrée : n éléments ai distincts (ordre total <) - Sortie : l'élément maximum

● Portes disponibles

● Arité non-bornée :

wireless comm: multiple access (SDMA/FDMA/CDMA)

CRCW : Concurrent Read Concurrent Write

And Or < ? Max

12

(13)

Coûts et

algorithmes ultra-rapides

0 5E+42 1E+43 1,5E+4

3 2E+43 2,5E+4

3 3E+43

10 20 30 40 50 60 70 80 90 100

exp n n

Log n LogLog n

13

(14)

Circuit séquentiel de base

T1 = n #procs = n portes

Max

an a2

res := a₁ ;

For i :=2 .. n do res := Max ( res, a_n ) ;

Return res;

a1 a2

Circuitseq

14

(15)

Circuit parallèle

T1 = log₂ n #procs = n portes

Function max2(a_i .. a_k ) { if (i == k) return a_i ;

else {

PARALLEL {

rl = max2(a_i .. a_(i+k)/2 ) ; rh = max2(a_(i+k)/2+1 .. a_k);

}

return Max( rl, rh ) ; }

a_n a₁ a₂ a₃ a₄

Max

Max Max

Max

Circuitpar

15

(16)

a_k = Max^(a₁^{.. a}_n⁾ ⇔ ^a_k > ^a_i∀ i=1..n, i /= k

Un circuit ultra-rapide pour tester si un élément a

k

est le max

< ? < ? < ?

a_k a₁ a_k a₂ a_k a_n

Multiple Access OR

T1(n) = O(1) ☺ #portes = O(n) ☹

Vrai ssi ak n'est pas maximum CircuitTest

16

(17)

Application: calcul du maximum

T1(n) = O(1) ☺ #portes = O(n2) ☹

CircuitTest

a1 … an

a1 CircuitTest CircuitTest

a1 … an a1 … an

a2 an

Seulement 1 écriture pour calculer le maximum

CircuitCste

17

(18)

Un circuit recursif ultra-rapide

● Time(n) = Time(n^0.5) + O(1) = loglog n

● #procs (n) = n^0.5.#procs(n^0.5) = n loglog n CircuitRec

a1 … a √ n

CircuitRec CircuitRec

a √ n+1 … a2 √ n an- √ n … an

CircuitRec Max(a

1 a _√_n) ^Max(a√ n+1 … a_{2 √ n} ) Max(an- √ n … an )

CircuitCste on only sqrt(n) = n0.5 elts

18

● Granularité : utiliser l'algo rapide pour accélérer

(19)

Réduction du nombre de portes

● Granularité: utiliser un algo économique pour réduire le nombre de portes

Circuitseq

a1 … a loglog n

Circuitseq Circuitseq

a loglog n+1 … a2 loglog n an- loglog n … an

CircuitUltra

Max(a1 … a loglog n)Max(aloglog n+1 … a2loglog n ) Max(an-loglog n … an )

Circuitrec on only n/loglog n elts

19

(20)

Conclusion : un algo ultra-rapide

Algorithme final : temps = loglog n #portes=n Technique utilisée : « cascading »

mélange de 3 algorithmes pour construire un compromis plus performant :

temps et nombre de portes

Technique importante en parallélisme (adaptation de granularité)... et en génie logiciel

-> nombreuses applications : [ATLAS, FFTW, ...]

20

(21)

Cours 2. Algorithmes Parallèles sans communication

I. Introduction

III. Mise en oeuvre de l'ordonnancement

21 Machine UMA

Noeud SMP

(22)

Principe

● Lancement de p threads

 1 thread == processeur virtuel

● Chaque thread :

 While (not fin)

• Attendre une tache t prete

• L'exécuter

● Liste centralisée + verrou :

 Tp < (T1/ p ) + T∞ + O(#sync)

22

(23)

Surcoût pour réaliser l ’ ordonnancement

• Contrôle :

– création/placement/entrelacement des tâches

– gestion de la mémoire, mouvements de données

– préemptivité, réactivité

• Exemple : algorithme récursif d’exploration

– Ordonnancement glouton : théorique = OK

– Mais réalisation ???

• Nombre de tâches ~ T1 …

• Mémoire ~ 2h … en séquentiel ~ h h

23

(24)

Work-stealing

Distribuer les synchronisations

● 1 liste de taches prêtes par processeur :

 Lorsqu'un thread crée une tâche, il l'ajoute à sa liste locale.

● Lorsqu'un processeur est inactif :

 Si il n'y a plus de tache prête localement

• Choix d'un processeur victime

• Lui voler une tâche prête

● Choix : exemple [Cilk]

 Processeur victime : au hasard

 Accès à la liste des tâches prêtes : verrou arithmétique

24

(25)

Work-stealing

Minimiser le surcoût d'ordt

● => Minimiser le nombre de vols

● Programmes récursifs = graphe « série-parallèle »

 Principe : exécution localement d'abord

 => sur chaque proc. : les vols sont sur un chemin critique #vols < p.T∞

● Optimisation : création locale dégénérée en appel de fonction

 Exemple : produit itéré

25

(26)

Légende:

SMP : durée = f( seuil )

_ temps séquentiel

_ pour 1 processeur _ pour 2 processeurs

26

Ordonnancement SMP -Conclusion

● Théorique : si programme série-parallèle [Blumofe98]

Tp < (T1/ p ) + T∞ + p.T∞

● Pratique : contrôle automatique de granularité

 Exemple : arbre ~10⁶ tâches de grain 1

Sans dégénérescence séq ^[Ath-1]

Avec dégénérescence séq ^[Cilk]

× ×

Ath-1

Cilk

(27)

Cours 2. Algorithmes Parallèles sans communication

I. Introduction

III. Mise en oeuvre de l'ordonnancement

IV. Application: recherche arborescente Contrôle de l'espace mémoire

27 Machine UMA

Noeud SMP

(28)

Parallélisme et explosion mémoire

28

R. Blumofe C. Leiserson : « Space-efficient scheduling of multithreaded

computations » SIAM Journal of computing, vol 27, Fév. 1998 p. 207-229 G. Narlikar : « Space-efficient scheduling for parallel

multithreaded computations » thèse - www-2.cs.cmu.edu/~girija/publications.html F. Galilée : « Athapascan-1 : Interprétation distribuée du flot de donnée d'un

programme parallèle » Thèse www-id.imag.fr/~jlroch/perso.html/ps/

/2001-dea-algo-par/these-galilee_pages113-151.ps.gz

(29)

Un exemple

void explore( nœud n, …) { if … {

for (s =n.first(); s <n.last(); n++) {

dopar explore( s, …) ; }

}

h

T1 : temps séquentiel T∞ ^{= O(h)}

S1 ^{= O(h)}

Texec(p) ~ T1 /p Sexec(p) ~ S1^O(1)

tâche

???

29

(30)

Programme série-parallèle

● Work-stealing:

 Si inactif : tirage au hasard d'un proc victime Pv

 La tâche volée est la plus ancienne sur Pv

● Chaque processeur vole des tâches sur un

chemin critique : espace mémoire < S1 / proc _Sp < p._S1

● Exemple :

 Cilk : Joueur d'échecs Socrates

 Athapascan : Visualisateur Mandelbrot

30

(31)

Et la consommation mémoire ?

● Calcul récursif : Découpe en 4

découpes de l'image

découpes du calcul

affichage affichage

S1 = logn + un morceau d'image = 78 ko

allocations

31

(32)

S2 = 548ko S1 = 78ko

☹

arbitraire

p1p0

seq locseq glob

S2 = 143ko S1 = 78ko

Ordre d'exécution des tâches p = 2

S1 = logn + un morceau d'image = 78 ko

32

(33)

p1p0

arbitraire

S2 = 84ko S1 = 78ko

seq globseq loc S2 = 143ko☺

S1 = 78ko S2 = 548ko S1 = 78ko

☹ S1 = logn + un morceau d'image = 78 ko

Ordre d'exécution des tâches p = 2

33

(34)

0 100 200 300 400 500 600 700 800 900 1000

p=1 p=2 p=3 p=4

arbitraire LIFO O2 : seq. loc. O1 : seq. glob.

Consommation mémoire en fonction du nombre de processeurs

pS1

S1 ko

LIFO seq loc seq glob

arbitraire

34

(35)

Analyse théorique du coût mémoire

• O1 : « séquentiel global »

• O2 : « séquentiel local »

• Arbitraire ^[Threads]

 pour tout graphes [Narlikar2000]

 Ordre de référence suivit de manière globale

 Athapascan-1 : graphes dynamiques

Sp ≤ S1 + p.hOT∞

 pour graphes série-parallèle [Blumofe98]

 Ordre de référence suivi localement

 Parcours en profondeur

 Athapascan-1 : pour tout graphe [Géalilée 99]

Sp ≤ pS1

 Ordonnancement arbitraire des tâches _Sp≤ #T S1

35

(36)

Cours 2. Algorithmes Parallèles sans communication

36 Machine UMA

Noeud SMP

Conclusion

➢ Contrôler la granularité

➢ Limiter le surcoût dordonnancement

➢ Maîtriser l'espace mémoire requis