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 :

Option	Signification
`--ntasks`	Nombre de tâches ou processus à lancer
`--cpus-per-task`	Nombre de CPU attribués à chaque tâche
`--nodes`	Nombre de nœuds demandés
`--ntasks-per-node`	Nombre 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 :

Espace	Usage
`$HOME`	Configuration, scripts et petits fichiers
Espace projet	Données partagées et résultats importants
`$SCRATCH`	Fichiers 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

État	Signification
`PD` ou `PENDING`	Le job attend des ressources ou une condition
`R` ou `RUNNING`	Le job est en cours d'exécution
`CG` ou `COMPLETING`	Le job termine ses opérations
`CD` ou `COMPLETED`	Le job s'est terminé correctement
`F` ou `FAILED`	Le job a échoué
`CA` ou `CANCELLED`	Le job a été annulé
`TO` ou `TIMEOUT`	La durée maximale a été atteinte
`OOM`	La 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>

Cluster HPC​

Nœud​

Nœud de connexion​

Nœud de calcul​

Nœud GPU​

Nœud de visualisation​

Job​

Allocation de ressources​

Tâche, CPU et cœur​

Mémoire​

GPU​

Partition​

File d'attente​

Job interactif et job batch​

Job interactif​

Job batch​

Parallélisme​

Modules logiciels​

Espaces de stockage​

Job ID et fichiers de sortie​

États courants d'un job​

Consommation des ressources​

Bonnes pratiques​

Commandes essentielles​

Pour aller plus loin​

Cluster HPC

Nœud

Nœud de connexion

Nœud de calcul

Nœud GPU

Nœud de visualisation

Job

Allocation de ressources

Tâche, CPU et cœur

Mémoire

GPU

Partition

File d'attente

Job interactif et job batch

Job interactif

Job batch

Parallélisme

Modules logiciels

Espaces de stockage

Job ID et fichiers de sortie

États courants d'un job

Consommation des ressources

Bonnes pratiques

Commandes essentielles

Pour aller plus loin