algorithmes parallèles auto-adaptatifs et applications daouda traorÉ directeurs de thèse...

Algorithmes parallèles auto-adaptatifs et applications

Daouda TRAORÉ

Directeurs de thèse

Jean-Louis ROCH & Denis TRYSTRAM

Projet MOAIS

Laboratoire d’Informatique de Grenoble (UMR 5217), France

Vendredi 19 Décembre 2008

Algorithmes parallèles auto-adaptatifs et applicationsDaouda Traoré

Motivations

Evolution des machines parallèles: de machines avec processeurs identiques vers:

Grilles de calcul => ressources hétérogènes et dynamiques

Systèmes multi-processus (Processeurs multi-cœurs, SMP, MPsoc) applications concurrentes sur une même unité => les cœurs apparaissent comme de vitesses variables

Processeurs graphiques : GPUs + CPUs => hétérogénéité, fréquences et opérations différentes

Questions: Est-ce qu’un algorithme parallèle peut fonctionner dans ce contexte? Avec quelles garanties de performance ? Sous quelles hypothèses?

2/52


Evolution de la programmation parallèle

Grille Multi-coeurs, SMP GPU

Google MapReduceOpenMP, Cilk++, intel TBB

Cuda

Athapascan/Kaapi

Initialement: processeurs identiques (MPI)

Aujourd’hui: Interfaces de haut-niveau permettant d’abstraire l’architecture.

3/52


Construction d’algorithmes parallèles adaptatifs

S’adaptent à la plate-forme d’exécution- Inconscients du nombre de processeurs (en anglais, processor oblivious)- Adaptation à la charge de la plate-forme

Avec des garanties d’efficacité- Temps d’exécution si possible optimal p/r aux ressources (dynamiquement) allouées

• Contexte: LIG / EP INRIA Moais:

Thème sur la conception d’algorithmes adaptatifs [Roch&al gzip2001, TSI2005,...]

Master ROCO D. Traoré 2005 : un algorithme de préfixe adaptatif (mais clairvoyant…)

4/52

Objectif de la thèse

Un algorithme auto-adaptatif est un algorithme qui est capable de changer automatiquement son comportement en fonction de son contexte d‘exécution (données manipulées, plate-forme d’exécution, occupation des processeurs, …).

Définition (algorithme auto-adaptatif)


1. Introduction [objectifs et contributions, organisation]

2. Programmation parallèle [notions]

3. Algorithmes parallèles adaptatifs[définitions]

4. Un algorithme adaptatif pour le calcul parallèle des préfixes [EUROPAR’06, CARI’06]

5. Algorithmes adaptatifs de tri parallèle [RENPAR’08]

6. Schéma générique des algorithmes parallèles adaptatifs [PDP’08, EUROPAR’08]

7. Application du schéma à la librairie standard STL [EUROPAR’08, MSAS’08]

8. Conclusion et perspectives

5/52

Plan du mémoire et contributions


Algorithmes pour processeurs identiques: illustration sur le calcul parallèle des préfixes

Ordonnancement par vol de travail

Schéma générique adaptatif

Algorithme adaptatif pour le calcul parallèle des Préfixes

Application du schéma à la STL

Conclusion et perspectives

6/52

Plan de la présentation



Calcul des préfixes

– Entrée : x0, x1, …, xn

– Sortie : ..., n avec

Applications : parallélisation de boucles, additions modulaires [Blelloch’89]

Algorithme séquentiel :

for(x[0], i=1; i <= n; i++) [i]=i-1]*x[i]; // n opérations

Borne inférieure sur p processeurs identiques :

Parallélisation optimale sur p processeurs identiques [Snir’86, Nicolau-Wang’96]

i

kii x

0

7/52

1

2

p

n[Fich’83]



s+1 s+1 s+2 s+2 s-p+1… …

q-1 blocsp-q+1 blocs

p+1 blocs

Un nouvel algorithme optimal pour le calcul des préfixes [chap. 3, pages 27-36]

- Soit s et q le quotient et le reste de la division de n+1 par p+1:

n+1 = s(p+1) + q

Division du tableau initial en p+1 blocs de taille éventuellement différentes

8/52



s+1 s+1 s+2 s+2… …

p-1 étapes

