Parallel Programming in C with MPI and OpenMP

Présentation au sujet: "Parallel Programming in C with MPI and OpenMP"— Transcription de la présentation:

1 Parallel Programming in C with MPI and OpenMP
Michael J. Quinn

2 Le crible d’Ératosthène
Chapitre 5 Le crible d’Ératosthène

3 Objectifs Analyse du partitionement d’un tableau
Introduction de la fonction MPI_Bcast

4 Algorithme séquentiel
2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 12 12 13 14 14 15 15 16 16 17 18 18 19 20 20 21 21 22 22 23 24 24 25 25 26 26 27 27 28 28 29 30 30 31 32 32 33 33 34 34 35 35 36 36 37 38 38 39 39 40 40 41 42 42 43 44 44 45 45 46 46 47 48 48 49 49 50 50 51 51 52 52 53 54 54 55 55 56 56 57 57 58 58 59 60 60 61 Complexité: (n ln ln n)

5 Pseudocode 1. Créer une liste non marquée d’entiers 2, 3, …, n
2. k  2 3. Répéter (a) Marquer tous les multiples de k entre k2 et n (b) k  plus petit entier non marqué > k jusqu’à ce que k2 > n 4. Les entiers non marqués sont premiers

6 Rendre 3(a) Parallèle  Marquer tous les multiple de k entre k2 et n
Pour tout j entre k2 et n faire si j mod k = 0 alors marquer j // pas premier

7 Rendre 3(b) Parallèle  Trouver le plus petit entier non marqué > k
Min-reduction: pour trouver le plus petit entier non marqué > k Diffusion (Broadcast): Pour communiquer le résultat

8 Option de partitionnement
Entrelacé (cyclique) Facile de déterminer le « responsable » d’un indice Charge de travail non balancée Par bloc Balance la charge de travail Si n n’est pas un multiple de p alors il est plus difficile de trouver le “responsable” d’un indice.

9 Partitionnement par bloc
On veut balancer la charge de travail Chaque processus reçoit n/p ou n/p elements On recherche des expressions simples pour: Trouver le plus petit et plus grand indice de la partie de tableau d’un processus Trouver le responsable d’un indice

10 Méthode 1 r = n mod p Si r = 0, tous les blocs ont la même taille
Sinon Les premiers r blocs ont une taille n/p Les p-r blocs suivants ont une taille n/p

11 Exemples 17 elements, 7 processus 17 elements, 5 processus
17 element, 3 processus

12 Méthode 1: Calculs Premier élément contrôlé par le processus i
Dernier élément contrôlé par le processus i Processus contrôlant l’élément j

13 Méthode 1: Exemple 1 Premier élément contrôlé par le processus i
N=12, p=4 Premier élément contrôlé par le processus i Dernier élément contrôlé par le processus i Processus contrôlant l’élément j

14 Méthode 1: Exemple 2 Premier élément contrôlé par le processus i
N=14, p=4 Premier élément contrôlé par le processus i Dernier élément contrôlé par le processus i Processus contrôlant l’élément j

15 Méthode 2 On disperse les grands blocs parmi les processus
Premier élément contrôlé par le processus i Dernier élément contrôlé par le processus i Processus contrôlant l’élément j

16 Exemples 17 elements, 7 processus 17 elements, 5 processus

17 Comparaison Notre choix
Opérations Méthode 1 Méthode 2 Premier élément 4 2 Dernier élément 6 Responsable 7 En supposant aucune opération pour le calcul du plancher

18 Macros #define BLOCK_LOW(id,p,n) ((i)*(n)/(p))
#define BLOCK_HIGH(id,p,n) \ (BLOCK_LOW((id)+1,p,n)-1) #define BLOCK_SIZE(id,p,n) \ (BLOCK_LOW((id)+1)-BLOCK_LOW(id)) #define BLOCK_OWNER(index,p,n) \ (((p)*(index)+1)-1)/(n))

