Skip to main content

Notions essentielles du calcul HPC

Avant de lancer votre premier calcul sur eXplor-v2, il est important de comprendre quelques notions essentielles du calcul haute performance (HPC).

Cette page présente les principaux termes utilisés dans la documentation et les commandes que vous rencontrerez sur le centre de calcul.

Pourquoi commencer par ces notions ?

Comprendre le vocabulaire du cluster vous aidera à choisir les ressources adaptées, à rédiger un script SLURM et à interpréter les messages affichés par le système.

Cluster HPC​

Un cluster HPC est un ensemble de machines reliées par un réseau rapide et administrées comme une infrastructure commune.

Il comprend généralement plusieurs types de nœuds :

  • les nœuds de connexion ;
  • les nœuds de calcul ;
  • les nœuds équipés de GPU ;
  • les nœuds de visualisation ;
  • les nœuds ou services associés au stockage.

Les utilisateurs accèdent à l'ensemble de ces ressources par l'intermédiaire de services communs comme SSH, Open OnDemand et SLURM.

Nœud​

Un nœud est une machine appartenant au cluster.

Un nœud possède généralement :

  • un ou plusieurs processeurs ;
  • une quantité définie de mémoire vive ;
  • éventuellement un ou plusieurs GPU ;
  • un système de fichiers local ou partagé ;
  • une connexion au réseau du cluster.

Les nœuds n'ont pas tous le même rôle ni les mêmes caractéristiques.

Nœud de connexion​

Un nœud de connexion est utilisé pour :

  • se connecter au cluster ;
  • préparer et modifier les scripts ;
  • compiler des programmes légers ;
  • charger des modules ;
  • transférer des fichiers ;
  • soumettre et suivre les jobs.
Ne lancez pas de calcul lourd sur un nœud de connexion

Les nœuds de connexion sont partagés entre les utilisateurs. Un calcul important doit être exécuté sur un nœud de calcul par l'intermédiaire de SLURM.

Nœud de calcul​

Un nœud de calcul est une machine sur laquelle SLURM exécute un job.

Vous ne choisissez généralement pas directement un nœud précis. Vous demandez un ensemble de ressources et SLURM affecte un ou plusieurs nœuds disponibles selon les contraintes de votre job.

Nœud GPU​

Un nœud GPU contient un ou plusieurs accélérateurs graphiques utilisables pour certains codes scientifiques, bibliothèques numériques et applications d'intelligence artificielle.

Un GPU ne remplace pas automatiquement un CPU. Le logiciel utilisé doit être capable d'exploiter l'accélérateur et le job doit demander les ressources GPU appropriées.

Nœud de visualisation​

Un nœud de visualisation est destiné aux applications qui nécessitent une interface graphique ou une accélération matérielle pour afficher et analyser des résultats.

Ces nœuds sont généralement utilisés avec TurboVNC, Open OnDemand ou un autre service interactif.

Job​

Un job est une tâche soumise au gestionnaire de ressources. Il peut s'agir :

  • d'un programme scientifique ;
  • d'un script Python ;
  • d'une simulation ;
  • d'un calcul MPI ;
  • d'une étape de prétraitement ou de post-traitement ;
  • d'une session interactive.

Lorsqu'un job est soumis, SLURM lui attribue un identifiant unique appelé Job ID.

Exemple :

sbatch mon-calcul.slurm

Réponse possible :

Submitted batch job 12345

Dans cet exemple, 12345 est le Job ID.

Allocation de ressources​

Une allocation est un ensemble de ressources réservé pour l'exécution d'un job.

Elle peut comprendre :

  • un nombre de tâches ;
  • un nombre de CPU par tâche ;
  • une quantité de mémoire ;
  • un nombre de GPU ;
  • une durée maximale ;
  • une partition particulière.

Exemple de demande de ressources :

srun \
  --ntasks=1 \
  --cpus-per-task=4 \
  --mem=8G \
  --time=00:30:00 \
  --pty bash

Cette commande demande une tâche, quatre CPU, 8 Go de mémoire et une durée maximale de 30 minutes.

Tâche, CPU et cœur​

Une tâche est généralement un processus lancé par SLURM.