p-1 1

p-1 1

…

p-1 1

…

s+1-p s+1-p s+2-p s+2-p s+1-p

Algorithme statique en p+1 blocs

9/52

Algorithmes parallèles auto-adaptatifs et applicationsDaouda Traoré 10/52


Analyse théorique du temps d’exécution de l’algorithme proposé

et le nombre d’opérations vérifie :

Remarque : Une variante donne un temps toujours optimal, mais n’a pas été programmée

1

2

p

nTp

Si 0 ≤ q ≤ 1 et (p+3)/2 ≤ q ≤ p, alors le temps d’exécution de l’algorithme (optimal) sur p processeurs identiques vérifie

Théorème [chap. 3, page 30]

11

2

p

nTp

Si 2 ≤ q ≤ (p+3)/2, alors le temps d’exécution de l’algorithme à 1 de l’optimal sur p processeurs identiques vérifie

Théorème [chap. 3, pages 31 et 32]

1

2

p

npWp



0

0,02

0,04

0,06

0,08

0,1

0,12

0,14

n=100001 10000001

implantation "algoproposé"implantation "Nicolau-Wang"implantation"séquentielle"

11/52

1

1,2

1,4

1,6

1,8

2

2,2

2,4

2,6

n=21 n=141 n=261 n=381 n=421

implantation "algoproposé"implantation "Nicolau-Wang"borne inférieure

taille

tem

ps

accé

léra

tion

taille

Machine AMD Opteron

n petit, temps d’une opération assez élevé

n grand, temps d’une opération très petit (temps d’addition de deux Doubles par exemple).Dans l’algorithme de Nicolau-WangOn a 2n/(p+1) synchronisations

4 processeurs

1 processeur



Inconvénients de la parallélisation sur des processeurs identiques

Nombre d’opérations : toujours le même si les p processeurs initialement prévus pour l’exécution ne sont pas disponibles.

Exemple : si on suppose que Un seul processeur exécute l’algorithme parallèle Les autres étant mobilisés pour d’autres calculs

=> le nombre d’opérations effectuées par un seul processeur est

L’algorithme optimal sur processeurs identiques n’est pas performant Si les processeurs sont de vitesses différentes (temps d’exécution final = temps

d’exécution du processeur le plus lent) Si le temps de l’opération * est variable

12/52

1

2

p

np








13/52



Principe Suit le principe glouton : à tout instant où il existe une tâche prête non encore

ordonnancée, tous les processeurs sont actifs.

Algorithme distribué Chaque processeur gère localement une pile des tâches qu’il a rendues prêtes

(créées, ou débloquées).

tâches

P0 P1 P2

