Document Actions
Comparaisons des méthodes
Comparaison des parallélisations par MPI et OpenMP sur l'équation de la chaleur 3D
- Cas test
- Résultats code séquentiel
- Résultats décomposition de domaine avec MPI
- Résultats partage de travail avec OpenMP : parallélisation implicite
- Résultats partage de travail avec OpenMP : parallélisation explicite
- Résultats décomposition de domaine avec OpenMP
- Résultats parallélisation à deux niveaux : parallélisation implicite
- Résultats parallélisation à deux niveaux : parallélisation explicite
- Conclusion
- Fichiers
Cas test
L'équation de la Chaleur en trois dimensions d'espace sert de cadre à ces comparaisons de performances entre plusieurs méthode de parallélisation : MPI, OpenMP, MPI-OpenMP avec des variantes dans les deux derniers cas. Dans le cas MPI-OpenMP, il s'agit de parallélisation à deux niveaux : décomposition de domaines avec MPI puis partage du travail avec OpenMP dans chacun des sous-domaine.
Selon le nombre de processus, les dimensions du problème à résoudre augmentent de telle sorte que chaque
processus-thread dispose d'une masse de calcul correspondant à un bloc avec 256x256x256 points. Le tableau suivant reprend les dimensions utilisées selon le nombre de processus-threads.
| Nombre total de processus-threads | ntx | nty | ntz | Couples (MPI - OpenMP) |
|---|---|---|---|---|
| 1 | 256 | 256 | 256 | (1-1) |
| 2 | 256 | 256 | 512 | (2-1) ; (1-2) |
| 4 | 256 | 512 | 512 | (4-1) ; (2-2) ; (1-4) |
| 8 | 512 | 512 | 512 | (8-1) ; (4-2) ; (2-4) ; (1-8) |
| 12 | 512 | 512 | 768 | (12-1) ; (6-2) ; (4-3) ; (3-4) ; (2-6) ; (1-12) |
| 16 | 512 | 512 | 1024 | (16-1) ; (8-2) ; (4-4) ; (2-8) ; (1-16) |
On effectue 100 itérations en temps avec une fréquence d'affichage de 1 pour 20.
La viscosité cinématique, lambda, vaut 1E-2.
Le pas de temps, dt, vaut 1E-3.
Le critère d'arrêt pour le Gradient Conjugué est : résidu inférieur à 1E-07 ou 50 itérations effectuées.
Comme la matrice est bien conditionnée la convergence du Gradient Conjugué a lieu en quelques itérations.
Les schémas relatifs à l'Equation de la Chaleur 3D sont décrits ici.
Résultats code séquentiel
Les mesures du temps et des performances sont réalisées à l'intérieur du code.
| 1 processus | Mesures |
|---|---|
| Temps écoulé (sec.) | 402.1 |
| MFlops / processus-thread | 751.1 |
| MFlops cumulés | 751.1 |
Résultats décomposition de domaine avec MPI
La parallélisation repose sur la décomposition de domaine. On fractionne le domaine de calcul initial en plusieurs sous-domaines sur lesquels on construit une topologie cartésienne pour faire une correspondance avec les processus MPI.Des routines d'envoi-réception de messages MPI permettent d'échanger des données entre voisins aux interfaces des sous-domaines.
Les mesures du temps et des performances sont réalisées à l'intérieur du code.
| Nombre de processus MPI | Nombre moyen d'itérations de Gradient Conjugué | Temps écoulé (sec.) | MFlops / processus | MFlops cumulés |
|---|---|---|---|---|
| 1 | 7 | 377 | 800 | 800 |
| 2 | 11 | 605 | 741.3 | 1482.5 |
| 4 | 13 | 818 | 673.8 | 2695.3 |
| 8 | 16 | 1297 | 494.8 | 3958.7 |
| 12 | 20 | 2065 | 390.7 | 4688.7 |
| 16 | 25 | 3384 | 291.4 | 4662.9 |
Résultats partage de travail avec OpenMP : parallélisation implicite
Il s'agit de la première variante de la parallélisation avec OpenMP.La parallélisation est faite en plaçant des directives !$OMP DO ...!$OMP END DO autour des boucles parallélisables, soit dans les routines gradconj, nrmerr, fctfx, saxpy, prodscal, scdmb. Ainsi le système gère la répartition des itérations entre les threads OpenMP.
Une seule région parallèle a été construite : elle englobe la boucle en temps de résolution de l'équation.
Les mesures du temps et des performances sont réalisées à l'intérieur du code.
| Nombre de threads OpenMP | Nombre moyen d'itérations de Gradient Conjugué | Temps écoulé (sec.) | MFlops / thread | MFlops cumulés |
|---|---|---|---|---|
| 1 | 7 | 374 | 804.3 | 804.3 |
| 2 | 11 | 723 | 620.6 | 1241.2 |
| 4 | 13 | 1419 | 388.2 | 1552.7 |
| 8 | 16 | 2882 | 222.6 | 1780.8 |
| 12 | 20 | 4222 | 191.2 | 2294.8 |
| 16 | 25 | 7130 | 138.4 | 2214.7 |
Résultats partage de travail avec OpenMP : parallélisation explicite
Il s'agit de la deuxième variante de la parallélisation avec OpenMP.La parallélisation est faite en découpant "à la main" les boucles parallélisables, i.e. on calcule les indices de ces boucles pour chaque thread. Il n'y a alors plus de directives !$OMP DO ...!$OMP END DO autour de ces boucles, soit dans les routines gradconj, nrmerr, fctfx, saxpy, prodscal, scdmb. Seules subsistent les directives de synchronisation et de mises à jour atomiques. Ainsi le système ne gère pas la répartition des itérations entre les threads OpenMP.
Une seule région parallèle a été construite : elle englobe la boucle en temps de résolution de l'équation.
Les mesures du temps et des performances sont réalisées à l'intérieur du code.
| Nombre de threads OpenMP | Nombre moyen d'itérations de Gradient Conjugué | Temps écoulé (sec.) | MFlops / thread | MFlops cumulés |
|---|---|---|---|---|
| 1 | 7 | 378 | 797.6 | 797.6 |
| 2 | 11 | 751 | 597.2 | 1194.4 |
| 4 | 13 | 1401 | 393.5 | 1574.0 |
| 8 | 16 | 2743 | 233.6 | 1868.6 |
| 12 | 20 | 4199 | 192.3 | 2307.7 |
| 16 | 25 | 7020 | 140.3 | 2245.0 |
Résultats décomposition de domaine avec OpenMP
Il s'agit de la troisième variante de la parallélisation avec OpenMP.La parallélisation repose sur la décomposition de domaine. On fractionne le domaine de calcul initial en plusieurs sous-domaines sur lesquels on construit une topologie cartésienne pour faire une correspondance avec les threads OpenMP. Contrairement à MPI, la construction de la topologie est à faire "à la main" mais n'est pas compliquée à créer.
Il n'y a pas de routines d'envoi-réception de données pour échanger des données entre voisins aux interfaces des sous-domaines. Pour effectuer les mises à jour des valeurs fantomes, on construit des buffers locaux à chaque thread et à l'aide de variables de type POINTER on stocke les adresses mémoire de ces buffers. Il n'y a plus qu'à récupérer ces adresses au travers de variables publiques pour aller directement chercher les données dans ces buffers.
Les mesures du temps et des performances sont réalisées à l'intérieur du code.
| Nombre de threads OpenMP | Nombre moyen d'itérations de Gradient Conjugué | Temps écoulé (sec.) | MFlops / thread | MFlops cumulés |
|---|---|---|---|---|
| 1 | 7 | 402 | 751.1 | 751.1 |
| 2 | 11 | 721 | 621.9 | 1243.7 |
| 4 | 13 | 993 | 555.3 | 2221.3 |
| 8 | 16 | 1561 | 411.2 | 3289.3 |
| 12 | 20 | 2428 | 332 | 3984.6 |
| 16 | 25 | 4002 | 246 | 3938.4 |
Résultats parallélisation à deux niveaux : parallélisation implicite
Les mesures du temps et des performances sont réalisées à l'intérieur du code.Les couples correspondent aux nombres de processus-threads (MPI - OpenMP).
| Couple (MPI-OpenMP) | Nombre moyen d'itérations de Gradient Conjugué | Temps écoulé (sec.) | MFlops / processus-thread | MFlops cumulés |
|---|---|---|---|---|
| Couple (1-1) | 7 | 374 | 806.8 | 806.8 |
| Couple (2-1) | 11 | 588 | 762.6 | 1525.2 |
| Couple (1-2) | 11 | 768 | 584.3 | 1168.7 |
| Couple (4-1) | 13 | 795 | 693.2 | 2772.9 |
| Couple (2-2) | 13 | 1009 | 546.4 | 2185.7 |
| Couple (1-4) | 13 | 1426 | 387.0 | 1547.8 |
| Couple (8-1) | 16 | 1278 | 501.9 | 4014.8 |
| Couple (4-2) | 16 | 1406 | 456.0 | 3648.3 |
| Couple (2-4) | 16 | 1920 | 334.0 | 2672.1 |
| Couple (1-8) | 16 | 2755 | 232.9 | 1862.8 |
| Couple (12-1) | 20 | 1884 | 428.1 | 5137.5 |
| Couple (6-2) | 20 | 2102 | 384.2 | 4610.5 |
| Couple (4-3) | 20 | 2441 | 330.8 | 3970.0 |
| Couple (3-4) | 20 | 2478 | 326.0 | 3911.8 |
| Couple (2-6) | 20 | 3525 | 228.7 | 2744.8 |
| Couple (1-12) | 20 | 4207 | 191.9 | 2302.3 |
| Couple (16-1) | 25 | 3185 | 309.6 | 4953.5 |
| Couple (8-2) | 25 | 3413 | 288.5 | 4615.3 |
| Couple (4-4) | 25 | 3706 | 266.1 | 4257.4 |
| Couple (2-8) | 25 | 6528 | 151.2 | 2419.1 |
| Couple (1-16) | 25 | 6707 | 147.0 | 2352.4 |
Résultats parallélisation à deux niveaux : parallélisation explicite
Les mesures du temps et des performances sont réalisées à l'intérieur du code.Les couples correspondent aux nombres de processus-threads (MPI - OpenMP).
| Couple (MPI-OpenMP) | Nombre moyen d'itérations de Gradient Conjugué | Temps écoulé (sec.) | MFlops / processus-thread | MFlops cumulés |
|---|---|---|---|---|
| Couple (1-1) | 7 | 380 | 796.5 | 796.5 |
| Couple (2-1) | 11 | 579 | 773.7 | 1547.3 |
| Couple (1-2) | 11 | 723 | 620.2 | 1240.4 |
| Couple (4-1) | 13 | 800 | 686.7 | 2746.9 |
| Couple (2-2) | 14 | 1054 | 523.9 | 2095.4 |
| Couple (1-4) | 14 | 1411 | 391.2 | 1564.8 |
| Couple (8-1) | 16 | 1267 | 505.7 | 4045.2 |
| Couple (4-2) | 16 | 2718 | 456.9 | 3655.1 |
| Couple (2-4) | 16 | 1902 | 338.3 | 2706.7 |
| Couple (1-8) | 16 | 2740 | 234.3 | 1874.5 |
| Couple (12-1) | 20 | 1890 | 427 | 5124 |
| Couple (6-2) | 37 | 3896 | 377.8 | 4533.7 |
| Couple (4-3) | 46 | 4611 | 347.2 | 4166.4 |
| Couple (3-4) | 20 | 2321 | 347.4 | 4168.3 |
| Couple (2-6) | 22 | 3422 | 267.1 | 3205.5 |
| Couple (1-12) | 20 | 4206 | 192.0 | 2303/8 |
| Couple (16-1) | 25 | 3119 | 316.1 | 5056.9 |
| Couple (8-2) | 37 | 4861 | 302.1 | 4833.4 |
| Couple (4-4) | 47 | 6733 | 266.1 | 4257.9 |
| Couple (2-8) | 50 | 9576 | 206.0 | 3296.2 |
| Couple (1-16) | 25 | 6706 | 147.3 | 2356.6 |
Conclusions
- les versions parallèles permettent d'obtenir des temps de retour plus courts que la version séquentielle du code avec des résultats qualitativement équivalents;- La parallélisation basée sur la décomposition de domaine est plus efficace que celle basée sur le partage du travail lorsque le volume de données à traiter augmente. En effet, pour la première méthode, on augmente le nombre de processus/thread mais le volume de données reste constant et demeure dans la mémoire locale. Pour la seconde méthode, le volume global augmente, et il est partagé entre plus de processus, ce qui stresse la bande passante mémoire.
- les mesures effectuées dépendent de l'état du système, de la charge de la machine et mais demeurent intéressantes pour les routines représentant une part significative du temps consommé.
Fichiers
On peut récupérer l'arborescence des fichiers source sous forme d'archive tar.gz .Le répertoire Gradient contient différents sous-répertoires (MPI, 1OMPI, 2OMPI, 1OMP, 2OMP et SEQ) qui correspondent aux différentes versions présentées ci-dessus.