Motivation (1/2) Parallélisme et granularité

(1)

Motivation (1/2)

Parallélisme et granularité

Granularité « pratique » : gros grain

Découpe en p = #ressources disponibles

Inconvénient : architecture hétérogène, dynamique

Granularité « théorique » : grain fin

Parallélisme maximal avec #ops ~ tps séquentiel

Inconvénient : surcoût d’ordonnancement sur l’architecture

Quel grain pour limiter le surcoût de la parallélisation ?

a b

H(a) O(b,7)

F(2,a) G(a,b) H(b)

Degré de parallélisme

arbitraire

(2)

• Exemple : calcul des préfixes P

_i

= *

_k=0

a

_i

^(i=0..n)

• Algorithme séquentiel :

for (i= 0 ; i <= n; i++ ) P[ i ] = P[ i – 1 ] * a [ i ] ; #ops * = n

• Algorithme parallèle :

Motivation (2/2) Algorithmique

i

(3)

• Exemple : calcul des préfixes P

_i

= *

_k=0

a

_i

^(i=0..n)

• Algorithme séquentiel :

• Algorithme parallèle :

Motivation (2/2) Algorithmique

i

a₀ a₁ a₂ a₃ a_n

* * *

a_n-1

(4)

• Exemple : calcul des préfixes P

_i

= *

_k=0

a

_i

^(i=0..n)

• Algorithme séquentiel :

• Algorithme parallèle :

Motivation (2/2) Algorithmique

i

* * *

a_n-1

Préfixe ( n / 2 )

(5)

• Exemple : calcul des préfixes P

_i

= *

_k=0

a

_i

^(i=0..n)

• Algorithme séquentiel :

• Algorithme parallèle :

Motivation (2/2) Algorithmique

i

* * *

a_n-1

Préfixe ( n / 2 )

P₀ P₂ P_n-1

(6)

• Exemple : calcul des préfixes P

_i

= *

_k=0

a

_i

^(i=0..n)

• Algorithme séquentiel :

• Algorithme parallèle :

Motivation (2/2) Algorithmique

i

* * *

a_n-1

Préfixe ( n / 2 )

P₀ P₂ P_n-1

* P₃

* P₁

* P_n

(7)

• Exemple : calcul des préfixes P

_i

= *

_k=0

a

_i

^(i=0..n)

• Algorithme séquentiel :

• Algorithme parallèle :

dopar (i= 0 ; i <= n; i+=2 ) b[ i ] = a[ 2.i ] * a [ 2.i+1 ] ; PrefixePar( b[ 0 .. n/2], P[1, 3, 5, .., n-1] ) ; dopar (i= 1 ; i <= n/2; i++ ) P[ 2.i ] = P[2i-1] * a [ 2.i ] ;

=> #T_∞ = tps parallèle = 2. log n mais #ops * = 2.n

• Parallèle => surcoût en nbre d’opérations

[Ladner-Fischer]

Motivation (2/2) Algorithmique

i

(8)

Plan de la présentation

• 1. Découpe récursive et ordonnancement work-stealing

• 2. Parallélisation à grain adaptatif:

• couplage algorithme séquentiel et algorithme parallèle

• 3. Application à la parallélisation de gzip

(9)

1. Parallélisme par découpe récursive

exemple: Produit itéré, arborescence critique Branch&Bound, …

void ProdIter ( node x, …) { if (grain(x) < …) eval_seq(x) else {

for s ∈ fils(x) dopar compute( s, …) ;

} }

h

Notations :

T

_s

= temps séquentiel T

₁

= travail parallèle T

_∞= temps parallèle

Sur p processeurs [Brent]

T

_exec(p)

~ T

₁

/p + T

_∞ + surcoût //

task

(10)

Implantation : ordo. par vol de travail (1/2)

• Ordonnancement par vol de travail

^[Graham]

:

• Graphe de tâches avec parallélisme dynamique

