Environnements logiciels

$ module load oneapi/
You can load modules for a product belonging to oneAPI 2025.
       module avail now lists oneAPI 2025 modules

$ module avail 
----------------------------- /softs/x86/oneapi/2025.3/modulefiles -----------------------------
2025.3/advisor   2025.3/ishmem  2025.3/ccl  2025.3/dev-utilities           
2025.3/dnnl      2025.3/mkl     2025.3/compiler-intel-llvm                 
2025.3/mpi       2025.3/dpct    2025.3/compiler-rt  2025.3/dpl                
2025.3/tbbt      2025.3/dpl     2025.3/compiler     2025.3/umf     
2025.3/dal       2025.3/vtune   2025.3/debugger            
2025.3/intel_ippcp_intel64      2025.3/intel_ipp_intel64 
 

Pour simplifier la configuration de l’environnement, Kairos propose des toolchains sur architecture x86. Il s’agit de méta-modules qui chargent un ensemble cohérent de compilateurs et de bibliothèques, validés pour fonctionner correctement ensemble. 

1- GCC Toolchain
 Inclut les compilateurs GCC,  OpenMPI, and OpenBLAS

$ module purge 
$ module load toolchain/gcc14.1
Loading toolchain/gcc14.1
 Loading requirement: binutils/2.46 gcc/14.1 openmpi/gcc/4.1.6-gcc14.1
   openblas/0.3.31-gcc14.1
$ module list 
Currently Loaded Modulefiles:
1) binutils/2.46   3) openmpi/gcc/4.1.6-gcc14.1   5) toolchain/gcc14.1  
2) gcc/14.1        4) openblas/0.3.31-gcc14.1    
 

2- oneAPI Toolchain 
Inclut les compilateurs Intel oneAPI (icx, ifx, icpc), Intel MPI (mpicc, mpirun), Intel MKL (Math Kernel Library) ainsi que des outils de performance (VTune, Advisor).

$ module purge 
$ module load toolchain/oneapi2025.3
You can load modules for a product belonging to oneAPI 2025.
        module avail now lists oneAPI 2025 modules
Loading toolchain/oneapi2025.3
 Loading requirement: oneapi/2025.3 2025.3/tbb/latest 2025.3/compiler-rt/latest
   2025.3/umf/latest 2025.3/compiler/latest 2025.3/mpi/latest 2025.3/mkl/latest
   2025.3/vtune/latest 2025.3/advisor/latest
$ module list 
Currently Loaded Modulefiles:
1) oneapi/2025.3               6) 2025.3/mpi/latest       
2) 2025.3/tbb/latest           7) 2025.3/mkl/latest       
3) 2025.3/compiler-rt/latest   8) 2025.3/vtune/latest     
4) 2025.3/umf/latest           9) 2025.3/advisor/latest   
5) 2025.3/compiler/latest     10) toolchain/oneapi2025.3  
 

Le module NVHPC peut être utilisé pour la plupart des applications s’exécutant sur GPU.
Il existe plusieurs versions de NVHPC accessibles via 

module load nvidia

 Les modules mises à jour en continu avec de nouvelles versions.

NVHPC inclut à la fois OpenMPI et HPC-X. Il existe de nombreux sous-modules pour chaque version.

Voici une description des différences entre ces modules, indépendamment de la version :

• nvhpc (Base) :
  Compilateurs NVIDIA (nvc, nvc++, nvfortran), CUDA Toolkit,
  bibliothèques mathématiques GPU (cuBLAS, cuFFT, etc.) et OpenMPI.

• nvhpc-nompi :
  Identique à la version de base NVHPC mais sans implémentation MPI.
  À utiliser si vous fournissez votre propre module MPI.

• nvhpc-hpcx :
  NVHPC avec HPC-X MPI de NVIDIA (support UCX, HCOLL, NCCL),
  avec intégration CUDA par défaut.

• nvhpc-hpcx-cudaXX :
  Identique à nvhpc-hpcx mais compilé avec une version spécifique de CUDA.

• nvhpc-byo-compiler (Bring Your Own Compiler) :
  Fournit les bibliothèques NVIDIA (NCCL, NVSHMEM, bibliothèques mathématiques)
  sans les compilateurs NVIDIA ni MPI. Conçu pour une utilisation avec GCC/Clang.

• nvhpc-hpcx-2.20-cudaXX :
  Version figée de HPC-X 2.20 + CUDA pour des environnements reproductibles
  et des workflows scientifiques stables.

Pour les applications nécessitant BLAS et LAPACK, vous pouvez désormais utiliser les bibliothèques NVIDIA Performance Libraries (NVPL) à la place d’OpenBLAS.

Ces bibliothèques sont configurées automatiquement via le module. Vous pouvez afficher les informations correspondantes avec la commande module show, ce qui vous permettra notamment de voir le répertoire dans lequel se trouvent toutes les bibliothèques.

En plus de NVHPC, il existe plusieurs versions d’OpenMPI disponibles.

On peut distinguer quatre types d’OpenMPI :