Lorsqu’un processeur devient inactif, il choisit (au hasard) un processeur dont la pile en cours d’exécution contient une tâche prête et lui vole une tâche (la plus ancienne, en haut de la pile (FIFO).

steal

14/52


[Blelloch’90, ], [Leiserson & Kuszmaul 2001]


Modèle de coût associé au vol de travail (1/2)

Notations• W = travail = le nombre d’opérations de l’algorithme parallèle sur 1

processeur

• Tp = la durée d’exécution de l’algorithme parallèle sur p processeurs

• D = la profondeur de l’algorithme parallèle (le nombre d’opérations sur le chemin critique)

• ave = la vitesse moyenne des p processeurs :

Théorème[Arora, Blumofe, Plaxton 02, Bender, Rabin 02]

Avec une grande probabilité; Le temps d’exécution Tp d’un programme utilisant l’ordonnancement par

vol de travail est majoré par :

Le nombre de vols (réussis ou échoués) est inférieure à O(p.D)

)(aveave

p

DO

p

WT

15/52

ave i(t)

i1

p

t1

T

T.p


Modèle de coût associé au vol de travail (2/2)

Efficacité de la parallélisation• Wseq = travail de l’ algorithme séquentiel• Tseq = temps d’exécution de l’algorithme séquentiel :

Intérêt : Si W ≈ Wseq et D très petit,

En général W ≥ c1Wseq, c1 mesure le surcoût dû à l’ordonnancement et au parallélisme. Surcoût de parallélisme

Gestion des tâches : tâches empilées dans une pile Exemple : algorithme récursif, Grain fin : surcoût arithmétique (récursivité)

Minimisation du surcoût d’ordonnancement Principe du travail d’abord[Frigo et al98, Roch01]

Ce principe consiste à minimiser le surcoût de création de tâches de l’ordonnancement par vol de travail.

Appels de création de tâches traduits en appel local de fonction séquentielle.

ave

seqseq

WT

16/52

p

TDO

p

WT seq

aveavep

)(


Cilk[ Frigo et al 98]

Création de tâches : spawn Synchronisation : sync Architectures cibles : mémoires partagées

Athapascan/Kaapi Athapascan [Roch et al, PACT 98] : interface applicative

Basé sur le graphe de flot de données Création de tâches : Fork Création de données : Shared Architectures cibles : mémoires partagées et distribuées Kaapi [Gautier et al 07] : moteur exécutif, qui supporte Athapascan

17/52

Bibliothèques implémentant le vol de travail

cilk A () { x = spawn C(); y = spawn B(); sync;return (x+y);}

A (Shared_w<int> res) { shared<int> x; shared<int> y;

Fork<C>()(x); Fork<B>()(y); Fork<M>()(x, y, res);}


Emulation séquentielle de l’algorithme parallèle Nombre d’opérations arithmétiques supérieur à celui de l’algorithme

séquentiel Exemple : Calcul des préfixes, optimal avec n opérations !

- Entrée : x0, x1, …, xn

- Sortie : ..., n avec

Un algorithme parallèle récursif (Diviser Pour Régner) :

18/52

Ordonnancement par vol de travail : limite

i

kii x

0

pref(n/2) pref(n/2)

final(n/2)

…

W(n) = 2W(n/2) + n/2 = (1/2) n*log(n) => l’émulation séquentielle de l’algorithme parallèle fait plus d’opérations que l’algorithme séquentiel optimal !








19/52



Ordonnancement par vol de travail: amélioration Principe de base [Roch&al TSI 2005]

Remplacer l’émulation séquentielle de l’algorithme parallèle par un « vrai » algorithme séquentiel plus efficace.

=>Utiliser le couplage de deux algorithmes : Un séquentiel: qui minimise le travail (nombre d’opérations) W Un parallèle: qui minimise la profondeur parallèle D

Points clefs: À tout instant, chaque processus actif exécute un algorithme

séquentiel, mais peut être volé par un processus inactif Un processus « suit » l’algorithme séquentiel (optimal)

20/52



Un processeur occupé a une tâche et l’exécute avec un algorithme séquentiel

T0.Run_seq()

21/52

Couplage adaptatif de deux algorithmes

Ps


Un processeur devient libre et exécute une opération d’extraction de travail chez un processeur actif sans l’interrompre.

Ps

Pv

21/52


steal

T0.Run_seq()


Un processeur devient libre et exécute une opération d’extraction de travail chez un processeur actif (victime) sans l’interrompre.

Ps

21/52


Pv

T0.Run_seq()

T’0.Run_seq()


La victime a fini sa tâche et préempte son voleur

Ps

21/52


Pv

T’0.Run_seq()

Prem

pts


La victime effectue un saut (jump) sur le travail déjà fait par le voleur, le voleur finalise éventuellement ses calculs grâce aux résultats de la victime.

Ps

21/52


Pv

jump

T’0.Finalize

T0.Run_seq()

gets

Ps


A la fois les processeurs victime et voleur peuvent modifier les informations sur le travail en cours de traitement Nécessité de se synchroniser ( pour la cohérence des données)

22/52

Couplage adaptatif : Amortissement des synchronisations (extraction séquentielle du travail)

work extract_seq() { lock(); //verrouiller ws = NextWorkSeq();

unlock(); //déverrouiller return ws;}

Côté victime

work extract_par() { //Micro-loop lock(); //verrouiller wv = WorkToSteal(); unlock(); //déverrouiller return wv;}

Côté voleur

Run_seq() { While((ws= extract_seq())≠Ø) { local_run(ws) // Nano-loop }}

Côté victime

- Si taille(ws) est petite => surcoût élévé.- Choix de taille (ws) : taille (ws) = profondeur (wrest); => travail arithmétique ≈ Wseq

Algorithmes parallèles auto-adaptatifs et applicationsDaouda Traoré 23/52

Couplage adaptatif : Amortissement des synchronisations (extraction séquentielle du travail)

0

0,2

0,4

0,6

0,8

1

1,2

1,4

1,00E+05

1,00E+06

1,00E+07

1,00E+08

1,00E+09

transformSTL

transformadapt

Exemple : transform STL : boucle avec n calculs indépendants

log(n1)

ni=l-fi

log(n2)

f1 lf2

taille

Tem

ps[

s]Machine utilisée :AMD Opteron Opteron 8752,2 Ghz,Compilateur gcc, option –O2


Schéma adaptatif : Amortissement du surcoût arithmétique

Pour Certains d’algorithmes: – Wseq n’est pas connu d’avance – W > Wseq

Exemple: algorithme find_if qui permet de trouver le premier élément d’une séquence vérifiant un predicat

P0 P1 P2 P3

position ou se trouve l’élément

Le temps final de l’algorithme parallèle est le temps final du processeur ayant terminé le dernier. Donc T4 = 6

Le temps séquentiel de l’algorithme est Tseq = 2

24/52


Pour s’adapter : division dynamique du travail global en des étapes (Macro-loop [Danjean, Gillard, Guelton, Roch, Roche, PASCO’07]),avec synchronisation après chaque pas schéma de type algorithme de Floyd

n_cur elts n_cur / log(n_cur)

25/52


Exemple : find_if

B1 B2 B3

P0, P1, P2 P0, P1, P2 P0, P1, P2


Exemple : find_if STL Comparaison avec find_if parallèle MPTL [Baertschiger 06]

26/52


Machine utilisée :AMD Opteron (16 cœurs);Données : doubles;Taille tableau : 106;Position élément : 105;

Temps STL : 3,60 s;Temps prédicat ≈ 36μ

Accélération inférieure à 1


Exemple : find_if STL Accélération par rapport au temps STL en fonction de la position où se

trouve l’élément

0

2

4

6

8

10

12

14

16

1 3 5 7 9 11 13 15

pos=100

pos=1000

pos=10000

pos=100000

pos=500000

pos=1000000

accélération idéale

Nombre de processeurs

accé

léra

tion

27/52


Machine utilisée :AMD Opteron (16 cœurs);Données : doubles;Taille tableau : 106;Temps prédicat ≈ 36μ


)log(1 2

seqseqp WDWp

T

Si le temps parallèle d’exécution d’un algorithme sur un nombre infini de processeurs fait (1+)Wseq opérations avec ≥ 0, alors avec une grande probabilité,


28/52

Schéma adaptatif : Analyse théorique

Trois niveaux de boucles utilisés dans l’algorithme du du schéma nano-loop => limite le surcoût de synchronisation micro-loop => permet le vol de travail et la préemption macro-loop => limite le surcoût arithmétique

Analyse de la complexité de l’algorithme du schéma


Suit le schéma de l’algorithme adaptatif Classes à instancier : WorkAdapt, JumpWork, FinalizeWork

Les fonctions à instancier :

Fonctions Spécifications

bool extract_seq() extrait une partie du travail local

bool extract_par() appelée lors du vol (extraction du parallélisme

void local_run() exécution séquentielle efficace

void join(const WorkAdapt stolenwork) fusionne les résultats

void jump(JumpWork* &) construit le travail à sauter

void after_jump(const JumpWork* ) donne les informations sur le travail sauté

bool extract_nexmacro_work() extrait la taille d’une macro-étape

bool get_finalize_work (FinalizeWork*&) donne le travail à finaliser

void get_main_result() retourne le résultat de la victime

void get_thieft_result() retourne le résultat du voleur

void must_jump() autorise le saut

29/52

Spécification et implantation du Schéma Interface C++ sur Kaapi


Pour construire un algorithme adaptatif, l’utilisateur remplit les fonctions nécessaires

Class MyWorkAdapt : public WorkAdapt {

…

bool extract_seq() { …. } bool extract_par() { …. } void local_run() {

} void join(const WorkAdapt stolenwork) { …. }

… }

Lancement du moteur adaptatif sur le travail construit

void MyalgoAdapt (… ) { MyWorkAdapt my_work = new MyWorkAdapt(….); adapt::run(my_work); }

30/52

Spécification et implantation du Schéma Interface C++ sur Kaapi


Implémentation « sans pile » du couplage séquentiel-parallèle Mais le parallélisme récursif sans surcoût peut rester géré par Kaapi avec sa pile

Gestion des vols: Remplacer la pile distribuée de tâches créées par une liste distribuée de tâches

volées Intérêt : peu de vols => peu de tâches insérées dans la liste; les surcoûts de

création sont aussi limités. Gestion lors de la préemption :

31/52

Spécification et implantation du schéma Gestion des vols

v1

v2

v3

v31

v12

v12

v11

w

(a) avant préemption de v1

(b) après préemption de v1

v2

v3

v12

v11

w

v31

v12








32/52



Algorithme adaptatif du calcul parallèle des préfixes (1/7)

Calcul des préfixes– Entrée : x0, x1, …, xn

– Sortie : ..., n avec

Algorithme séquentiel : for(x[0], i=1; i <= n; i++) [i]=i-1]*x[i]; // n opérations

Borne inférieure sur p processeurs identiques :

Parallélisation optimale sur p processeurs identiques [Snir’86, Nicolau-Wang’96]

Ne sont pas adaptés si le temps de l’opération * varie ou si les processeurs sont à vitesse variable

Parallélisation sur un nombre non borné de processeurs [Ladner-Fischer’80, Lin-Su’02]

Peuvent être émulés par vol de travail mais effectuent plus de 2n opérations

But : trouver un algorithme adaptatif qui se comporte optimalement [EUROPAR’2006, CARI’2006]

i

kii x

0

33/52

1

2

p

n[Fich’83]


a1 a2 a3

a4 a5 a6

a4 a5 a6

1ère étape de la macro-loop

a7 a8 a9

a10 a11 a12

a13

Ste

al r

equ

est

1 2 83 54 6 7

Ps

Pv

9

temps

Ps

Pvi=a4*…*ai

i=a0*…ai

i=a0*…ai

34/52



a1 a2 a3

a4 a5

a6

a7 a8 a9

a10 a11 a12

a13

preem

pt

1 2 84 6 7

Ps

Pv

3 5 9

Ps

Pvi=a4*…*ai

i=a0*…ai

i=a0*…ai


temps

34/52



a1 a2 a3

a4 a5

a6

a7 a8 a9

a10 a11 a12

a13

jump

2ème étape de lamacro-loop

a10 a11 a12

Ste

al r

equ

est

Ps

Pv

1 2 84 63 5 7

9

Ps

Pv

i=a10*…*ai

i=a0*…ai

i=a4*…*ai

i=a0*…ai


temps

34/52



a1 a2 a3

a4 a5

a6

a7 a8 a9

a13

jump

a10 a11 a12

preem

pt

Ps

Pv

1 2 84 63 5 7 9

Ps

Pv

i=a10*…*ai

i=a0*…ai

i=a0*…ai


temps


34/52



a1 a2 a3

a4 a5

a6

a7 a8 a9

a12 a13

jump

a10 a11

jump


Ps

Pv

1 2 84 63 5 7 9

Ps

Pv

i=a0*…ai

i=a10*…*ai

i=a0*…ai

T2 = 9 temps optimal = 9


temps


34/52



)(log)1(

2 3 np

nT

avep

Le temps Tp sur p processeurs du calcul n+1 préfixes par l’algorithme adaptatif vérifieAvec une grande probabilité :


35/52


Analyse théorique du temps d’exécution


Taille des données : n=3.105, temps d’une opération ≈ 1ms

0

0,5

1

1,5

2

2,5

3

3,5

4

4,5

1 2 3 4 5 6 7 8

accélérationoptimale

préfixeadaptatifac

célé

ratio

n


0

1

2

3

4

5

6

7

8

9

1 2 4 6 8 10 12 14 16

accélérationoptimale

préfixeadaptatif


36/52

Algorithme adaptatif du calcul parallèle des préfixes (4/7): validation expérimentale

Machine Itanium-2 (8 cœurs) Machine AMD Opteron (16 cœurs)


0,5

1

1,5

2

2,5

3

3,5

1 2 3 4 5 6 7 8

prefixestatique

prefixeadaptatif


Tem

ps

d’ex

écut

ion

0,4

0,6

0,8

1

1,2

1,4

1,6

1,8

1 2 3 4 5 6 7 8

prefixestatique

prefixeadaptatif

37/52


Taille des données : n= 108, temps d’une opération = addition de deux doubles

Machine Itanium-2 (8 cœurs) Machine AMD Opteron (16 cœurs)



Taille des données : n= 104, temps d’une opération ≈ 2ms

Tem

ps [s

]


38/52

Dix Machines de fréquences différentes AMD Opteron

0

5

10

15

20

25

30

35

40

45

1 2 3 4 10

théorique

temps minimum depréfixe adaptatiftemps moyen de préfixeadaptatiftemps maximum depréfixe adaptatiftemps moyen de préfixestatique (SWARM)

ave

seq

p

T

)1(

2

processeur fréquence

1 1760 Mhz

2 550 Mhz

3 1100 Mhz

4 1650 Mhz

5 660 Mhz

6 440 Mhz

7 1320 Mhz

8 880 Mhz

9 550 Mhz

10 1760 Mhz

[Simulateur CpuBurning /Cérin]


1

1,5

2

2,5

3

3,5

4

4,5

5

1 2 3 4 5 6 7 8

Accélérationthéoriqueoptimale

prefixeadaptatif endistribué


accé

léra

tion

39/52


Taille des données : n=5120000, temps d’une opération ≈ 1ms

8 Machines distribuées AMD Opteron [accès des données paginé via mmap]








40/52



Applications du schéma à la librairie standard C++

La librairie STL (Standard Template Library) : Fournit : conteneurs, algorithmes, itérateurs Avantage : généricité Parallélisation de la STL

PSTL (Parallel Standard Template Library) [Johnson et al 97] STAPL (Standard Adaptive Parallel Libary) [Thomas et al 88 ] MPTL (Multi-Processing Template Library) [Baertschiger 06 ] MCSTL (Multi-Core Standard Template Library) [Singler et al 07 ] Intel TBB (Thread Building Blocks) [Reinders 07] PaSTeL [Saule & Videau, RENPAR’08]

KASTL (Kaapi Adaptive Standard Template Library) Implémenté sur le noyau exécutif kaapi Basé le schéma adaptatif

41/52



Classe Algorithmes implémentés

Algorithmes sans fusion de résultats copy, copy_bacward, fill, fill_n, for_each, generate, generate_n, replace, replace_if, replace_copy, replace_copy_if, swap_ranges, transform

Algorithmes avec fusion de résultats count, count_if, accumulate, inner_product, partial_difference

Algorithmes avec terminaison anticipée find, find_if, find_end, find_first_of, adjacent_find, search_n

Algorithmes avec surcoûts de parallélisme

partial_sum, remove_copy_if, unique_copy

Algorithmes de partition et de tri merge, stable_sort, partition, sort

Classification des algorithmes de la STL

42/52



Algorithmes sans fusion de résultats Fonctions : extract_seq, extract_par, local_run (1)

Algorithmes avec fusion de résultats Fonctions : (1) et join, jump (2)

Algorithmes avec terminaison anticipée Fonctions : (2) et extract_nextmacro_work (3)

Algorithmes avec surcoûts de parallélisme Fonction et classe : (3) et la classe FinalizeWork

43/52


« Partition »: primitive de base dans un tri de type « quicksort »

Soit un tableau T[0..n], et un élément quelconque appelé pivot pris dans le

tableau. Le but de l’algorithme de partition est d’arriver à la situation suivante :1. T[i] < pivot pour i appartenant à [0..k[

2. T[i] >= pivot pour j appartenant à [k..n[

Exemple : soit T = [10, 5, 2, 8, 20, 6, 32, 3, 7 ] et pivot = 8;

T_partionné = [7,5,2,3,6, 20, 32, 8,10]

44/52

Applications du schéma à la librairie standard C++: partition


Tableau initial

P1

45/52

Applications du schéma à la librairie standard C++: partition adaptative


Initialement P1 commence le calcul

P1

45/52



P2 vol du travail chez P1

P1

P2 steal

45/52



P1 et P2 font la partition dans leurs intervalles respectifs

P1

P2

45/52




P1

P3steal

45/52



Les trois processeurs font la partition dans leurs intervalles respectifs

P1

P2

P3

45/52




P2

P4 steal

45/52



Les quatre processeurs font la partition dans leurs intervalles respectifs

P1

P2

P3

P4

45/52



P1 a fini sa partie droite et préempte P3

P1

P2

P3

P4

préemption

préemption

45/52




P1

P2

P4

45/52



Les processeurs continuent les calculs en parallèle

P1

P2

P4

45/52




P1

P2

P4

45/52


préemption

préemption



P1

P4

45/52




P1

P4

préemption

préemption

45/52



P1 a fini sa partie droite

P1

45/52



Réarrangement des blocs non terminés

P1

Tous les éléments qui sont dans cette partie sont supérieurs au pivot

Réarrangement des blocs mal placés

45/52



Réarrangement des blocs non terminés

P1

Tous les éléments qui sont dans cette partie sont supérieurs au pivot

Tous les éléments qui sont dans cette partie sont inférieurs au pivot

Appel à partition adaptive sur ce intervalle

45/52

Applications du schéma à la librairie standard C++ : partition adaptative


sort

2

6

10

14

18

22

1 3 5 7 9 11 13 15

sort STL

sort adaptatif

sort TBB

Tem

ps [s

]

46/52

Applications du schéma à la librairie standard C++ : validations expérimentales


Machine : Opteron (16 cœurs )

Données : Doubles

Taille : 108


unique_copy : supprime dans une séquence des éléments contigus égaux Exemple :

0,1

0,3

0,5

0,7

1 3 5 7 9 11 13 15

unique_copy adaptatif

unique_copy de MCSTL

Tem

ps [s

]


47/52

Applications du schéma à la librairie standard C++ : validation expérimentales

=>1 1 2 3 0 0 10 15 15 15

10

1 2 3 0 10 15

6


Données : Doubles

Taille : 108


partial_sum : identique au calcul des préfixes

5

10

15

20

25

30

35

40

45

50

1 3 5 7 9 11 13 15

partial_sum adaptatif

partial_sum de TBB(grain adaptatif)

partial_sum de TBB(grain=100)partial_sum de TBB(grain=1875)

Tem

ps [s

]


48/52

Applications du schéma à la librairie standard C++ : validation expérimentales


Données : Doubles

Taille : 3.105

2n/p

2n/(p+1)


merge

0

1

2

3

4

5

6

1,E+05 1,E+06 1,E+07 1,E+08

Merge adaptatif

Merge MCSTL

Merge STL

accé

léra

tion

49/52

Applications du schéma à la librairie standard C++ : validations expérimentales

taille


Données : Doubles

8 processeurs








50/52



Conclusion

Spécification d’un schéma générique qui permet de développer des programmes parallèles adaptatifs Garanties théoriques prouvées Interface C++ sur Kaapi développée

Validation expérimentales sur plusieurs exemples Calcul parallèle des préfixes Fusion de listes triées, partition, tri par fusion et tri introspectif Algorithmes de la STL : unique_copy, remove_copy_if, transform,

accumulate, …. Bonnes performances expérimentales obtenues par rapport à

d’autres algorithmes implantés dans d’autres librairies (MCSTL, TBB, SWARM)

51/52


Perspectives

Optimisation de l’interface développée Supprimer les verrous : important pour un travail de petite taille Expérimenter et améliorer en contexte distribué (calcul automatique des seuils)

Implémenter le schéma sur d’autres bibliothèques Comme : Cilk, Cilk++, intel Tbb Comparer les performances

Avoir des algorithmes caches et processeurs inconscients (vrai pour plusieurs algorithmes (préfixe, partition, …), mais reste sort adaptatif?)

Utilisation pour des applications de simulations 3D (SOFA, Everton) -> ressources hétérogènes: CPU/GPU [Soares et al 07]

52/52

algorithmes parallèles auto-adaptatifs et applications daouda traorÉ directeurs de thèse...

Documents

calcul parallle

algorithme autoadaptatif

machines parallles

prfixes calcul

lalgorithme parallle

mmoire et contributions

stl conclusion et perspectives

processeurs en anglais