• Nombre de vols < p. T_∞=> T_p= T_1/p + T_∞ + O(p.T_∞)

• Intérêt de la découpe récursive si T_∞ petit

• Optimisation à l’exécution :

work-first principle

[Multilisp, Cilk, …]

⇒ dégénération séquentielle de l’algorithme parallèle pour éviter le surcoût de gestion de tâches parallèles inutiles

(11)

Implantation : ordo. par vol de travail (2/2)

f1() { ….

fork 2 ; … }

+ Exécution non-préemptive d’une tâche prête Hypothèse : ordo. séquentiel de l’algorithme parallèle valide

Pile

(12)

Implantation : ordo. par vol de travail (2/2)

f1() { ….

fork 2 ; … }

Pile

f1

P

Pile

(13)

Implantation : ordo. par vol de travail (2/2)

f1() { ….

fork 2 ; … }

Pile

f1

P

Pile

fork f2

(14)

Implantation : ordo. par vol de travail (2/2)

f1() { ….

fork 2 ; … }

Pile

f1

P

Pile

fork f2

f2

(15)

Implantation : ordo. par vol de travail (2/2)

f1() { ….

fork 2 ; … }

Pile

f1

P

Pile

fork f2

f2

(16)

Implantation : ordo. par vol de travail (2/2)

f1() { ….

fork 2 ; … }

Pile

f1

P

Pile

fork f2

f2

P’

(17)

Implantation : ordo. par vol de travail (2/2)

f1() { ….

fork 2 ; … }

Pile

f1

P

Pile

fork f2

f2

P’

vol

(18)

Implantation : ordo. par vol de travail (2/2)

f1() { ….

fork 2 ; … }

Pile

f1

P

Pile

fork f2

f2

P’

vol

(19)

Implantation : ordo. par vol de travail (2/2)

f1() { ….

fork 2 ; … }

Pile

f1

P

Pile

fork f2

f2

P’

vol

f1

(20)

Implantation : ordo. par vol de travail (2/2)

f1() { ….

fork 2 ; … }

Pile

f1

P

Pile

fork f2

f2

P’

vol

f1

• Intérêt : Grain fin « statique », mais contrôle dynamique

• Inconvénient: surcôut possible de l’algorithme parallèle

[ex. préfixes]

(21)

Expérimentations : knary

SMP Origin 3800

Cilk / Athapascan

iCluster

Athapascan

59,2 64

90,1 100

30,9 32

15,6 16

7,83 8

Speed-Up

#procs

T_s= 2397 s - T₁ = 2435

(22)

2. Parallélisation à grain adaptatif

• Principe : si un processeur devient inactif,

=> extraction de parallélisme sur un processeur en train d ’exécuter un algorithme séquentiel

• Hypothèses : deux algorithmes :

• 1 algo. séquentiel : SeqCompute

• 1 algo. parallèle : LastPartComputation => à tout moment, possibilité d’extraire du parallélisme du travail restant à faire dans l’algo. séquentiel.

• Après extraction : le travail extrait peut être réalisé par l’algo.séquentiel.

(23)

2. Parallélisation à grain adaptatif

SeqCompute

(24)

2. Parallélisation à grain adaptatif

SeqCompute

Extract_par LastPartComputation

(25)

2. Parallélisation à grain adaptatif

SeqCompute

(26)

2. Parallélisation à grain adaptatif

SeqCompute

(27)

2. Parallélisation à grain adaptatif

SeqCompute

Extract_par LastPartComputationSeqCompute

(28)

Algorithme générique à grain adaptatif

• Programmation : suppose un ordo. des tâches par vol de travail :

• LastPartComputation( work ) {

wpar = Extract_par( work ) ; // work est modifié fork SeqCompute ( wpar ) ;

fork LastPartComputation ( wpar ) ; fork LastPartComputation ( work ) ;

}

• Sémantique séquentielle :

