---
# System prepended metadata

title: SID OpenMP

---

# SID OpenMP

OpenMP (Open Multi-Processing) est une interface de programmation pour le calcul parallèle sur architecture à mémoire partagée.
Basé sur les mechanisme de mutli-threading.

Ressortir du parallélisme

- GNU/Linux
- Windows
- OS x

- C
- C++
- Fortran

API qui utilise des directives OpenMP, se configure grâce aux variables d'environnement.

## Modèle de programmation : Fork and Join

![](https://i.imgur.com/j9HZU50.png)
    
L'exécution commence sur un unique thread (master thread)
https://i.imgur.com/j9HZU50.png
Directive OpenMP `#pragma omp parallel` qui créer +sieurs threads

Le nombre de thread est contrôlé par : 
- La variable d'environnement `OMP_NUM_THREADS`
- La requête API `omp_set_num_threads()`
- La clause `num_threads()`
- 
Retourne à un thread unique à la fin de la région parralèle avec une barrière pour synchroniser les threads

### Stratégies de parallélisation
#### Stratégie parallèle

![](https://i.imgur.com/qnzUX4L.png)

- Chaque thread possède son propre ID
- Chaque thread possède sa mémoire privée + accès à la mémoire partagée
- Les threads exécutent le même code
- Barrière pour se synchroniser à la fin de la région parallèle
![](https://i.imgur.com/nPowbna.png)


#### Stratégie maitre/esclave
![](https://i.imgur.com/1Usa6Ka.png)

- Les threads exécutent la région parralèle
- Le noeud maître exécute la région `#program omp master`
- Pas de barrière de synchronisation à la fin de la région maître

#### Stratégie critique
![](https://i.imgur.com/DbAq1Kr.png)

- Un seul thread a accès à la zone critique à la fois
- Garantit l'exclusion mutuelle sur la ressource

![](https://i.imgur.com/GYInRFI.png)

#### Stratégie bloquante
![](https://i.imgur.com/4N5lyLs.png)

- Synchronisation globale 
- Attend que tous les processus ont terminés l'exécution du code pour franchir la barrière
![](https://i.imgur.com/eFOLBz4.png)

#### Stratégie boucles parallèles
![](https://i.imgur.com/DyX2hQn.png)

- Exécution des boucles de manière parallèles
- Chaque thread effectue un nombre d'itération précise 
- On peut distribuer les itérations avec la clause `schedule()`

![](https://i.imgur.com/1V3RLNP.png)



### schedule ( t    ype [ , chunk ] )
**Spécifie la politique de partage des itérations**

5 types possibles :

* **static :** Les itérations sont divisées en blocs de chunk
itérations consécutives ; les blocs sont assignés
aux threads en round-robin ; si chunk n’est pas
précisé, des blocs de tailles similaires sont créés,
un par thread

* **dynamic :** Chaque thread demande un bloc de chunk
itérations consécutives dès qu’il n’a pas de travail
(le dernier bloc peut être plus petit) ; si chunk n’est
pas précisé, il vaut 1

* **guided :** Même chose que dynamic mais la taille des blocs
décroît exponentiellement ; si chunk vaut plus que
1, il correspond au nombre minimum d’itérations
dans un chunk (sauf pour le dernier)

* **runtime :** Le choix de la politique est reporté au moment de
l’exécution, par exemple par la variable
d’environnement OMP_SCHEDULE

* **auto :** Le choix de la politique est laissé au compilateur
et/ou au runtime