Parall´lisation & mod`les                                   e              e                                de programmati...
1 PRODUIT MATRICIEL                                                                            21         Produit matricie...
´2 DECOUPAGE D’UN TABLEAU BINAIRE                                                             31.2.2       Le produit   En...
´2 DECOUPAGE D’UN TABLEAU BINAIRE                                                                42.2       Solution    No...
3 DESIGN                                                                                                    53     Design ...
4 MESURE DE PERFORMANCE                                                                           64         Mesure de per...
4 MESURE DE PERFORMANCE                                                                           7          Donn´es : P ∈...
4 MESURE DE PERFORMANCE                                                                         8        Donn´es : p, P, p...
4 MESURE DE PERFORMANCE                                                                                                   ...
5 CONCLUSION                                                                                                              ...
5 CONCLUSION                                                                                                              ...
5 CONCLUSION                                                                                                              ...
5 CONCLUSION                                                                                                              ...
Prochain SlideShare
Chargement dans…5
×

PMP Report

876 vues

Publié le

I did a report in "parallélisation & modèles de programmation" during my MSc in HPC, here is the source.

Publié dans : Formation
0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
876
Sur SlideShare
0
Issues des intégrations
0
Intégrations
23
Actions
Partages
0
Téléchargements
27
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

PMP Report

  1. 1. Parall´lisation & mod`les e e de programmation Caner Candan M2 MIHP 6 mars 2011Table des mati`res e1 Produit matriciel 2 ´ 1.1 Enonc´ . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.2 Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.2.1 La diffusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.2.2 Le produit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.2.3 L’impl´mentation e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 D´coupage d’un tableau binaire e 3 ´ 2.1 Enonc´ . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.2 Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2.1 D´terminer l’index . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2.2 Cr´er le tableau binaire e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2.3 Impl´mentation . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Design 5 3.1 Diagramme de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 3.2 Surcharge d’op´rateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e 54 Mesure de performance 6 4.1 Pr´ambule . . . . . . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . 6 4.2 Identifier les ressources les plus utilis´es e . . . . . . . . . . . . . . . . . . . . . . . 6 4.3 Pseudo-code de la fonction apply . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 4.4 La fonction en parall`le . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . 6 4.5 Speed-up . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 4.6 Mesures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 4.6.1 Fonctions objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 4.6.2 Benchmark . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 4.6.3 Dynamicit´ . . . . . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . 9 4.6.4 R´sultats en O(1) . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . 9 4.6.5 R´sultats en O(n) . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . 105 Conclusion 10 1
  2. 2. 1 PRODUIT MATRICIEL 21 Produit matriciel1.1 ´ Enonc´ e Matrice : D´crire un algorithme PRAM pour le mod`le EREW qui utilise O(n3 ) processeurs e epour multiplier deux matrices de taille n ∗ n. 11.2 Solution Une solution consisterait ` diffuser dans un premier temps toutes les donn´es des matrices ` a e amultiplier ` chaque processus puis de faire le produit des matrices en prenant le soin que chaque aprocessus utilise les donn´es qui leur est propre. e1.2.1 La diffusion En respectant le mod`le EREW, les matrices A et B ∈ Kn∗n sont copi´es, dans un premier e etemps, n fois dans les cubes A et B ∈ Kn∗n∗n . Ceci permet de r´server une dimension du cube ea` un processus et ´viter toute lecture concurrente. e L’algorithme 1 pr´sente le pseudo-code de la fonction de diffusion qui prend comme donn´e e een entr´e une matrice M ∈ Kn∗n et retourne un cube M ∈ Kn∗n∗n . Elle est exprim´e en e e2 ´tapes. La premi`re consiste ` affecter, en utilisant O(n2 ) processeurs, chaque point de la e e amatrice dans la premi`re dimension du cube. La deuxi`me ´tape effectue la copie en diffusion 2 e e ede chaque point de la matrice situ´ ` la premi`re dimension du cube vers les autres dimensions ea edu cube en utilisant O(log n) processeurs et pour une matrice enti`re en O(n2 ∗ log n). e Donn´es : M ∈ Kn∗n , n ∈ N e R´sultat : M ∈ Kn∗n∗n e 1 d´but e 2 parall`le e 3 pour i ← 0 ` n faire a 4 parall`le e 5 pour j ← 0 ` n faire a 6 m (0, i, j) ← m(i, j) 7 parall`le e 8 pour s ← 0 ` log2 n faire a 9 parall`le e 10 pour h ← 0 ` s2 faire a 11 parall`le e 12 pour i ← 0 ` n faire a 13 parall`le e 14 pour j ← 0 ` n faire a 15 m (2s + h, i, j) ← m (h, i, j) 16 fin Algorithme 1 : Copie de matrice en diffusion n 1. cij = k=0 aik bkj : http://fr.wikipedia.org/wiki/Produit_matriciel 2. Hot potato routing : http://en.wikipedia.org/wiki/Hot_potato_routing
  3. 3. ´2 DECOUPAGE D’UN TABLEAU BINAIRE 31.2.2 Le produit En appliquant le mod`le EREW, le produit matriciel prend en param`tre les cubes A et e eB ∈ Kn∗n∗n tel que chaque processus utilise sa dimension de cube respective pour lire lesdonn´es de aij et bij . e L’algorithme 2 pr´sente le pseudo-code de la fonction de produit matriciel qui prend comme edonn´e en entr´e les cubes A et B ∈ Kn∗n∗n et retourne une matrice C ∈ Kn∗n . L’affectation e edes valeurs dans la matrice C se fait en O(n2 ) et le produit de cij se fait en O(n). Donn´es : A, B ∈ Kn∗n∗n , n ∈ N e R´sultat : C ∈ Kn∗n e 1 d´but e 2 parall`le e 3 pour i ← 0 ` n faire a 4 parall`le e 5 pour j ← 0 ` n faire a 6 c(i, j) ← n a(p, i, k) ∗ b(p, k, j) k=0 7 fin Algorithme 2 : Produit matriciel1.2.3 L’impl´mentation e Apr`s avoir d´crit la fonction de diffusion et le produit matriciel respectant tous deux le e emod`le EREW, nous allons voir l’implementation d’un produit de deux matrices A et B ∈ Kn∗n eproduisant une troisi`me matrice C ∈ Kn∗n . e L’algorithme 3 d´crit l’impl´mentation. e e Donn´es : A, B ∈ Kn∗n , n ∈ N e R´sultat : C ∈ Kn∗n e 1 d´but e 2 A ← dif f usion(A, n) 3 B ← dif f usion(B, n) 4 C ← produit(A , B ) 5 fin Algorithme 3 : Impl´mentation du produit matriciel e2 D´coupage d’un tableau binaire e2.1 ´ Enonc´ e D´coupage d’un tableau : Soit A un tableau de longueur n dont les ´l´ments sont soit des e ee0 soit des 1. Concevez un algorithme EREW de complexit´ O(log n) utilisant O(n) processeurs epour ranger tous les ´l´ments 1 ` la droite du tableau tout en maintenant leur ordre relatif ee a(propri´t´ de stabilit´ des ´l´ments). ee e ee Hint : effectuer un calcul de pr´fixe pour d´terminer quel devrait ˆtre la position de chaque e e e´l´ment.ee
  4. 4. ´2 DECOUPAGE D’UN TABLEAU BINAIRE 42.2 Solution Notre tableau ´tant binaire, contenant que des 0 et 1, il devient facile de compter le nombre ede 1 en sommant toutes les valeurs du tableau pour ensuite d´terminer ` quel index placer les e a0 et 1. Toute fois pour respecter l’´nonc´ et avoir une complexit´ en O(log n), nous allons devoir e e eutiliser la fonction calculant la somme des pr´fixes. e2.2.1 D´terminer l’index e L’algorithme 4 permet de d´terminer l’index qui constituera la fronti`re entre les 0 et 1 dans e ele tableau. Pour cela il prend en param`tre le tableau binaire B ∈ Kn ainsi que la taille du etableau n ∈ N . Donn´es : B ∈ Kn , n ∈ N e R´sultat : i ∈ N e 1 d´but e 2 i ← n − calcul somme pref ixe(B) 3 fin Algorithme 4 : Trouver l’index2.2.2 Cr´er le tableau binaire e L’algorithme 5 prend en param`tre l’index et la taille et cr´e un tableau binaire tri´ en e e efonction de l’index, 0 ` gauche et 1 ` droite. a a Donn´es : i, n ∈ N e R´sultat : B ∈ Kn e 1 d´but e 2 parall`le e 3 pour j ← 0 ` i faire a 4 B (i) ← 0 5 parall`le e 6 pour j ← i ` n faire a 7 B (i) ← 1 8 fin Algorithme 5 : Cr´ation du tableau binaire tri´ e e2.2.3 Impl´mentation e L’algorithme 6 illustre la solution. Donn´es : B ∈ Kn e R´sultat : B ∈ Kn e 1 d´but e 2 i ← trouver index(B) 3 B ← creer tableau binaire(i) 4 fin Algorithme 6 : D´coupage d’un tableau binaire e
  5. 5. 3 DESIGN 53 Design Tous les exercices ont ´t´ d´velopp´s en C++ en utilisant le paradigme de programmation ee e eobjet et le design qui suit a ´t´ ´labor´ pour regrouper les diff´rents composants de calculs. ee e e eN´anmoins une recherche a ´t´ effectu´ pour d´terminer les limites de OpenMP et C++. Il e ee e esemblerait que les conteneurs fournit par la STL 3 ne soient pas threadsafe 4 . Une ´tude 5 donne eune liste non-exhaustive des pr´cautions ` prendre lors de l’utilisation de OpenMP en C++. e aCependant la version OpenMP 3.0 apporte des concepts nouveaux permettant l’utilisation no-tamment des iterateurs. On peut ainsi, par exemple, s’affranchir de simple indexeur de tableauet ´tendre la parall´lisation sur des listes chaˆ ees. e e ın´3.1 Diagramme de classes Figure 1 – Diagramme de classes Deux grandes familles d’op´ration coexistent. Elles sont pr´sent´es en figure 1. Les op´rations e e e ede calcul ` param`tre unique “OMPComputeUnary” et celles ` deux param`tres “OMPCompu- a e a eteBinary”. Tous deux renvoient un r´sultat. Elles sont pr´fix´es de “OMP” pour OpenMP 6 . Le e e ecalcul de somme des pr´fixes prenant un seul param`tre en entr´e “OMPVector” et renvoyant e e eun “Atom”, cette classe se situe dans la famille “OMPComputeUnary”. Le produit matriciel sesitue, quant ` lui, dans la famille “OMPComputeBinary”, cette classe prend deux param`tres a e“OMPMatrix” et retourne le mˆme type. On peut imaginer d’autres op´rations comme, par e eexemple, un produit vectoriel.3.2 Surcharge d’op´rateur e Compte tenu des possibilit´s offertes par le langage C++, comme la surcharge des op´rateurs, e el’op´rateur ∗ se voit ainsi surcharg´ dans la classe “OMPMatrix” afin d’appeler implicitement e ela classe “OMPMatrixProduct” pour le calcul du produit matriciel. Ainsi en ´crivant le code eC = A ∗ B ceci revient ` ´crire C = OM P M atrixP roduct()(A, B). ae 3. Standard Template Library : http://www.sgi.com/tech/stl/ 4. On dit qu’un programme ou qu’une portion de code est thread-safe s’il fonctionne correctement durant uneex´cution simultan´e par plusieurs threads (processus l´gers). http://fr.wikipedia.org/wiki/Threadsafe e e e 5. C++ and OpenMP : http://www.compunity.org/events/pastevents/parco07/parco_cpp_openmp.pdf 6. Open Multi-Processing : http ://openmp.org/
  6. 6. 4 MESURE DE PERFORMANCE 64 Mesure de performance Je profite de ce rapport pour parler d’un travail qui m’a ´t´ demand´ en entreprise. Nous uti- ee elisons le framework EO 7 pour d´velopper nos algorithmes ´volutionnaires 8 . Le sujet consistait e ea` impl´menter, au framework EO, un parall´lisme ` m´moire partag´e en utilisant OpenMP. e e a e e4.1 Pr´ambule e Avant de commencer il est important de pr´ciser que les EA 9 travaillent sur une population ed’individu aussi appel´ ´chantillon. Un individu ´tant repr´sent´ par un point dans l’´chantillon, ee e e e ela complexit´ d’un probl`me est d´finit par le nombre de dimensions pour chaque individu. e e e Le probl`me est repr´sent´ par la fonction objectif qui prend en param`tre un individu (un e e e epoint dans l’´chantillon) et ´value toutes ses dimensions pour en d´duire la qualit´ 10 . La qualit´ e e e e eest le crit`re de comparaison d’un point dans son ´chantillon. e e4.2 Identifier les ressources les plus utilis´es e Un test de profiling a ´t´ ex´cut´ afin d’identifier les ressources les plus utilis´es dans le ee e e eframework EO. Le test nous a permit d’identifier une fonction qui est utilis´e par une grande emajorit´ des op´rateurs 11 EO. Il s’agit de la fonction “apply”. Elle prend en param`tres une e e epopulation d’individu et un op´rateur. Cette fonction va it´rer sur tous les individus de la e epopulation et appliquer l’op´rateur. Il peut ˆtre int´ressant d’optimiser cette fonction. Nous e e eallons nous limiter ` transformer le code s´quentiel en parall`le. a e e4.3 Pseudo-code de la fonction apply L’algorithme 7 prend en param`tre une population ainsi qu’un op´rateur ` appliquer ` e e a achaque individu. Donn´es : P ∈ Kn , F ∈ Operateur e R´sultat : B ∈ Kn e 1 d´but e 2 pour i ← 0 ` n faire a 3 F (P (i)) 4 fin Algorithme 7 : La fonction apply4.4 La fonction en parall`le e L’algorithme 8 transforme la fonction “apply” en parall`le en utilisant le mod`le PRAM e eCREW 12 et O(n) processeurs pour parcourir tous les individus de la population. 7. Evolving Object, http://eodev.sf.net 8. Algorithme ´volutionnaire : http://fr.wikipedia.org/wiki/Algorithme_evolutionnaire e 9. Algorithmes ´volutionnaires e 10. Fitness en anglais 11. Op´rateurs de s´lection et variation e e 12. Concurantial Read Exclusive Write
  7. 7. 4 MESURE DE PERFORMANCE 7 Donn´es : P ∈ Kn , F ∈ Operateur e R´sultat : B ∈ Kn e 1 d´but e 2 parall`le e 3 pour i ← 0 ` n faire a 4 F (P (i)) 5 fin Algorithme 8 : La fonction omp apply4.5 Speed-up Apr`s avoir cr´e la fonction alternative employant le parall´lisme ` m´moire partag´e, appel´ e e e a e e e“omp apply”, nous allons ´tudier une solution de mesure du speed-up 13 . e L’´quation, en figure 2, pr´sente une m´thode de mesure du speed-up et est impl´ment´e e e e e edans l’algorithme 9. P,D M esure du Speedup = r Spkl k=0,l=0 Figure 2 – Mesure du Speedup Une description des param`tres est disponible dans la figure 3. e Param`tres e Description p la taille minimum de la population popStep le pas d’iteration de la population P la taille maximum de la population d la taille minimum de la dimension dimStep le pas d’iteration de la dimension D la taille maximum de la dimension r le nombre d’ex´cution pour chaque com- e binaison de p et d Figure 3 – Description des param`tres utilis´s e e4.6 Mesures En prenant en compte les param`tres d´crits pr´c´demment, nous allons lancer les tests sur e e e edeux architectures mat´rielles diff´rentes pr´sent´ en figure 4. e e e e Pour visualiser l’´volution du speed-up, nous utilisons un outil de g´n´ration de graphiques 15 , e e eavec les donn´es produits par les tests. e T∗ 13. Sp = T1 : http://en.wikipedia.org/wiki/Speedup p 15. Utilisation de matplotlib en python pour g´n´rer des boites a moustache e e `
  8. 8. 4 MESURE DE PERFORMANCE 8 Donn´es : p, P, popStep, d, D, dimStep, r ∈ N e 1 d´but e 2 pour k ← p ` P faire a 3 pour l ← d ` D faire a 4 pour m ← 0 ` r faire a 5 Ts ← 0 6 Tp ← 0 7 d´but e 8 t1 ← omp get wtime() 9 ... code sequentiel avec k et l ex´cut´ m fois ... e e 10 apply( ... ) 11 t2 ← omp get wtime() 12 Ts ← t2 − t1 13 fin 14 d´but e 15 t1 ← omp get wtime() 16 ... code parall`le avec k et l ex´cut´ m fois ... e e e 17 omp apply( ... ) 18 t2 ← omp get wtime() 19 Tp ← t2 − t1 20 fin Ts 21 ... on conserve le speed-up Tp pour k et l ... 22 fin Algorithme 9 : La fonction de mesure du speedup Processeur Nombre de coeurs Fr´quence e Cache L1 Intel Centrino vPro 2 2.40GHz 3072KB Intel Core i7 8 (hyperthreading 14 ) 2.67GHz 8192KB Figure 4 – Architectures mat´rielles e4.6.1 Fonctions objectifs Il est important de simuler toutes les compl´xit´s de probl`mes que l’on peut ˆtre amen´ e e e e ea e` r´soudre. Pour nos tests, le choix a ´t´ orient´ vers deux fonctions objectifs de complexit´ ee e ediff´rente pr´sent´ en figure 5. e e e Fonction objectifs Complexit´ en temps e Algorithme La fonction Sphere O(1) Sphere = n individuk k=0 Probl`me ` temps variable quelconque e a O(n) usleep(U (0, 1) ∗ 10) Figure 5 – Fonctions objectifs4.6.2 Benchmark Pour faciliter et automatiser les tests, une liste de mesures a ´t´ ´labor´ avec les param`tres e ee e ed´crits pr´c´demment et un script contenant l’ensemble des tests ` ex´cuter a ´t´ cr´e. La liste e e e a e ee edes mesures est pr´sent´e en figure 6. e e
  9. 9. 4 MESURE DE PERFORMANCE 9 Mesure Description 1 mesure pour toutes les combinaisons de P et D 2 mesure pour P ∈ [1, 101[ avec D = 1000 3 mesure pour P ∈ [1, 1001[ avec popStep = 10 et D = 1000 4 mesure pour D ∈ [1, 101[ avec P = 1000 5 mesure pour D ∈ [1, 1001[ avec dimStep = 10 et P = 1000 Figure 6 – Liste des mesures4.6.3 Dynamicit´ e Parmi les optimisations possibles en OpenMP, il existe deux types de planification, la pla-nification statique, utilis´ par d´faut, divise le nombre de tˆches ` traiter ` tous les processus e e a a adisponibles et la planification dynamique maintient une file de tˆches trait´e au fur et ` mesure a e apar les processus disponibles. Nous ´valuons la dynamicit´ par le rapport entre une mesure de e espeedup en mode statique et une mesure de speedup en mode dynamique 16 .4.6.4 R´sultats en O(1) e Le benchmark a ´t´ ex´cut´ dans un premier temps pour la fonction Sphere qui se r´soud en ee e e etemps constant. Les r´sultats de chaque mesure sont num´rot´s d’apr`s le tableau des mesures e e e ed´crit pr´c´demment. e e e Les mesures sont pr´sent´es en fonction des processeurs utilis´s et disponibles en figure 7, e e e8, 9, 10 et 11. 2.0 2.0 1.5 1.5 dynamicity - 1 speedup - 1 1.0 1.0 0.5 0.5 0.0 13 6791115192327313539434751555963677175798387919599104110116 245 8112162024283236404448525660646872768084889296101107113119 014182226303438424650545862667074788286909498102108114120 13172125293337414549535761656973778185899397 103109115121 105111117 100106112118 0.0 13 6791115192327313539434751555963677175798387919599104110116 245 8112162024283236404448525660646872768084889296101107113119 014182226303438424650545862667074788286909498102108114120 13172125293337414549535761656973778185899397 103109115121 105111117 100106112118 100 iterations from 1,1 to 101,101 100 iterations from 1,1 to 101,101 (a) speedup sur 2 coeurs (b) dynamicit´ sur 2 coeurs e 2.5 7 6 2.0 5 1.5 dynamicity - 1 4 speedup - 1 3 1.0 2 0.5 1 0.0 13 6791115192327313539434751555963677175798387919599104110116 245 8112162024283236404448525660646872768084889296101107113119 014182226303438424650545862667074788286909498102108114120 13172125293337414549535761656973778185899397 103109115121 105111117 100106112118 0 13 6791115192327313539434751555963677175798387919599104110116 245 8112162024283236404448525660646872768084889296101107113119 014182226303438424650545862667074788286909498102108114120 13172125293337414549535761656973778185899397 103109115121 105111117 100106112118 100 iterations from 1,1 to 101,101 100 iterations from 1,1 to 101,101 (c) speedup sur 8 coeurs (d) dynamicit´ sur 8 coeurs e Figure 7 – Mesure 1 en O(1) sur 2 et 8 coeurs Sp 16. Dynamicit´ : Dp = e d Sp
  10. 10. 5 CONCLUSION 10 2.0 2.0 1.5 1.5 dynamicity - 2 speedup - 2 1.0 1.0 0.5 0.5 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 1,1000 to 101,1000 100 iterations from 1,1000 to 101,1000 (a) speedup sur 2 coeurs (b) dynamicit´ sur 2 coeurs e 6 8 7 5 6 4 5 dynamicity - 2 speedup - 2 3 4 3 2 2 1 1 0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 1,1000 to 101,1000 100 iterations from 1,1000 to 101,1000 (c) speedup sur 8 coeurs (d) dynamicit´ sur 8 coeurs e Figure 8 – Mesure 2 en O(1) sur 2 et 8 coeurs4.6.5 R´sultats en O(n) e Dans un second temps, le benchmark est ex´cut´ pour le probl`me qui se r´soud en temps e e e evariable. Les r´sultats de chaque mesure sont num´rot´s d’apr`s le tableau des mesures d´crit e e e e epr´c´demment en figure 6. e e Il est important d’ajouter que compte tenu de la r´solution du probl`me en O(n) et non e eplus en fonction de la dimension, celle ci perd de son importance. Ainsi les mesures 1, 4 et 5 nesont plus nessaire ` mesurer. Seules les mesures 2 et 3 seront pr´sent´es ci-dessous. a e e Un algorithme s´quentiel ex´cut´ sur un processeur ` 8 coeurs en comparaison avec un pro- e e e acesseur ` 2 coeurs est plus performant sur des petits ´chantillons. Nous avons donc choisit de a ed´finir les bornes des param`tres, d´crits en figure 6, comme multiple du nombre de coeurs e e edisponible. Les mesures sont pr´sent´es en fonction des processeurs utilis´s et disponibles en figure 12 e e eet 13.5 Conclusion Pour un processeur ` 2 coeurs, selon la complexit´ du probl`me utilis´e, nous pouvons a e e eobserver par la mesure du speedup que les ressources sont utilis´es au maximum 17 pour de egrandes tailles d’´chantillon. Les petites tailles d’´chantillon restant domin´es par une ex´cution e e e es´quentielle. e Pour un processeur ` 8 coeurs, en hyperthreading, notre premi`re observation consiste ` a e amontrer les limites de l’hyperthreading, en effet nous utilisons pas plus de 4 coeurs. Et pour 17. cpu-bound
  11. 11. 5 CONCLUSION 11 2.0 2.0 1.5 1.5 dynamicity - 3 speedup - 3 1.0 1.0 0.5 0.5 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 1,1000 to 1001,1000 100 iterations from 1,1000 to 1001,1000 (a) speedup sur 2 coeurs (b) dynamicit´ sur 2 coeurs e 7 8 6 7 6 5 5 dynamicity - 3 4 speedup - 3 4 3 3 2 2 1 1 0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 1,1000 to 1001,1000 100 iterations from 1,1000 to 1001,1000 (c) speedup sur 8 coeurs (d) dynamicit´ sur 8 coeurs e Figure 9 – Mesure 3 en O(1) sur 2 et 8 coeursrejoindre ce qui a ´t´ dit sur 2 coeurs, un plus grand nombre de petites tailles d’´chantillon ee ereste domin´e par une ex´cution s´quentielle. e e e La diff´rence entre les deux complexit´s de probl`me s’observe dans la mesure de la dyna- e e emicit´. En effet pour un probl`me en O(1), la planification statique en OpenMP permet d’avoir e eune meilleur efficacit´ de travail tandis que en O(n), la planification dynamique apporte quelque eam´lioration. e Pour r´sumer nous avons compar´ par nos mesures les 2 types de planification de tˆches en e e aOpenMP, les 2 complexit´s de probl`mes que nous serons amen´ ` parall´liser et finalement sur e e ea e2 types de processeurs diff´rents. e Un point que je n’ai pas eu le temps d’´claircir que j’invite ` regarder est l’utilisation de e al’auto parall´lisation int´gr´ au compilateur GCC e e e 18 . Il s’agit d’un niveau d’optimisation quiconsiste ` v´rifier la non d´pendance des donn´es dans les boucles et les parall´liser. a e e e e 18. Automatic Parallelization : http://gcc.gnu.org/wiki/openmp
  12. 12. 5 CONCLUSION 12 2.0 2.0 1.5 1.5 dynamicity - 4 speedup - 4 1.0 1.0 0.5 0.5 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 1000,1 to 1000,101 100 iterations from 1000,1 to 1000,101 (a) speedup sur 2 coeurs (b) dynamicit´ sur 2 coeurs e 6 7 5 6 5 4 dynamicity - 4 4 speedup - 4 3 3 2 2 1 1 0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 1000,1 to 1000,101 100 iterations from 1000,1 to 1000,101 (c) speedup sur 8 coeurs (d) dynamicit´ sur 8 coeurs e Figure 10 – Mesure 4 en O(1) sur 2 et 8 coeurs 2.0 2.0 1.5 1.5 dynamicity - 5 speedup - 5 1.0 1.0 0.5 0.5 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 1000,1 to 1000,1001 100 iterations from 1000,1 to 1000,1001 (a) speedup sur 2 coeurs (b) dynamicit´ sur 2 coeurs e 6 8 7 5 6 4 5 dynamicity - 5 speedup - 5 3 4 3 2 2 1 1 0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 1000,1 to 1000,1001 100 iterations from 1000,1 to 1000,1001 (c) speedup sur 8 coeurs (d) dynamicit´ sur 8 coeurs e Figure 11 – Mesure 5 en O(1) sur 2 et 8 coeurs
  13. 13. 5 CONCLUSION 13 2.0 2.0 1.5 1.5 variable_dynamicity - 2 variable_speedup - 2 1.0 1.0 0.5 0.5 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 2,1000 to 202,1000 100 iterations from 2,1000 to 202,1000 (a) speedup sur 2 coeurs (b) dynamicit´ sur 2 coeurs e 7 3.5 6 3.0 5 2.5 variable_dynamicity - 2 variable_speedup - 2 4 2.0 3 1.5 2 1.0 1 0.5 0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 8,1000 to 808,1000 100 iterations from 8,1000 to 808,1000 (c) speedup sur 8 coeurs (d) dynamicit´ sur 8 coeurs e Figure 12 – Mesure 2 en O(n) sur 2 et 8 coeurs 2.0 2.0 1.5 1.5 dynamicity - 3 speedup - 3 1.0 1.0 0.5 0.5 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 2,1000 to 2002,1000 100 iterations from 2,1000 to 2002,1000 (a) speedup sur 2 coeurs (b) dynamicit´ sur 2 coeurs e 8 3.0 7 2.5 6 2.0 variable_dynamicity - 3 variable_speedup - 3 5 4 1.5 3 1.0 2 0.5 1 0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 0.0 123456789111417202326293235384144475053565962656871747780838689929598 101316192225283134374043464952555861646770737679828588919497101 121518212427303336394245485154576063666972757881848790939699 100 100 iterations from 8,1000 to 8008,1000 100 iterations from 8,1000 to 8008,1000 (c) speedup sur 8 coeurs (d) dynamicit´ sur 8 coeurs e Figure 13 – Mesure 3 en O(n) sur 2 et 8 coeurs

×