CUDA et GPU

Les GPU d'eXplor-v2 accélèrent les applications compatibles avec CUDA, notamment pour l'intelligence artificielle, le calcul scientifique, le traitement d'images et certaines applications de visualisation.

Un GPU n'est utilisable que dans une allocation Slurm qui réserve explicitement cette ressource. Avant une campagne de production, validez toujours votre environnement CUDA et votre application dans une session interactive GPU.

Ne pas utiliser de GPU sur le nœud de connexion

N'exécutez pas de calcul GPU sur un nœud de connexion. Les commandes CUDA, les tests et les calculs doivent être effectués sur un nœud GPU attribué par Slurm.

GPU disponibles

Les nœuds GPU d'eXplor-v2 sont hétérogènes. Les modèles disponibles comprennent :

Nœuds	GPU	GPU par nœud	Mémoire GPU par carte	Usage indicatif
gpua[01-02]	NVIDIA Quadro RTX 6000 Ada	2	24 GB	Calcul GPU général, traitement d'images et visualisation
gpub01	NVIDIA L40	4	48 GB	Calcul accéléré et applications professionnelles
gpuc[01-13]	NVIDIA RTX 6000 Pro BSE	2	96 GB	Applications nécessitant une grande mémoire GPU
gpud[01-03]	NVIDIA H200	2	141 GB	Calcul intensif et apprentissage automatique à grande échelle
visu[01-02]	NVIDIA L4	1	24 GB	Visualisation distante et applications graphiques

La disponibilité effective dépend de la partition, du projet, des quotas et de la charge du cluster. Consultez Ressources de calcul pour l'inventaire matériel détaillé.

Conditions d'utilisation

Pour exécuter une application GPU, vous devez :

1. demander une allocation sur la partition gpu ;
2. réserver le nombre de GPU nécessaire ;
3. charger l'environnement logiciel compatible ;
4. vérifier le GPU attribué ;
5. confirmer que l'application utilise réellement l'accélérateur.

La présence de nvidia-smi ou la visibilité d'un GPU ne garantit pas que votre programme exploite effectivement CUDA.

Tester un environnement GPU

Avant de soumettre un job batch, démarrez une allocation interactive GPU pour vérifier le matériel, CUDA et l'application.

salloc \
  --partition=gpu \
  --ntasks=1 \
  --cpus-per-task=4 \
  --mem=16G \
  --gres=gpu:1 \
  --time=01:00:00

srun --pty bash

Une fois dans l'allocation, vérifiez le nœud et les GPU :

hostname
nvidia-smi
nvidia-smi --query-gpu=index,name,memory.total,driver_version --format=csv

Vérifiez également les variables définies par Slurm :

echo "Job ID: $SLURM_JOB_ID"
echo "Nœuds: $SLURM_JOB_NODELIST"
echo "GPU visibles: ${CUDA_VISIBLE_DEVICES:-non défini}"

Un seul GPU visible peut être normal

Même si le nœud possède plusieurs GPU, Slurm peut rendre visibles uniquement les GPU réservés par votre job. Cette isolation est normale et permet de partager un nœud entre plusieurs jobs lorsque la configuration l'autorise.

Utiliser les modules CUDA

Recherchez les versions disponibles :

module spider cuda
module avail 2>&1 | grep -i cuda

Chargez une version compatible avec votre application :

module purge
module load nom_module_cuda
module list

Vérifiez le compilateur CUDA :

which nvcc
nvcc --version

Le module CUDA sélectionne généralement une boîte à outils incluant nvcc, des bibliothèques CUDA et des variables comme CUDA_HOME ou CUDA_PATH.

Pour inspecter le module :

module show nom_module_cuda

Compatibilité pilote et CUDA

La boîte à outils CUDA chargée, le pilote NVIDIA installé sur le nœud GPU et les bibliothèques utilisées par votre application doivent être compatibles. Ne choisissez pas une version CUDA au hasard : suivez les prérequis du logiciel et validez l'environnement dans une allocation interactive.

Compiler un programme CUDA

Exemple minimal dans un fichier bonjour-cuda.cu :

#include <cstdio>

__global__ void hello_gpu() {
    printf("Bonjour depuis le GPU.\n");
}

int main() {
    hello_gpu<<<1, 1>>>();
    cudaDeviceSynchronize();
    return 0;
}

Après avoir chargé un module CUDA :

nvcc -O3 -o bonjour-cuda bonjour-cuda.cu

Exécutez le programme dans une allocation GPU :

./bonjour-cuda

Pour compiler un projet plus complexe, utilisez de préférence un système de construction comme CMake, Make ou Meson et documentez les modules, options de compilation et versions utilisés.

Exécuter un programme CUDA avec Slurm

Une fois l'environnement validé, préparez un script batch pour le calcul de production.

#!/bin/bash
#SBATCH --job-name=calcul-cuda
#SBATCH --partition=gpu
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4
#SBATCH --mem=16G
#SBATCH --gres=gpu:1
#SBATCH --time=02:00:00
#SBATCH --output=logs/%x-%j.out
#SBATCH --error=logs/%x-%j.err

set -euo pipefail

mkdir -p logs

module purge
module load nom_module_cuda
module load nom_module_application
module list