openmpi/gcc_cpu :
OpenMPI compilé avec GCC, fonctionnant uniquement sur CPU (notamment sur les CPU Grace Hopper),
avec un support pouvant aller jusqu’à 288 processus par nœud. Il est optimisé uniquement pour le CPU.

openmpi/gcc_gpu :
OpenMPI compilé avec GCC, prenant en charge à la fois le CPU et l’exécution sur GPU (CUDA-aware).

openmpi/nvidia_cpu :
OpenMPI compilé avec les compilateurs NVHPC, fonctionnant uniquement sur CPU.

openmpi/nvidia_gpu :
OpenMPI compilé avec les compilateurs NVHPC, prenant en charge à la fois le CPU et les GPU.

Plusieurs versions de GCC sont installées, ainsi qu'OpenMPI compilé avec ces différentes versions, et OpenMPI Bull. 
En plus un module toolchain, qui charge GCC et l'OpenMPI correspondant :

#!/bin/bash
#SBATCH --job-name=compile
#SBATCH --partition=shared-cpu 
#SBATCH --nodes=1
#SBATCH --ntasks=64
#SBATCH --cpus-per-task=1
#SBATCH --time=00:30:00

module purge
module load toolchain/gcc14.1  # charge gcc/14 + l'OpenMPI associé

# Des flags optionnel 
# -march=graniterapids est possible et préféré mais nécessite GCC 14+ 
# -g pour Debugger 
# -fopt-info-vec Rapport vectoriel

# compilation (sans openmp, sans MPI) ( pour C, C++, fortran)   
gcc      -O3 -march=native prog.c   -o prog 
g++      -O3 -march=native prog.cpp -o prog
gfortran -O3 -march=native prog.f90 -o prog

# compilation (Avec openmp, sans MPI) ( pour C, C++, fortran)   
gcc      -O3 -march=native -fopenmp prog.c -o prog
g++      -O3 -march=native -fopenmp prog.cpp -o prog
gfortran -O3 -march=native -fopenmp prog.f90 -o prog

# compilation (sans openmp, Avec MPI) ( pour C, C++, fortran) 
mpicc   -O3 -march=native prog.c   -o prog
mpicxx  -O3 -march=native prog.cpp -o prog
mpifort -O3 -march=native prog.f90 -o prog


# compilation hybride (Avec openmp, Avec MPI) ( pour C, C++, fortran) 
mpicc   -O3 -march=native -fopenmp prog.c -o prog
mpicxx  -O3 -march=native -fopenmp prog.cpp -o prog
mpifort -O3 -march=native -fopenmp prog.f90 -o prog



#si vous avez #SBATCH --cpus-per-task=64 
#export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}
export OMP_NUM_THREADS=num_threads 
export OMP_PLACES=cores
export OMP_PROC_BIND=close

srun ./prog

Version complète Intel (avec IntelMPI)

Versions 2024 et 2025 disponibles. Le module toolchain charge oneAPI et tous les modules nécessaires, y compris IntelMPI 

Si vous utilisez intel 2018, il faut considérer changes les suivant: 
CC= icc -> icx 
CPP = icpc -> icpx 
FC = ifort -> ifx  

#!/bin/bash
#SBATCH --job-name=compile
#SBATCH --partition=shared-cpu 
#SBATCH --nodes=1
#SBATCH --ntasks=64
#SBATCH --cpus-per-task=1
#SBATCH --time=00:30:00

module purge
module load toolchain/oneapi2025.3 

# Des flags optionnel 
# -xGRANITERAPIDS est possible et préféré mais nécessite GCC 14+ 
# -g pour Debugger 

# compilation (sans openmp, sans MPI) ( pour C, C++, fortran)   
icx  -O3 -xHost prog.c   -o prog
icpx -O3 -xHost prog.cpp -o prog
ifx  -O3 -xHost prog.f90 -o prog

# compilation (Avec openmp, sans MPI) ( pour C, C++, fortran)   
icx  -O3 -xHost -qopenmp prog.c    -o prog
icpx -O3 -xHost -qopenmp prog.cpp  -o prog
ifx  -O3 -xHost -qopenmp prog.f90  -o prog


# compilation (sans openmp, Avec MPI) ( pour C, C++, fortran) 
mpiicx  -O3 -xHost  prog.c    -o prog
mpiicpx -O3 -xHost  prog.cpp  -o prog
mpiifx  -O3 -xHost  prog.f90  -o prog


# compilation hybride (Avec openmp, Avec MPI) ( pour C, C++, fortran) 
mpiicx  -O3 -xHost -qopenmp  prog.c    -o prog
mpiicpx -O3 -xHost -qopenmp  prog.cpp  -o prog
mpiifx  -O3 -xHost -qopenmp  prog.f90  -o prog


srun ./prog

OpenMPI avec compilateur Intel (sans IntelMPI)

OpenMPI (et aussi OpenMPI Bull) est aussi disponible compilé avec le compilateur Intel.
Dans ce cas, les wrappers standards mpicc/mpicxx/mpifort encapsulent icx/icpx/ifx 
Les commandes précédentes restent valables, la seule différence étant que nous utilisons le MPI d'OpenMP au lieu du MPI d'Intel.

