|
|
# Utiliser une machine OpenMP au LPNHE #
|
|
|
Désormais, toutes les machines de type sous OS récent sont des machines à plusieurs cœurs de calcul, avec mémoire partagée.
|
|
|
# Using OpenMP machine at LPNHE #
|
|
|
Henceforth, every machine under recent OS are multi-core machines, with shared memory.
|
|
|
|
|
|
Par exemple la machine qui supporte les [Phi](PhiAtLpnhe) est une machine :
|
|
|
* avec 16 cœurs physiques avec ses Intel(R) Xeon(R) CPU E5-2630 v3 @ 2.40GHz; dans la pratique, la machine est configurée en [hyperthreading](https://fr.wikipedia.org/wiki/Hyper-Threading), ce qui lui confère deux fois plus de cœurs de calculs logiques soit 32 cœurs (que l'on voit ainsi via `top` ou bien dans le fichier `/proc/cpuinfo`.
|
|
|
* avec 64 GB de mémoire partagée pour tous ces cœurs de calcul
|
|
|
for example, the machine which owns [Phi](PhiAtLpnhe) is a machine :
|
|
|
* with 16 physical cores with its Intel(R) Xeon(R) CPU E5-2630 v3 @ 2.40GHz; in practice, the machine is configured to be in [hyperthreading](https://fr.wikipedia.org/wiki/Hyper-Threading) mode, which gives twice more logical computing cores, i.e. 32 cores (seen using `top` in a shell or in the /proc/cpuinfo` file).
|
|
|
* with 64 GB shared memory for all those computing cores.
|
|
|
|
|
|
Les autres machines du laboratoire sont également OpenMP bien sûr (`lpnatlas`, `lpnui`, etc.).
|
|
|
Other lab machines are also OpenMP of course (`lpnatlas`, `lpnui`, etc.).
|
|
|
|
|
|
## Utiliser et spécifier les ressources en OpenMP ##
|
|
|
## Using and specifying OpenMP resources
|
|
|
To access to those resources, an [OpenMP](http://openmp.org) program is required. One should usefully read project examples : `pi_omp.c` and others.
|
|
|
|
|
|
Pour accéder à ces ressources, une programmation [OpenMP](http://openmp.org) est requise. On consultera utilement les exemples du projet `pi_omp.c` et consorts par exemple.
|
|
|
|
|
|
La compilation d'un programme *OpenMP* nécessite des flags spécifiques (voir les manuels des compilateurs utilisés). Dans le cas d'un programme en `python`, il faut utiliser des librairies adhoc. En tout état de cause, on spécifiera en ligne de commande le nombre de cœurs dont on a besoin ainsi :
|
|
|
Compiling an *OpenMP* code needs specific flags (see manuals of used compiler). For a `python` code, adhoc libraries should be used. Anyway, one will specify in command line how many cores are needed :
|
|
|
```bash
|
|
|
export OMP_NUM_THREADS=4
|
|
|
```
|
|
|
Par ailleurs, pour une machine [NUMA](https://en.wikipedia.org/wiki/Non-uniform_memory_access), qui physiquement possède plusieurs processeurs dont certains accèdent plus vite à certaines partie de la mémoire qu'à d'autre, il peut être utile de préciser une option d'[affinité](https://en.wikipedia.org/wiki/OpenMP#Thread_affinity), demandant ainsi que les process soient exécutés sur des processeurs en particulier (et donc que le *scheduler* ne les balade pas de cœurs en cœurs), ce qui permet aussi de ne pas avoir accès à des données présent dans une mémoire éloignée du processeur d'exécution de la tâche. Par exemple :
|
|
|
Furthermore, for a [NUMA](https://en.wikipedia.org/wiki/Non-uniform_memory_access) machine, which has many differentiated physical cores, each of them accessing more or less quickly to some part of the memory, it can be usefull to precize an [affinity](https://en.wikipedia.org/wiki/OpenMP#Thread_affinity) option, asking that processes are executing on specific cores (thus the *scheduler* does not take them from core to core); that allow also not to have data access located in far memory from the core point of view. For example :
|
|
|
```bash
|
|
|
export KMP_AFFINITY=physical,0
|
|
|
```
|
|
|
On consultera utilement la [documentation Intel](https://software.intel.com/en-us/articles/using-kmp-affinity-to-create-openmp-thread-mapping-to-os-proc-ids) à ce sujet. Pour les Phi, il existe [des arguments supplémentaires](https://cvw.cac.cornell.edu/hybrid/kmpaffinity?AspxAutoDetectCookieSupport=1) (à étudier...)
|
|
|
One should usefully read the [Intel documentation](https://software.intel.com/en-us/articles/using-kmp-affinity-to-create-openmp-thread-mapping-to-os-proc-ids) on that subject. For Phi, it exists [extra arguments](https://cvw.cac.cornell.edu/hybrid/kmpaffinity?AspxAutoDetectCookieSupport=1) (to be studied...)
|
|
|
|
|
|
### Compilation C ###
|
|
|
#### Avec le compilateur GNU ####
|
|
|
Par exemple :
|
|
|
### C compiling
|
|
|
#### With GNU compiler
|
|
|
For example :
|
|
|
```bash
|
|
|
gcc -O3 -lm -fopenmp pi_omp.c
|
|
|
```
|
|
|
#### Avec le compilateur Intel ####
|
|
|
#### With Intel compiler
|
|
|
```bash
|
|
|
icc -m64 -O3 -Wall -fPIC -ipo -msse4.2 -restrict -fargument-noalias-global -qopenmp pi_omp.c
|
|
|
```
|
|
|
### Python ###
|
|
|
*(à compléter...)*
|
|
|
*(to be completed...)*
|
|
|
|
|
|
### Et en shell ? ###
|
|
|
Il est aussi possible d'utiliser les ressources OpenMP d'une machine directement en `shell`. Soit en gérant les process à passer en tâche de fond, à la main. Soit par exemple en utilisant l'outil [`parallel`](http://www.gnu.org/software/parallel/), bien pratique.
|
|
|
### and in shell ?
|
|
|
It's also possible to use OpenMP resources of a machine directly in `shell`. Either managing processes to be in background, by hand. Or, for example, using the [`parallel`](http://www.gnu.org/software/parallel/) tool, very usefull.
|
|
|
|
|
|
Exemples :
|
|
|
En utilisant l'entrée standard de l'outil
|
|
|
Examples :
|
|
|
Using the standard input of the tool :
|
|
|
```bash
|
|
|
ls * | parallel cksum {}
|
|
|
```
|
|
|
ou bien une boucle sur 3 fichiers avec des arguments
|
|
|
or looping over 3 files with arguments
|
|
|
```bash
|
|
|
parallel mon_script fichier{}.txt ::: 0 1 2
|
|
|
```
|
|
|
|
|
|
## OpenMP ou MPI ? ##
|
|
|
Il est aussi possible d'utiliser une machine OpenMP pour faire tourner un code MPI (qui peut le plus peut le moins), i.e. un code fait a priori pour tourner sur un cluster, c'est-à-dire une machine à mémoire distribuée (et non partagée). Il faut alors utiliser l'outil `mpirun` (avec en option le nombre d'occurence de process) pour le lancement du *process* et utiliser `mpicc` pour la compilation :
|
|
|
## OpenMP or MPI ? ##
|
|
|
It's also possbile to use an OpenMP machine to run MPI code (what can do more can do less), i.e. a code built a priori for a cluster, which is a distributed memory machine. Then, one have to use the `mpirun` tool (with, in option, the needed number of process occurences) to run the *process* and use `mpicc` to compile :
|
|
|
|
|
|
### Avec GNU ###
|
|
|
### With GNU
|
|
|
```bash
|
|
|
mpicc -O2 pi_mpi.c # MPI for gcc (see mpicc -showme for args)
|
|
|
time mpirun -np 4 ./a.out
|
|
|
```
|
|
|
|
|
|
### Avec Intel ###
|
|
|
Pour les options, voir sur [open-mpi.org](https://www.open-mpi.org/faq/?category=mpi-apps#override-wrappers-after-v1.0).
|
|
|
### With Intel
|
|
|
For options, see [open-mpi.org](https://www.open-mpi.org/faq/?category=mpi-apps#override-wrappers-after-v1.0).
|
|
|
```bash
|
|
|
export OMPI_CC=icc
|
|
|
mpicc -m64 -O3 -Wall -fPIC -msse4.2 -restrict -fargument-noalias-global pi_mpi.cc
|
|
|
time mpirun -np 4 ./a.out
|
|
|
```
|
|
|
|
|
|
### Autres options de `mpirun` ###
|
|
|
* Option `-f` suivi d'un nom de fichier contenant les noms des machines pouvant accueillir un process MPI
|
|
|
* Option `-host` suivi du nom de la machine
|
|
|
### Other options of `mpirun` ###
|
|
|
* `-f`followed by a filename with machine names which can run a MPI process
|
|
|
* `-host` followed by a machine name
|
|
|
|
|
|
On peut faire également plus compliqué, par exemple :
|
|
|
One can do also more complicated thing, such as :
|
|
|
```bash
|
|
|
mpirun -n 3 -host localhost ./a.out : -n 3 -host mic0 /home/beau/a.out
|
|
|
```
|
|
|
où l'on crée 3 process sur `localhost` et 3 process sur la machine `mic0` en spécifiant à chaque fois où trouver l'exécutable. |
|
|
\ No newline at end of file |
|
|
where 3 processes are created on `localhost` and 3 processes on the `mic0` machine, specifying each time where to find the binary. |
|
|
\ No newline at end of file |