IPD TP1 - Enonce 2012-2013.pdf

Travaux pratique d'Informatique Parallèle et Distribuée, UMONS/Polytech, TP 1 1
1.Programmation de systèmes à mémoire partagée avec l'API OpenMP
1.1.Objectifs
Les objectifs de la séance sont de:
1.2.Généralités
● se familiariser avec la syntaxe d'OpenMP
● réaliser des programmes multi­threadés exploitant les multiples cores/processeurs
OpenMP est une API permettant la programmation d'applications parallèles à mémoire partagée
en langage C/C++ ou Fortran.
Son fonctionnement repose sur la définition de sections de code parallèles permettant un partage
du calcul à réaliser et d'un ensemble d'étapes de synchronisation. L'exécution est multi­threadée et n'a
donc d'intérêt que sur des machines à mémoire partagée multi­processeurs et/ou multi­cores (ce qui est le
cas des PC utilisés dans la salle informatique).
De nombreux compilateurs open source (e.g. gcc à partir de la version 4.2) et propriétaires (e.g.
IBM, Intel, Portland Group) implémentent la spécification OpenMP.
1.3.Généralités sur la programmation multi-threadée
Un programme multi­threadé se caractérise par un ensemble de fils d'exécution se déroulant
simultanément sur des unités de traitements différentes (core/processeur) au sein d'un unique processus.
L'ordonnancement des fils d'exécution et le partage du temps de calcul sur la machine sont réalisés par le
système d'exploitation (e.g. le noyau Linux).
La création d'une telle application nécessite donc d'identifier les sections denses en terme de
quantité de calculs et de déterminer une manière de diviser le travail en différentes parties. Le processus
principal (thread principal) donne alors naissance à un ensemble de threads qui s'exécutent en parallèle:
Thread
principal
Section
parallèle
Thread
principal
FORK JOIN
(synchronisation)
UMONS/Polytech
Pierre Manneback, Sébastien Frémal, Sébastien Noël 2012­13

Travaux pratique d'Informatique Parallèle et Distribuée, UMONS/Polytech, TP 1 2
1.4.Utilisation d'OpenMP avec gcc
Lors des séances de TP, nous utiliserons le compilateur GNU gcc en spécifiant l'option de
compilation ­fopenmp afin de lui permettre d'interpréter les directives OpenMP. La compilation d'un
code code.c se fera donc de la manière suivante:
gcc code.c ­o executable ­fopenmp
L'en­tête omp.h doit également être inclus en début de code:
#include
Une section parallèle OpenMP est spécifiée par une construction du type:
#pragma omp parallel
{
...
}
Lorsqu'un thread principal atteint une section parallèle, il crée un groupe de n threads dont il
devient le maître. Le nombre n de threads créés dépend du nombre d'unités de traitement sur la machine
utilisée. Implicitement, les threads s'attendent mutuellement en sortie d'une section parallèle sauf si
l'option nowait à été spécifiée dans la déclaration de la section:
#pragma omp parallel nowait
Les variables déclarées avant la section parallèle et devant être manipulées par les threads sont
spécifiées dans la déclaration de la section parallèle en tant que partagée (shared) ou privée (private):
#pragma omp parallel private(i,j) → chaque thread dispose d'une copie locale de i et j
#pragma omp parallel shared(n) → chaque thread partage l'accès à une unique variable n
Une opération de réduction (e.g. somme globale) peut être opérée sur une variable: de cette
manière, chaque thread travaille sur une variable privée et une réduction de la valeur des variables est
opérée en sortie de la section parallèle:
#pragma omp parallel reduction(+:i)
→ chaque thread dispose d'une copie de i et la somme
de toutes les valeurs de i est réalisée en sortie de
section parallèle
Un test peut être réalisé si l'on souhaite conditionner la création d'un groupe de threads suivant la
valeur d'un paramètre donné:
#pragma omp parallel if ( n > 3 )
→ le groupe de threads n'est créé que si le test est vrai
UMONS/Polytech
Pierre Manneback, Sébastien Frémal, Sébastien Noël 2012­13

