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

1. Parall´lisation & mod`les
e e
de programmation
Caner Candan
M2 MIHP
6 mars 2011
Table des mati`res
e
1 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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3 Design 5
3.1 Diagramme de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.2 Surcharge d’op´rateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e 5
4 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 . . . . . . . . . . . . . . . . . . . . . . . 10
5 Conclusion 10
1

2. 1 PRODUIT MATRICIEL 2
1 Produit matriciel
1.1 ´
Enonc´
e
Matrice : D´crire un algorithme PRAM pour le mod`le EREW qui utilise O(n3 ) processeurs
e e
pour multiplier deux matrices de taille n ∗ n. 1
1.2 Solution
Une solution consisterait ` diffuser dans un premier temps toutes les donn´es des matrices `
a e a
multiplier ` chaque processus puis de faire le produit des matrices en prenant le soin que chaque
a
processus utilise les donn´es qui leur est propre.
e
1.2.1 La diffusion
En respectant le mod`le EREW, les matrices A et B ∈ Kn∗n sont copi´es, dans un premier
e e
temps, n fois dans les cubes A et B ∈ Kn∗n∗n . Ceci permet de r´server une dimension du cube
e
a
` 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 e
en entr´e une matrice M ∈ Kn∗n et retourne un cube M ∈ Kn∗n∗n . Elle est exprim´e en
e e
2 ´tapes. La premi`re consiste ` affecter, en utilisant O(n2 ) processeurs, chaque point de la
e e a
matrice dans la premi`re dimension du cube. La deuxi`me ´tape effectue la copie en diffusion 2
e e e
de chaque point de la matrice situ´ ` la premi`re dimension du cube vers les autres dimensions
ea e
du 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. ´
2 DECOUPAGE D’UN TABLEAU BINAIRE 3
1.2.2 Le produit
En appliquant le mod`le EREW, le produit matriciel prend en param`tre les cubes A et
e e
B ∈ Kn∗n∗n tel que chaque processus utilise sa dimension de cube respective pour lire les
donn´es de aij et bij .
e
L’algorithme 2 pr´sente le pseudo-code de la fonction de produit matriciel qui prend comme
e
donn´e en entr´e les cubes A et B ∈ Kn∗n∗n et retourne une matrice C ∈ Kn∗n . L’affectation
e e
des 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 matriciel
1.2.3 L’impl´mentation
e
Apr`s avoir d´crit la fonction de diffusion et le produit matriciel respectant tous deux le
e e
mod`le EREW, nous allons voir l’implementation d’un produit de deux matrices A et B ∈ Kn∗n
e
produisant 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
e
2 D´coupage d’un tableau binaire
e
2.1 ´
Enonc´
e
D´coupage d’un tableau : Soit A un tableau de longueur n dont les ´l´ments sont soit des
e ee
0 soit des 1. Concevez un algorithme EREW de complexit´ O(log n) utilisant O(n) processeurs
e
pour 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. ´
2 DECOUPAGE D’UN TABLEAU BINAIRE 4
2.2 Solution
Notre tableau ´tant binaire, contenant que des 0 et 1, il devient facile de compter le nombre
e
de 1 en sommant toutes les valeurs du tableau pour ensuite d´terminer ` quel index placer les
e a
0 et 1.
Toute fois pour respecter l’´nonc´ et avoir une complexit´ en O(log n), nous allons devoir
e e e
utiliser la fonction calculant la somme des pr´fixes.
e
2.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 e
le tableau. Pour cela il prend en param`tre le tableau binaire B ∈ Kn ainsi que la taille du
e
tableau 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’index
2.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 e
fonction 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 e
2.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. 3 DESIGN 5
3 Design
Tous les exercices ont ´t´ d´velopp´s en C++ en utilisant le paradigme de programmation
ee e e
objet et le design qui suit a ´t´ ´labor´ pour regrouper les diff´rents composants de calculs.
ee e e e
N´anmoins une recherche a ´t´ effectu´ pour d´terminer les limites de OpenMP et C++. Il
e ee e e
semblerait que les conteneurs fournit par la STL 3 ne soient pas threadsafe 4 . Une ´tude 5 donne
e
une liste non-exhaustive des pr´cautions ` prendre lors de l’utilisation de OpenMP en C++.
e a
Cependant 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 tableau
et ´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 e
de calcul ` param`tre unique “OMPComputeUnary” et celles ` deux param`tres “OMPCompu-
a e a e
teBinary”. Tous deux renvoient un r´sultat. Elles sont pr´fix´es de “OMP” pour OpenMP 6 . Le
e e e
calcul de somme des pr´fixes prenant un seul param`tre en entr´e “OMPVector” et renvoyant
e e e
un “Atom”, cette classe se situe dans la famille “OMPComputeUnary”. Le produit matriciel se
situe, 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 e
exemple, 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 e
l’op´rateur ∗ se voit ainsi surcharg´ dans la classe “OMPMatrix” afin d’appeler implicitement
e e
la classe “OMPMatrixProduct” pour le calcul du produit matriciel. Ainsi en ´crivant le code
e
C = 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 une
ex´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. 4 MESURE DE PERFORMANCE 6
4 Mesure de performance
Je profite de ce rapport pour parler d’un travail qui m’a ´t´ demand´ en entreprise. Nous uti-
ee e
lisons le framework EO 7 pour d´velopper nos algorithmes ´volutionnaires 8 . Le sujet consistait
e e
a
` impl´menter, au framework EO, un parall´lisme ` m´moire partag´e en utilisant OpenMP.
e e a e e
4.1 Pr´ambule
e
Avant de commencer il est important de pr´ciser que les EA 9 travaillent sur une population
e
d’individu aussi appel´ ´chantillon. Un individu ´tant repr´sent´ par un point dans l’´chantillon,
ee e e e e
la 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 e
point dans l’´chantillon) et ´value toutes ses dimensions pour en d´duire la qualit´ 10 . La qualit´
e e e e e
est le crit`re de comparaison d’un point dans son ´chantillon.
e e
4.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 e
framework EO. Le test nous a permit d’identifier une fonction qui est utilis´e par une grande
e
majorit´ des op´rateurs 11 EO. Il s’agit de la fonction “apply”. Elle prend en param`tres une
e e e
population d’individu et un op´rateur. Cette fonction va it´rer sur tous les individus de la
e e
population et appliquer l’op´rateur. Il peut ˆtre int´ressant d’optimiser cette fonction. Nous
e e e
allons nous limiter ` transformer le code s´quentiel en parall`le.
a e e
4.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 a
chaque 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 apply
4.4 La fonction en parall`le
e
L’algorithme 8 transforme la fonction “apply” en parall`le en utilisant le mod`le PRAM
e e
CREW 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. 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 apply
4.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 e
dans 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 e
4.6 Mesures
En prenant en compte les param`tres d´crits pr´c´demment, nous allons lancer les tests sur
e e e e
deux 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 e
avec 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. 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
e
4.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 e
a e
` r´soudre. Pour nos tests, le choix a ´t´ orient´ vers deux fonctions objectifs de complexit´
ee e e
diff´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 objectifs
4.6.2 Benchmark
Pour faciliter et automatiser les tests, une liste de mesures a ´t´ ´labor´ avec les param`tres
e ee e e
d´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 e
des mesures est pr´sent´e en figure 6.
e e

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 mesures
4.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 a
disponibles et la planification dynamique maintient une file de tˆches trait´e au fur et ` mesure
a e a
par les processus disponibles. Nous ´valuons la dynamicit´ par le rapport entre une mesure de
e e
speedup 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 e
temps constant. Les r´sultats de chaque mesure sont num´rot´s d’apr`s le tableau des mesures
e e e e
d´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 e
8, 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. 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 coeurs
4.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 e
variable. Les r´sultats de chaque mesure sont num´rot´s d’apr`s le tableau des mesures d´crit
e e e e e
pr´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 e
plus en fonction de la dimension, celle ci perd de son importance. Ainsi les mesures 1, 4 et 5 ne
sont 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 a
cesseur ` 2 coeurs est plus performant sur des petits ´chantillons. Nous avons donc choisit de
a e
d´finir les bornes des param`tres, d´crits en figure 6, comme multiple du nombre de coeurs
e e e
disponible.
Les mesures sont pr´sent´es en fonction des processeurs utilis´s et disponibles en figure 12
e e e
et 13.
5 Conclusion
Pour un processeur ` 2 coeurs, selon la complexit´ du probl`me utilis´e, nous pouvons
a e e e
observer par la mesure du speedup que les ressources sont utilis´es au maximum 17 pour de
e
grandes tailles d’´chantillon. Les petites tailles d’´chantillon restant domin´es par une ex´cution
e e e e
s´quentielle.
e
Pour un processeur ` 8 coeurs, en hyperthreading, notre premi`re observation consiste `
a e a
montrer les limites de l’hyperthreading, en effet nous utilisons pas plus de 4 coeurs. Et pour
17. cpu-bound

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 coeurs
rejoindre ce qui a ´t´ dit sur 2 coeurs, un plus grand nombre de petites tailles d’´chantillon
ee e
reste 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 e
micit´. En effet pour un probl`me en O(1), la planification statique en OpenMP permet d’avoir
e e
une meilleur efficacit´ de travail tandis que en O(n), la planification dynamique apporte quelque
e
am´lioration.
e
Pour r´sumer nous avons compar´ par nos mesures les 2 types de planification de tˆches en
e e a
OpenMP, les 2 complexit´s de probl`mes que nous serons amen´ ` parall´liser et finalement sur
e e ea e
2 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 a
l’auto parall´lisation int´gr´ au compilateur GCC
e e e 18 . Il s’agit d’un niveau d’optimisation qui
consiste ` 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. 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. 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