Les options suivantes ont des rôles différents :

OptionSignification
--ntasksNombre de tâches ou processus à lancer
--cpus-per-taskNombre de CPU attribués à chaque tâche
--nodesNombre de nœuds demandés
--ntasks-per-nodeNombre de tâches par nœud

Pour un programme séquentiel, on utilise généralement :

#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4

Pour un programme MPI à quatre processus :

#SBATCH --ntasks=4
#SBATCH --cpus-per-task=1

La configuration correcte dépend du mode de parallélisation du logiciel.

Mémoire​

La mémoire est la mémoire vive disponible pour votre job.

Vous pouvez la demander :

#SBATCH --mem=16G

ou par CPU :

#SBATCH --mem-per-cpu=4G

Une demande insuffisante peut provoquer l'arrêt du job pour dépassement de mémoire. Une demande excessive peut augmenter le temps d'attente du job.

Demandez une quantité réaliste de mémoire

Commencez par un test court et consultez la consommation réelle avec sacct avant d'augmenter la demande pour une campagne complète.

GPU​

Un GPU est un accélérateur spécialisé. Il est utile uniquement si le logiciel et le calcul peuvent l'exploiter.

Exemple de demande d'un GPU :

#SBATCH --gres=gpu:1

Les options exactes et les types de GPU disponibles doivent être vérifiés dans la documentation d'eXplor-v2 et avec :

sinfo
scontrol show partition

Partition​

Une partition est un groupe de nœuds partageant des caractéristiques ou une politique d'accès commune.

Une partition peut être associée à :

  • des nœuds CPU ;
  • des nœuds GPU ;
  • des nœuds de visualisation ;
  • une durée maximale particulière ;
  • une priorité ou une limite spécifique ;
  • un type d'utilisation particulier.

Consultez les partitions disponibles avec :

sinfo

Pour obtenir davantage de détails :

scontrol show partition
Choisissez une partition adaptée

Ne choisissez pas une partition uniquement parce qu'elle semble disponible. Vérifiez qu'elle correspond au type de ressources demandé et aux règles d'utilisation du calcul.

File d'attente​

Lorsqu'un job ne peut pas démarrer immédiatement, il est placé dans une file d'attente.

Un job peut attendre parce que :

  • les ressources demandées sont occupées ;
  • la partition est complète ;
  • une limite de projet est atteinte ;
  • une dépendance n'est pas encore satisfaite ;
  • la demande de ressources est trop importante pour les créneaux disponibles ;
  • une réservation ou une priorité particulière s'applique.

Consultez vos jobs avec :

squeue -u "$USER"

La raison de l'attente peut être affichée avec :

squeue -u "$USER" -o "%.18i %.9P %.30j %.8u %.2t %.10M %.6D %R"

Job interactif et job batch​

Job interactif​

Un job interactif ouvre une session sur un nœud de calcul. Il est utile pour :

  • tester une commande ;
  • déboguer un programme ;
  • vérifier un environnement ;
  • lancer une application interactive ;
  • préparer un calcul avant une soumission batch.

Exemple :

srun \
  --ntasks=1 \
  --cpus-per-task=4 \
  --mem=8G \
  --time=00:30:00 \
  --pty bash

Job batch​

Un job batch est défini dans un script et soumis à SLURM. Il est adapté aux calculs reproductibles et aux exécutions longues.

Exemple minimal :

#!/bin/bash
#SBATCH --job-name=test
#SBATCH --output=test-%j.out
#SBATCH --error=test-%j.err
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4
#SBATCH --mem=8G
#SBATCH --time=00:10:00

set -euo pipefail

module purge
module load <logiciel>/<version>

srun <commande>

Soumission :

sbatch test.slurm

Parallélisme​

Un programme parallèle utilise plusieurs ressources en même temps.

Les principaux modèles sont :

  • parallélisme de tâches : plusieurs tâches indépendantes ;
  • MPI : plusieurs processus qui communiquent entre eux ;
  • OpenMP : plusieurs threads au sein d'un processus ;
  • GPU : calcul délégué à un ou plusieurs accélérateurs ;
  • hybride : combinaison de MPI, OpenMP et GPU.

