OpenMP

OpenMP est une interface de programmation pour le calcul parallèle sur des architectures à mémoire partagée. Elle est disponible pour les langages C, C++ et Fortran. Cette API est prise en charge par les plateformes Unix, Linux, Mac OS X et Windows.
Il se présente sous la forme d'un ensemble de directives de compilation, de fonctions et de variables d'environnement qui influencent le comportement d'exécution du programme.

Concepts

Le programme OpenMp est exécuté par un processus unique qui est appelé thread maître. Ce thread maître crée des threads esclaves (threads léger) qui vont exécuter les tâches parallèles lors des sections parallèles.
Les threads exécutent des tâches correspondant à un ensemble d'instructions.
Lors de l'exécution d'un thread esclave, la mémoire est partagée entre les threads. Chaque thread possède sa propre pile d'exécution et ses propres variables locales appelé variable privée. Les variables globales sont partagées entre les threads.
Le programme contient une alternance de séquences séquentielles et de séquences parallèles. Les séquences séquentielles sont toujours exécutées par le thread maître et les séquences parallèles sont exécutées par les threads esclaves.

Le partage de travail peut consister à :

• Exécuter une boucle en parallèle
• Exécuter une section de code en parallèle, c'est-à-dire que chaque thread exécute une partie du code en même temps
• Exécuter une procédure en parallèle, c'est-à-dire que chaque thread exécute la même procédure en même temps

Contrairement à MPI, la communication dans OpenMP est implicite, la gestion des communications sont gérées par le compilateur.

Création de threads

Les threads sont affectés aux processeurs par le système d'exploitation. Le nombre de threads est défini par la variable d'environnement OMP_NUM_THREADS. Si cette variable n'est pas définie, le nombre de threads est égal au nombre de processus disponibles.
Trois cas peuvent se présenter :

• Le meilleur cas : le nombre de threads est égal au nombre de processus disponibles
• Le pire cas : le nombre de threads est exécuté en séquentielle sur un seul processeur
• Le cas moyen (le plus fréquent) : la situation est intermédiaire entre les deux cas précédents, c'est-à-dire que le nombre de threads est supérieur au nombre de processeurs disponibles mais en gardant un nombre de threads raisonnable.
  Lors de l'entrée dans une région parallèle, le thread maître crée des threads esclaves via la fonction fork(). Lors de la sortie de la région parallèle, les threads esclaves sont détruits via la fonction join().

Directives et clauses de compilation

Les directives de compilation sont des instructions qui permettent de définir les parties du code qui seront exécutées en parallèle. Les clauses permettent de définir les variables partagées et privées.
Les variables peuvent être définies comme privées ou partagées. Les variables privées sont définies par la clause private et les variables partagées sont définies par la clause shared. Par défaut, toutes les variables sont partagées. Si une variable est définie comme privée, chaque thread possède sa propre copie de la variable. Pour que les variables privées soient initialisées, il faut utiliser la clause firstprivate. La clause lastprivate permet de récupérer la valeur de la variable privée à la fin de la région parallèle.
Ces directives doivent être placé par le développeur, elles ne sont pas générées automatiquement par le compilateur.

La syntaxe dépend du langage utilisé, par exemple :

• C : #pragma omp
• C++ : #pragma omp
• Fortran : !$OMP

Lors de la compilation, il faut ajouter l'option -fopenmp pour activer OpenMP.

Exemples de directives

On peut définir une portion de code dans une région parallèle avec la directive single. Cette directive permet de définir une portion de code qui sera exécutée par un seul thread. Cette directive est utile pour les sections critiques. De la même manière MASTER permet de définir une portion de code qui sera exécutée par le thread maître.
La directive BARREER permet de définir une barrière de synchronisation. Cette directive permet de s'assurer que tous les threads ont terminé leur tâche avant de continuer l'exécution du programme.
La directive ATOMIC et CRITICAL permettent de définir une portion de code qui sera exécutée de manière atomique, c'est à dire que cette portion de code ne sera pas interrompue par un autre thread. Cette directive est utile pour les sections critiques.
OpenMP propose aussi des directives pour simplifier la parallélisation des boucles comme FOR, DO, etc.

Sources

Liens des sources :
https://fr.wikipedia.org/wiki/OpenMP
https://doc.lagout.org/programmation/unix/Programmation%20Parallele%20et%20Distribuee%20OpenMP.pdf
https://dept-info.labri.fr/ENSEIGNEMENT/pmc/transparents/openmp.pdf