19 Indices locaux et globaux

20 Indices locaux et globaux
Programme séquentiel for (i = 0; i < n; i++) { … } Programme parallèle size = BLOCK_SIZE (id,p,n); for (i = 0; i < size; i++) { gi = i + BLOCK_LOW(id,p,n); Indice local i de ce processus… …correspond à l’indice global gi

21 Avantage du partitionnement par bloc
La plus grande valeur de k possible est n Le premier processus contrôle n/p éléments Il contrôle toutes les valeurs de k possibles si p < n Le premier processus diffuse k aux autres Aucune réduction n’est nécessaire

22 Avantage du partitionnement par bloc
Le partitionnement par bloc permet un marquage identique à la méthode séquentielle: j, j + k, j + 2k, j + 3k, … plutôt que Pour tout j entre k2 et n faire si j mod k = 0 alors marquer j

23 Développement de l’algorithme parallèle
1. Créer une liste d’entiers non marqués 2, 3, …, n 2. k  2 3. Répéter (a) Marquer tous les multiple de k entre k2 and n (chacun sa partie) (b) k  plus petit entier non marqué > k (processus 0 seulement) (c) Processus 0 diffuse k aux autres processus Jusqu’à ce que k2 > m 4. Les entiers non marqués sont premiers 5. Le nombre de nombres premiers est déterminé par une réduction

24 Function MPI_Bcast MPI_Bcast (&k, 1, MPI_INT, 0, MPI_COMM_WORLD);
int MPI_Bcast ( void *buffer, /* Addr du 1er élément*/ int count, /* # éléments à diffuser*/ MPI_Datatype datatype, /* Type des éléments*/ int root, /* ID du processus racine*/ MPI_Comm comm) /* Communicator */ MPI_Bcast (&k, 1, MPI_INT, 0, MPI_COMM_WORLD);

25 Code (1/4) #include <mpi.h> #include <math.h>
#include <stdio.h> #include "MyMPI.h" #define MIN(a,b) ((a)<(b)?(a):(b)) int main (int argc, char *argv[]) { ... MPI_Init (&argc, &argv); MPI_Barrier(MPI_COMM_WORLD); elapsed_time = -MPI_Wtime(); MPI_Comm_rank (MPI_COMM_WORLD, &id); MPI_Comm_size (MPI_COMM_WORLD, &p); if (argc != 2) { if (!id) printf ("Command line: %s <m>\n", argv[0]); MPI_Finalize(); exit (1); }

26 Code (2/4) n = atoi(argv[1]); low_value = 2 + BLOCK_LOW(id,p,n-1);
high_value = 2 + BLOCK_HIGH(id,p,n-1); size = BLOCK_SIZE(id,p,n-1); proc0_size = (n-1)/p; if ((2 + proc0_size) < (int) sqrt((double) n)) { if (!id) printf ("Too many processes\n"); MPI_Finalize(); exit (1); } marked = (char *) malloc (size); if (marked == NULL) { printf ("Cannot allocate enough memory\n");

27 Code (3/4) for (i = 0; i < size; i++) marked[i] = 0;
if (!id) index = 0; prime = 2; do { if (prime * prime > low_value) first = prime * prime - low_value; else { if (!(low_value % prime)) first = 0; else first = prime - (low_value % prime); } for (i = first; i < size; i += prime) marked[i] = 1; if (!id) { while (marked[++index]); prime = index + 2; MPI_Bcast (&prime, 1, MPI_INT, 0, MPI_COMM_WORLD); } while (prime * prime <= n);

28 Code (4/4) count = 0; for (i = 0; i < size; i++)
if (!marked[i]) count++; MPI_Reduce (&count, &global_count, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); elapsed_time += MPI_Wtime(); if (!id) { printf ("%d primes are less than or equal to %d\n", global_count, n); printf ("Total elapsed time: %10.6f\n", elapsed_time); } MPI_Finalize (); return 0;