Le nombre de ressources demandé doit correspondre au modèle de parallélisme du programme.

Exemple MPI :

srun --ntasks=4 ./mon_programme_mpi

Exemple OpenMP :

export OMP_NUM_THREADS="$SLURM_CPUS_PER_TASK"
srun --ntasks=1 --cpus-per-task=8 ./mon_programme_openmp

Modules logiciels​

Un module configure l'environnement nécessaire à l'utilisation d'un logiciel.

Commandes principales :

module avail
module spider <logiciel>
module load <logiciel>/<version>
module list
module show <logiciel>/<version>
module purge

Exemple :

module purge
module load freefem/4.14

Les modules peuvent modifier PATH, LD_LIBRARY_PATH, LIBRARY_PATH, CPATH et d'autres variables d'environnement.

Espaces de stockage​

Les espaces de stockage ont des objectifs différents :

EspaceUsage
$HOMEConfiguration, scripts et petits fichiers
Espace projetDonnées partagées et résultats importants
$SCRATCHFichiers temporaires et calculs intensifs

Sur eXplor-v2 :

  • $HOME est limité à 30 Go par utilisateur et bénéficie d'une sauvegarde ;
  • l'espace projet dispose d'un quota en To, extensible jusqu'à 10 To sur demande justifiée ;
  • $SCRATCH n'a pas de quota individuel, mais les fichiers sont soumis à une rétention de trois mois et à un nettoyage automatique.
danger

Le scratch n'est pas un espace d'archivage

Copiez les résultats importants vers un espace projet ou un stockage adapté avant la fin de leur période de rétention.

Job ID et fichiers de sortie​

Chaque job possède un identifiant unique.

Pour consulter un job en cours :

squeue -j <jobid>

Pour consulter un job terminé :

sacct -j <jobid>

Les fichiers de sortie sont définis dans le script avec :

#SBATCH --output=job-%j.out
#SBATCH --error=job-%j.err

%j est remplacé par le Job ID.

États courants d'un job​

ÉtatSignification
PD ou PENDINGLe job attend des ressources ou une condition
R ou RUNNINGLe job est en cours d'exécution
CG ou COMPLETINGLe job termine ses opérations
CD ou COMPLETEDLe job s'est terminé correctement
F ou FAILEDLe job a échoué
CA ou CANCELLEDLe job a été annulé
TO ou TIMEOUTLa durée maximale a été atteinte
OOMLa mémoire demandée a été dépassée

Pour connaître la raison d'une attente :

squeue -j <jobid> -o "%.18i %.2t %R"

Consommation des ressources​

Après l'exécution, analysez la consommation réelle :

sacct -j <jobid> --format=JobID,State,Elapsed,AllocTRES,MaxRSS,TotalCPU

Cette information permet d'ajuster les demandes suivantes :

  • temps d'exécution ;
  • nombre de CPU ;
  • mémoire ;
  • nombre de GPU ;
  • nombre de nœuds.

Bonnes pratiques​

  • Commencez par un petit test.
  • Demandez uniquement les ressources nécessaires.
  • Utilisez la partition correspondant à votre calcul.
  • Définissez explicitement les modules dans vos scripts.
  • Utilisez set -euo pipefail dans les scripts Bash lorsque cela est approprié.
  • Utilisez $SCRATCH pour les fichiers temporaires.
  • Copiez les résultats importants vers l'espace projet.
  • Conservez les logs et les scripts avec vos résultats.
  • Analysez la consommation réelle avec sacct.
  • N'exécutez pas de calcul lourd sur un nœud de connexion.

Commandes essentielles​

# Voir les partitions et les nœuds
sinfo

# Voir ses jobs
squeue -u "$USER"

# Soumettre un script
sbatch mon-job.slurm

# Demander une allocation interactive

salloc  --partition=std --ntasks=1 --cpus-per-task=2 --mem=4G --time=00:15:00 srun --pty bash

# Consulter un job
scontrol show job <jobid>

# Consulter la consommation d'un job terminé
sacct -j <jobid>

# Annuler un job
scancel <jobid>

Pour aller plus loin​