• LastPartComputation n’est lancée que si un processeur est inactif

• Sinon, LastPartComputation est exécutée avec wpar = Vide

(29)

(30)

E.g. Calcul parallèle f(i), i=1..100 LastPart(w)

W=2..100

SeqComp(w) sur CPU=A

f(1)

(31)

E.g. Calcul parallèle f(i), i=1..100 LastPart(w)

W=3..100

SeqComp(w) sur CPU=A

f(1); f(2)

(32)

E.g. Calcul parallèle f(i), i=1..100 LastPart(w)

on CPU=B

W=3..100

SeqComp(w) sur CPU=A

f(1); f(2)

(33)

E.g. Calcul parallèle f(i), i=1..100

SeqComp(w) sur CPU=A

f(1); f(2) LastPart(w)

on CPU=B

W=3.. 51

SeqComp(w’) LastPart(w’)

W’=53..100

LastPart(w)

(34)

E.g. Calcul parallèle f(i), i=1..100

SeqComp(w) sur CPU=A

f(1); f(2) W=3.. 51

SeqComp(w’) LastPart(w’)

W’=53..100

LastPart(w)

(35)

E.g. Calcul parallèle f(i), i=1..100

SeqComp(w) sur CPU=A

f(1); f(2) W=3.. 52

SeqComp(w’) sur CPU=B

f(53)

LastPart(w’)

W’=54..100

LastPart(w)

(36)

3. Application : parallélisation de gzip

• Gzip :

• Utilisé (web) et coûteux bien que de complexité linéaire

• Code source :10000 lignes C, structures de données complexes

• Principe : LZ77 + arbre Huffman

• Pourquoi gzip ?

• Problème P-complet, mais parallélisation pratique possible

• Inconvénient: toute parallélisation (connue) entraîne un surcoût

(37)

Fichier

compressé Fichier en entrée

Compression à la volée

Algorithme

Comment paralléliser gzip ?

(38)

Fichier

Algorithme

Comment paralléliser gzip ?

Partition dynamique en blocs

(39)

Fichier

Algorithme

Comment paralléliser gzip ?

Blocs

compressés Compression

parallèle

Partition statique en blocs

Parallélisation

=>

(40)

Fichier

Algorithme

Comment paralléliser gzip ?

Blocs

compressés Compression

parallèle

Partition statique en blocs

Parallélisation

=>

ü Parallélisation « facile » ,100% compatible avec gzip/gunzip

ü Problèmes : perte de taux de compression, grain par robuste, surcoût

(41)

Output

compressed file

Input File

SeqComp LastPartComputation

Parallélisation gzip à grain adaptatif

(42)

Output

Input File

SeqComp LastPartComputation

Parallélisation gzip à grain adaptatif

Dynamic partition in blocks

(43)

Output

Input File

SeqComp LastPartComputation

Parallélisation gzip à grain adaptatif

(44)

Output

Input File

SeqComp LastPartComputation

Parallélisation gzip à grain adaptatif

Output

compressed blocks

Parallel compression

(45)

Output

Input File

SeqComp LastPartComputation

Parallélisation gzip à grain adaptatif

Output

compressed blocks

Parallel compression

cat

(46)

Conclusion Grain adaptatif

Couplage de 2 algos : 1 séquentiel, 1 parallèle “récursif”

Génération de parallélisme que sur inactivité de ressources Opérateur de base : ExtractPar de travail séquentiel en cours Programmation générique, originale ... et simple !

Intérêt

Réduction du surcoût lié au parallélisme : - création de tâche, ordonnancement

- surcoût arithmétique intrinsèque

- Gain pratique: code PL inférence probabiliste [Mazer, SHARP]

Perpsectives

- Expérimentations SMP et distribuées : gzip, préfixes, ....

- Extension au cas distribué et hétérogène : ajout/résilience - Extensions à d’autres algorithmes: Gauss, B&B, ...

(47)