Travaux pratique d'Informatique Parallèle et Distribuée, UMONS/Polytech, TP 1 3
a) Partage du travail
Quatre « schémas » sont mis à disposition par OpenMP pour diviser le travail entre les différents
threads au sein d'une section parallèle:
#pragma omp for
for(i=0;i

Travaux pratique d'Informatique Parallèle et Distribuée, UMONS/Polytech, TP 1 4
• Barrier
Une autre directive permet de synchroniser tous les threads de la section parallèle en attendant
que tous atteignent un certain point dans le programme:
#pragma omp barrier
c) Fonctions OpenMP
Un ensemble de fonctions est mis à disposition pour réaliser certaines opérations sur
l'environnement OpenMP.
void omp_set_num_threads(int num_threads) Spécifie le nombre de threads à utiliser (doit être
déclaré avant une section parallèle)
int omp_get_num_threads(void) Retourne le nombre de threads dans la section
parallèle
int omp_get_thread_num(void) Retourne le numéro du thread appelant
int omp_get_num_procs(void) Retourne le nombre d'unités de traitement
double omp_get_wtime(void) Retourne le nombre de secondes écoulées
UMONS/Polytech
Pierre Manneback, Sébastien Frémal, Sébastien Noël 2012­13

Travaux pratique d'Informatique Parallèle et Distribuée, UMONS/Polytech, TP 1 5
1.5.Exercices
a) Exercice 1
Écrire un programme affichant un message quelconque(e.g. « Hello world »).
Intégrer cet affichage à une section parallèle et ajouter au message les informations suivantes:
● le nombre de threads créés
● le numéro du thread affichant le message
● le nombre d'unités de traitement sur la machine utilisée
Ajouter ensuite une boucle parallèle afin d'afficher le message 10 fois.
b)Exercice 2.1
On souhaite réaliser un programme capable de calculer la somme des nombres premiers
inférieurs à une valeur donnée n.
La valeur de n sera passée comme argument dans la ligne de commande:
./ex1 100000
aura pour effet de calculer la somme des nombres premiers inférieurs à 100000 (remarque: en
vue de tester votre programme, le résultat à trouver vaut : 454396537).
Dans un premier temps, aucune directive OpenMP ne sera utilisée, le programme étant alors
exécuté séquentiellement.
Observer le temps d'exécution à l'aide de la commande unix time.
c) Exercice 2.2
time ./ex1 100000
Paralléliser l'exercice 1 à l'aide d'une boucle parallèle OpenMP et d'une variable partagée.
Remarque:
● Protéger l'accès à la variable partagée result.
● Tester différentes politiques d'ordonnancement à l'aide de l'option schedule et
observer leur impact sur le temps de calcul.
d)Exercice 2.3
Utiliser la directive reduction pour remplacer la variable partagée result.
UMONS/Polytech
Pierre Manneback, Sébastien Frémal, Sébastien Noël 2012­13

Travaux pratique d'Informatique Parallèle et Distribuée, UMONS/Polytech, TP 1 6
e) Exercice 3
Lire et comprendre le premier programme séquentiel fourni en annexe.
Ce programme permet la création d'un tableau de particules positionnées aléatoirement dans un
espace virtuel à 3 dimensions. Le nombre de particules est fourni en argument au lancement du
programme. La distance entre les particules prises 2 à 2 est ensuite évaluée et le programme fournit le
numéro des 2 particules les plus proches ainsi que la distance qui les sépare.
Paralléliser ce programme en utilisant les directives OpenMP afin d'obtenir le meilleur temps
d'exécution.
Estimer le nombre minimum de particules en dessous duquel la parallélisation n'améliore pas les
performances; introduire alors un test « if » sur ce nombre minimum conditionnant la création des
threads.
f) Exercice 4
Lire et comprendre le second programme séquentiel fourni en annexe.
Ce programme calcul le nombre de partitions de x en au plus y parties (noté d(x,y)), ce qui
signifie qu'il calcule le nombre de combinaisons d'au plus y chiffres et dont la somme vaut x. Exemple :
d(5,3) = {5} + {4+1} + {3+2} + {1+1+3} + {1+2+2} = 5
Soit d'(x,y) le nombre de partitions qui comprennent exactement y chiffres (soit 2 dans notre
exemple si y vaut 3), alors d(x,y) = d'(x,y) + d(x,y­1) (nombre de partitions de x en au plus y parties =
nombre de partitions de x en exactement y parties + nombre de partitions de x en au plus (y­1) parties).
Il a été démontré que d'(x,y) = d(x­y,y) 1 et ainsi :
d(x,y) = d(x­y,y) + d(x,y­1)
Paralléliser ce programme en utilisant les directives OpenMP afin d'optimiser le temps de calcul.
1. S. Skiena, Implementing Discrete Mathematics: Combinatorics and Graph Theory
with Mathematica. Reading, MA: Addison­Wesley, 1990, p.58
UMONS/Polytech
Pierre Manneback, Sébastien Frémal, Sébastien Noël 2012­13