# compilation (sans openmp, Avec MPI) ( pour C, C++, fortran) 
mpicc   -O3 -xHost  prog.c    -o prog
mpicxx  -O3 -xHost  prog.cpp  -o prog
mpifort -O3 -xHost  prog.f90  -o prog

# compilation hybride (Avec openmp, Avec MPI) ( pour C, C++, fortran) 
mpicc   -O3 -xHost -qopenmp  prog.c    -o prog
mpicxx  -O3 -xHost -qopenmp  prog.cpp  -o prog
mpifort -O3 -xHost -qopenmp  prog.f90  -o prog
 

Si votre code utilise OpenACC, il est conseillé d'utiliser l'un des modules suivants :

1- nvhpc : le plus général (avec MPI intégré)
2- openmpi/nvidia_gpu : il possède toutes les fonctionnalités de nvhpc, à l'exception de MPI, qui est une version compilée d'OpenMPI
3- openmpibull/nvhpc : il fonctionne de la même manière que openmpi/nvidia_gpu

Flags (NVHPC)

Optimisation               -O3 -tp=neoverse-v2
OpenMP (CPU)               -mp
OpenMP offload (GPU)       -mp=gpu -gpu=cc90
OpenACC                    -acc -gpu=cc90
Mémoire unifiée            -gpu=cc90,mem:unified
Mémoire managée            -gpu=cc90,mem:managed
CUDA Fortran               -cuda -gpu=cc90
Rapports GPU               -Minfo=accel (ACC) / -Minfo=mp (OMP)

Note: srun fonctionne avec seulement nvhpc-hpcx si vous utilisez nvhpc/version il faut appeler mpirun  

#!/bin/bash
#SBATCH --partition=shared-gpu
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=72
#SBATCH --time=00:30:00

module purge
# load nvhpc-hpcx/vesion
module load  nvhpc-hpcx/26.1 
#-tp=neoverse-v2    Cible le CPU Grace (recommandé)

# CPU uniquement 
# Compilation série CPU 
nvc       -O3 -tp=neoverse-v2 prog.c   -o prog
nvc++     -O3 -tp=neoverse-v2 prog.cpp -o prog
nvfortran -O3 -tp=neoverse-v2 prog.f90 -o prog

# Compilation OpenMP (CPU)
nvc       -O3 -tp=neoverse-v2 -mp prog.c   -o prog
nvc++     -O3 -tp=neoverse-v2 -mp prog.cpp -o prog
nvfortran -O3 -tp=neoverse-v2 -mp prog.f90 -o prog


# Compilation MPI (OpenMPI intégré au HPC SDK) CPU 
mpicc   -O3 -tp=neoverse-v2 prog.c   -o prog
mpicxx  -O3 -tp=neoverse-v2 prog.cpp -o prog
mpifort -O3 -tp=neoverse-v2 prog.f90 -o prog

# GPU 
OpenMP offload (GPU)
nvc -O3 -tp=neoverse-v2 -mp=gpu -gpu=cc90 -Minfo=mp prog.c -o prog

OpenACC
nvc -O3 -tp=neoverse-v2 -acc -gpu=cc90 -Minfo=accel prog.c -o prog
#mémoire unifiée Grace-Hopper
nvc -O3 -tp=neoverse-v2 -acc -gpu=cc90,mem:unified -Minfo=accel prog.c -o prog


export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK}
export OMP_PLACES=cores
export OMP_PROC_BIND=close


srun gbind ./prog

La méthode de compilation suivante s'applique uniquement aux projets utilisant un noyau CUDA.

Vous pouvez utiliser les modules suivants compilé avec gcc:
1- openmpi/gcc gpu
2- openmpi bull/gcc-14.1

Flags (CUDA)
Optimisation                              -O3
Architecture GPU (GH200)      -arch=sm_90
Compilateur hôte (MPI)           -ccbin=mpicxx
Compilateur hôte (sans MPI)   -ccbin=g++
Debug device                            -G -lineinfo
Rapports registre/occup.          -Xptxas -v

#!/bin/bash
#SBATCH --partition=shared-gpu
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=72
#SBATCH --time=00:30:00

module purge
module load openmpi/gcc_gpu  #ou openmpibull/gcc-14.1

#-arch=sm_90    Cible le GPU Hopper (GH200, recommandé)
# CUDA pur (sans MPI)
nvcc -O3 -arch=sm_90 -ccbin=g++ gpu_app.cu -o prog
nvfortran -O3 -tp=neoverse-v2 -cuda -gpu=cc90 gpu_app.cuf -o prog

# CUDA + MPI (hôte compilé avec le wrapper MPI)
nvcc -O3 -arch=sm_90 -ccbin=mpicxx gpu_app.cu -o prog
mpifort -O3 -tp=neoverse-v2 -cuda -gpu=cc90 gpu_app.cuf -o prog

srun gbind ./prog