nvidia-smi
./mon-programme-cuda arguments

Demander plusieurs GPU

Vous pouvez réserver plusieurs GPU lorsque l'application est conçue pour les utiliser, par exemple avec un entraînement distribué, du parallélisme de données, une simulation multi-GPU ou un traitement capable de répartir sa charge entre plusieurs accélérateurs.

Le nombre maximal de GPU demandables dépend du type de nœud attribué. Reportez-vous au tableau GPU disponibles :

• les nœuds gpua, gpuc et gpud disposent de 2 GPU par nœud ;
• le nœud gpub01 dispose de 4 GPU ;
• les nœuds visu disposent d'un seul GPU et sont destinés à la visualisation, pas au calcul de production général.

Choisissez le nombre de GPU selon les besoins réels du logiciel et la nature du travail. Un programme qui n'est pas multi-GPU ne bénéficiera généralement pas de GPU supplémentaires.

Exemple de demande de deux GPU sur un même nœud :

#SBATCH --partition=gpu
#SBATCH --gres=gpu:2
#SBATCH --cpus-per-task=8
#SBATCH --mem=32G

Pour exploiter plusieurs GPU, adaptez également :

• le nombre de CPU, afin d'alimenter correctement les accélérateurs ;
• la mémoire RAM, en fonction des données et des processus associés ;
• la durée demandée ;
• les paramètres de parallélisme propres à l'application.

Ne demandez pas plus de GPU que nécessaire

La demande de plusieurs GPU peut augmenter le temps d'attente et immobilise des ressources rares. Testez d'abord le programme sur un GPU, puis vérifiez qu'il obtient un gain réel avec plusieurs GPU avant une campagne de production.

Vérifiez dans les logs et avec nvidia-smi que tous les GPU attribués sont visibles et utilisés par l'application.

Python et GPU

Les bibliothèques Python comme PyTorch, JAX, TensorFlow et CuPy peuvent exploiter CUDA si la version installée est compatible avec l'environnement GPU.

Test simple :

python -c "import sys; print(sys.version)"

Avec PyTorch :

python -c "import torch; print(torch.__version__); print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'GPU indisponible')"

Avec JAX :

python -c "import jax; print(jax.devices())"

Avec CuPy :

python -c "import cupy; print(cupy.cuda.runtime.getDeviceCount())"

Consultez Python et Conda pour créer un environnement Python isolé et reproductible.

Mémoire GPU

La mémoire GPU est distincte de la mémoire RAM du nœud. Une application peut disposer de suffisamment de RAM tout en échouant parce que la mémoire GPU est insuffisante.

Surveillez la mémoire GPU avec :

nvidia-smi

Pour une mise à jour régulière :

watch -n 2 nvidia-smi

Réduisez la taille des lots, la résolution, le nombre de données chargées simultanément ou la précision numérique si l'application dépasse la mémoire GPU disponible.

Bonnes pratiques

• Testez l'environnement dans une allocation interactive GPU avant une production batch.
• Demandez uniquement le nombre de GPU réellement utilisé par le programme.
• Choisissez un GPU dont la mémoire vidéo est adaptée au volume de données.
• Chargez explicitement les modules CUDA et logiciels dans chaque script Slurm.
• Vérifiez nvidia-smi dans les logs des calculs importants.
• Vérifiez la compatibilité entre pilote, CUDA et bibliothèque applicative.
• Ne mélangez pas plusieurs versions CUDA ou plusieurs piles logicielles incompatibles.
• Utilisez un environnement Python isolé ou un conteneur pour les dépendances complexes.
• Documentez le modèle GPU, les versions de CUDA et du logiciel, ainsi que les ressources demandées.
• Utilisez la partition visu pour la visualisation interactive et la partition gpu pour les calculs GPU, sauf consigne contraire du centre.

Dépannage

nvidia-smi ne fonctionne pas

Vérifiez que vous êtes sur un nœud GPU attribué par Slurm :

hostname
scontrol show job "$SLURM_JOB_ID"

Vérifiez que le job a bien réservé un GPU et que vous n'êtes pas sur un nœud de connexion.

nvcc: command not found

Le module CUDA n'est probablement pas chargé :

module spider cuda
module load nom_module_cuda
which nvcc

Le GPU n'est pas détecté par Python

Vérifiez :

• le GPU attribué avec nvidia-smi ;
• l'environnement Python actif avec which python ;
• la version du framework ;
• la compatibilité CUDA et pilote ;
• les modules chargés avec module list.

Erreur de mémoire GPU

Réduisez la mémoire utilisée par l'application ou utilisez un modèle GPU disposant de davantage de mémoire, si les règles du centre permettent de le sélectionner.

Le job reste en attente

Les ressources GPU peuvent être très demandées. Vérifiez la raison d'attente :

squeue -j identifiant_job -o "%.18i %.9P %.20j %.8T %.10M %.10l %.6D %R"

Réduisez, si cela est approprié, la durée, la mémoire, le nombre de CPU ou le nombre de GPU demandés.

Pages associées

• Logiciels et environnements
• Modules
• Environnements logiciels
• Compilateurs et MPI
• Python et Conda
• Apptainer
• Ressources de calcul
• Ressources et partitions Slurm
• Jobs interactifs
• Jobs batch