Les variables d’environnement SLURM sont des informations précieuses que SLURM met à disposition à l’intérieur de votre job, vous permettant de rendre vos scripts plus dynamiques. En exploitant judicieusement ces variables, vous écrirez des scripts SLURM plus faciles à déboguer et mieux adaptés aux capacités et à la flexibilité offertes par le cluster !
Avant de parler de celles de SLURM, rappelons ce qu’est une variable d’environnement sous Linux :
C’est une information stockée sous forme de NOM=valeur accessible par les programmes et les scripts.
Elle définit des aspects de l’environnement dans lequel un processus s’exécute (ex: qui indique où chercher les commandes, $PATH votre répertoire personnel, $HOME votre nom d’utilisateur).$USER
Dans un script shell (comme Bash), on accède à la valeur d’une variable en la préfixant avec un dollar $, par exemple : echo $USER.
Lorsque vous soumettez un job via sbatch, SLURM prépare un environnement spécifique pour l’exécution de votre script sur le(s) nœud(s) de calcul. Dans cet environnement, SLURM définit automatiquement de nombreuses variables qui contiennent des informations cruciales sur le job lui-même : son ID, les ressources allouées, sur quels nœuds il tourne, etc.
Utiliser ces variables permet à votre script de :
S’adapter aux ressources qui lui ont été réellement allouées.
Créer des fichiers de sortie uniques pour chaque job ou tâche.
Obtenir des informations de contexte pour le logging ou le débogage.
Faciliter la programmation parallèle (MPI, OpenMP).
Gérer les Job Arrays efficacement.
C’est très simple ! Comme pour n’importe quelle variable d’environnement sous Linux, utilisez le $ devant le nom de la variable dans votre script sbatch.
#!/bin/bash #SBATCH --job-name=TestVar #SBATCH --output=var_test_%j.out #SBATCH --time=00:01:00 #SBATCH --nodes=1 #SBATCH --ntasks=1 echo "Bonjour !" # Accès à la variable SLURM_JOB_ID echo "L'ID de ce job SLURM est : $SLURM_JOB_ID" # ou (ancienne notation, fonctionne aussi souvent) : # echo "L'ID de ce job SLURM est : $SLURM_JOBID"
Si vous soumettez ce script (sbatch test_var.sh) et que le job obtient l’ID 12345, le fichier var_test_12345.out contiendra :
Bonjour ! L'ID de ce job SLURM est : 12345
Explorons les variables les plus utiles, regroupées par type d’information.
Ces variables donnent des informations d’identification de base.
SLURM_JOB_ID (ou SLURM_JOBID )Description : L’identifiant numérique unique du job courant.
Use Case Principal : Créer des noms de fichiers uniques (sortie, logs, temporaires) pour éviter les écrasements entre différents jobs ou relances. Essentiel pour le suivi.
#!/bin/bash
#SBATCH --job-name=UniqueWorkdir
#SBATCH --output=job_%j.out
#SBATCH --error=job_%j.err
#SBATCH --time=00:10:00
#SBATCH --nodes=1 --ntasks=1
# IMPORTANT: Adaptez /scratch/users/$USER selon la configuration souhaitée (scratch perso ou de groupe)
SCRATCH_BASE="/scratch/users/$USER" # Ou un autre chemin scratch recommandé
# Créer un répertoire temporaire unique sur l'espace scratch
SCRATCH_JOB_DIR="${SCRATCH_BASE}/job_${SLURM_JOB_ID}"
mkdir -p "$SCRATCH_JOB_DIR"
echo "Répertoire de travail temporaire créé : $SCRATCH_JOB_DIR"
# Se déplacer dans ce répertoire
# L'option '|| exit 1' arrête le script si la commande 'cd' échoue
cd "$SCRATCH_JOB_DIR" || exit 1
# ... Faire le travail ici ...
echo "Calcul en cours dans $(pwd)"
# Simuler la création d'un fichier
touch resultat_temporaire.txt
sleep 5 # Simule du travail
# (Optionnel) Copier les résultats finaux avant de nettoyer
# $SLURM_SUBMIT_DIR est le répertoire où sbatch a été lancé (voir plus bas)
cp resultat_temporaire.txt "$SLURM_SUBMIT_DIR/resultat_final_${SLURM_JOB_ID}.txt"
# Nettoyer (si besoin, attention si plusieurs étapes dépendent de ce dossier)
echo "Nettoyage du répertoire scratch..."
# Revenir au répertoire initial est une bonne pratique avant rm -rf
cd "$SLURM_SUBMIT_DIR"
rm -rf "$SCRATCH_JOB_DIR"
echo "Job terminé."
SLURM_JOB_NAME Description : Le nom du job tel que spécifié par #SBATCH --job-name=… ou par défaut.
Use Case : Logging, messages d’information, comportement conditionnel basé sur le nom du job (plus rare).
#!/bin/bash #SBATCH --job-name=DataAnalysis #SBATCH --output=log_%j.out #SBATCH --time=00:05:00 #SBATCH --nodes=1 --ntasks=1 echo "--- Début du Job ---" echo "Job ID : $SLURM_JOB_ID" echo "Job Name : $SLURM_JOB_NAME" echo "Exécuté sur le noeud : $(hostname)" # Commande Linux standard echo "Date : $(date)" # Commande Linux standard echo "--------------------" # ... Commandes du job ... echo "Analyse des données en cours..." sleep 10 echo "--------------------" echo "Fin du Job $SLURM_JOB_NAME (ID: $SLURM_JOB_ID)" echo "--------------------"
Ces variables indiquent d’où et comment le job a été soumis.
SLURM_SUBMIT_DIR Description : Le répertoire depuis lequel la commande sbatch a été exécutée.
Use Case Principal : Accéder aux fichiers d’entrée qui se trouvent dans le même répertoire que le script, ou copier les fichiers de résultats finaux vers ce répertoire. Très utile !
#!/bin/bash
#SBATCH --job-name=InputOutput
#SBATCH --output=inout_%j.out --error=inout_%j.err
#SBATCH --time=00:05:00
#SBATCH --nodes=1 --ntasks=1
# Utiliser un répertoire de travail temporaire est une bonne pratique
WORK_DIR="/scratch/users/$USER/job_${SLURM_JOB_ID}" # Adapter /scratch/users/$USER
mkdir -p "$WORK_DIR"; cd "$WORK_DIR" || exit 1
# Copier le fichier de configuration depuis le répertoire de soumission ($SLURM_SUBMIT_DIR)
# vers le répertoire de travail courant (.)
echo "Copie de la configuration depuis $SLURM_SUBMIT_DIR"
cp "$SLURM_SUBMIT_DIR/config.txt" ./config_runtime.txt
# Exécuter le programme qui utilise la config locale
echo "Lancement du programme..."
# Supposons que le programme lit 'config_runtime.txt' et écrit 'resultat_job.dat'
# ./mon_programme --config config_runtime.txt --output resultat_job.dat
echo "Résultat simulé" > resultat_job.dat # Simule la création du fichier résultat
sleep 3
# Copier le fichier résultat vers le répertoire de soumission initial
echo "Copie du résultat vers $SLURM_SUBMIT_DIR"
cp resultat_job.dat "$SLURM_SUBMIT_DIR/resultat_final_${SLURM_JOB_ID}.dat"
# Nettoyage
cd "$SLURM_SUBMIT_DIR" # Revenir avant de supprimer
rm -rf "$WORK_DIR"
echo "Job terminé."
SLURM_SUBMIT_HOST Description : Le nom d’hôte de la machine depuis laquelle sbatch a été lancé (souvent le nœud de connexion).
Use Case : Logging, information de traçabilité.
#!/bin/bash #SBATCH --job-name=HostInfo #SBATCH --output=host_%j.log #SBATCH --time=00:01:00 #SBATCH --nodes=1 --ntasks=1 echo "Job $SLURM_JOB_ID ($SLURM_JOB_NAME) démarré." echo "Soumis depuis l'hôte : $SLURM_SUBMIT_HOST" echo "Soumis depuis le répertoire : $SLURM_SUBMIT_DIR" echo "Exécuté sur le nœud : $(hostname)" # hostname est différent de SLURM_SUBMIT_HOST
Ces variables décrivent les ressources que SLURM a allouées à votre job.
SLURM_JOB_NODELIST (ou SLURM_NODELIST )Description : La liste des nœuds alloués au job. Le format peut être compact (ex: node[001-004],node007).
Use Case : Logging, savoir sur quelles machines le job tourne, passer la liste à certains outils parallèles (bien que srun le fasse souvent automatiquement).
#!/bin/bash
#SBATCH --job-name=NodeListJob
#SBATCH --output=nodes_%j.out
#SBATCH --time=00:01:00
#SBATCH --nodes=3 # Demande 3 noeuds
#SBATCH --ntasks-per-node=1 # Une tâche par noeud (total 3 tâches)
# Chaque tâche (lancée par srun implicitement ou explicitement) verra ces variables
echo "[Tâche $SLURM_PROCID] Job $SLURM_JOB_ID lancé."
echo "[Tâche $SLURM_PROCID] Ce job tourne sur les nœuds suivants : $SLURM_JOB_NODELIST"
# Exemple avancé: exécuter une commande sur chaque noeud alloué
# 'scontrol show hostnames' convertit le format compact en liste simple
# Note: Ceci est exécuté par chaque tâche, la tâche 0 suffit souvent.
if [ "$SLURM_PROCID" -eq 0 ]; then
NODES=$(scontrol show hostnames $SLURM_JOB_NODELIST)
echo "[Tâche 0] Liste détaillée des noeuds :"
for NODE in $NODES; do
echo " - $NODE"
# Pour exécuter une commande sur chaque noeud depuis la tâche 0 :
# srun --nodes=1 --ntasks=1 --nodelist=$NODE hostname &
done
# wait # Attendre la fin des srun en arrière-plan
fi
SLURM_NNODES (ou SLURM_JOB_NUM_NODES )Description : Le nombre total de nœuds alloués au job.
Use Case : Vérification, logging, passer à un script ou programme.
#!/bin/bash #SBATCH --job-name=NumNodesCheck #SBATCH --output=numnodes_%j.out #SBATCH --time=00:01:00 #SBATCH --nodes=2 # On demande 2 noeuds #SBATCH --ntasks=2 echo "Job $SLURM_JOB_ID lancé." echo "Nombre de noeuds alloués : $SLURM_NNODES" # Vérifier si on a bien obtenu le nombre de noeuds demandé if [ "$SLURM_NNODES" -ne 2 ]; then echo "ERREUR : Allocation incorrecte, obtenu $SLURM_NNODES noeuds au lieu de 2 !" exit 1 # Arrêter le script en erreur fi echo "Allocation de noeuds correcte." # ... suite du script ...
SLURM_NTASKS (ou SLURM_NPROCS )Description : Le nombre total de tâches (processus) demandées pour le job (--ntasks ou calculé depuis --nodes et --ntasks-per-node).
Use Case : Indispensable pour les jobs MPI (savoir combien de processus lancer), configuration de programmes.
#!/bin/bash #SBATCH --job-name=MpiNtasks #SBATCH --output=mpi_%j.out #SBATCH --nodes=2 #SBATCH --ntasks=16 # Total de 16 processus MPI # IMPORTANT: Charger le module MPI approprié # module load openmpi/4.1.1 # Exemple, adaptez ! echo "Lancement de $SLURM_NTASKS tâches MPI..." # srun utilise SLURM_NTASKS pour savoir combien de processus lancer # et SLURM_NODELIST pour savoir où les lancer. srun ./mon_executable_mpi # Ou si un programme a besoin du nombre en argument : # srun ./autre_executable --num-procs $SLURM_NTASKS
SLURM_CPUS_PER_TASK Description : Le nombre de cœurs CPU alloués par tâche. Défini par --cpus-per-task. Si non défini, vaut 1 par défaut.
Use Case : Essentiel pour les jobs OpenMP ou hybrides afin de définir correctement OMP_NUM_THREADS. Peut aussi servir à configurer des programmes multithreadés.
#!/bin/bash #SBATCH --job-name=OmpCpus #SBATCH --output=omp_%j.out #SBATCH --nodes=1 #SBATCH --ntasks=1 #SBATCH --cpus-per-task=8 # Demande 8 coeurs pour la tâche unique # Définir OMP_NUM_THREADS pour que OpenMP utilise les coeurs alloués # Vérifier d'abord si SLURM_CPUS_PER_TASK est défini (bonne pratique) if [ -n "$SLURM_CPUS_PER_TASK" ]; then export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK else export OMP_NUM_THREADS=1 # Valeur par défaut si non spécifié fi echo "Variable OMP_NUM_THREADS mise à : $OMP_NUM_THREADS" echo "Lancement du code OpenMP..." ./mon_executable_openmp
SLURM_CPUS_ON_NODE Description : Le nombre de cœurs CPU alloués au job sur le nœud courant. Utile si un job tourne sur plusieurs nœuds avec potentiellement des allocations différentes par nœud.
Use Case : Scénarios parallèles complexes, vérification, logging avancé.
#!/bin/bash #SBATCH --job-name=CpusOnNode #SBATCH --output=cpusnode_%j.out #SBATCH --nodes=2 #SBATCH --ntasks-per-node=1 # 1 tâche par noeud #SBATCH --cpus-per-task=4 # 4 coeurs par tâche (donc 4 coeurs alloués sur chaque noeud) # Ce script est exécuté par chaque tâche (une sur chaque noeud) echo "Noeud $(hostname): Tâche $SLURM_PROCID. Coeurs alloués sur ce noeud: $SLURM_CPUS_ON_NODE" # La sortie devrait montrer 4 pour chaque tâche.
Ces variables sont particulièrement utiles dans les jobs parallèles (MPI, ou jobs lancés avec srun avec plus d’une tâche) où chaque tâche peut avoir besoin de connaître son identité.
SLURM_PROCID Description : L’identifiant (rang) unique de la tâche courante au sein du job global. Varie de 0 à $SLURM_NTASKS
Use Case : Programmation MPI (le "rang MPI"), distribution manuelle du travail entre les tâches.
#!/bin/bash
#SBATCH --job-name=ProcIdMaster
#SBATCH --output=procid_%j.out
#SBATCH --nodes=1
#SBATCH --ntasks=4 # Lance 4 tâches
# Chaque tâche exécute ce bloc de code
echo "[Node $(hostname)] Je suis la tâche globale $SLURM_PROCID / $SLURM_NTASKS"
# La tâche 0 fait quelque chose de spécial (ex: initialisation, collecte résultats)
if [ "$SLURM_PROCID" -eq 0 ]; then
echo "[Tâche $SLURM_PROCID] Je suis le maître ! Je prépare le travail."
# Créer un fichier que les autres pourraient lire
echo "Données préparées par le maître" > /tmp/shared_data_${SLURM_JOB_ID}.txt
fi
# Attendre que tous les processus arrivent ici (synchronisation très basique)
# Dans un vrai code MPI, on utiliserait MPI_Barrier()
sleep 2
# Toutes les tâches font leur part du travail
echo "[Tâche $SLURM_PROCID] Je lis les données partagées et je travaille..."
# DATA=$(cat "/tmp/shared_data_${SLURM_JOB_ID}.txt") # Exemple lecture
sleep 5 # Simule le travail
# La tâche 0 collecte les résultats (exemple très simplifié)
if [ "$SLURM_PROCID" -eq 0 ]; then
echo "[Tâche $SLURM_PROCID] Je collecte/vérifie les résultats."
# ... code pour collecter les résultats ...
rm /tmp/shared_data_${SLURM_JOB_ID}.txt # Nettoyage
fi
echo "[Tâche $SLURM_PROCID] Terminé."
SLURM_LOCALID Description : L’identifiant (rang) local de la tâche sur le nœud courant. Varie de 0 à (nombre de tâches sur ce nœud - 1).
Use Case : Utile quand plusieurs tâches tournent sur le même nœud et ont besoin de coordonner des ressources locales (ex: assigner un GPU spécifique à chaque tâche locale).
#!/bin/bash #SBATCH --job-name=LocalGpuAssign #SBATCH --output=localgpu_%j.out #SBATCH --nodes=1 #SBATCH --ntasks=2 # 2 tâches sur le même noeud #SBATCH --cpus-per-task=4 #SBATCH --gres=gpu:h100:2 # Demande 2 GPUs sur le noeud # SLURM alloue les GPUs, mais c'est souvent l'intégration CUDA/MPI # qui définit CUDA_VISIBLE_DEVICES. Cependant, SLURM_LOCALID *peut* être # utilisé pour forcer une correspondance si nécessaire. # ATTENTION : La méthode recommandée est souvent de laisser faire l'intégration # Slurm/CUDA. Cet exemple est illustratif. # L'utilisation de SLURM_LOCALID pour CUDA_VISIBLE_DEVICES est une convention # parfois utilisée, mais pas universelle. export CUDA_VISIBLE_DEVICES=$SLURM_LOCALID echo "Tâche globale $SLURM_PROCID, Tâche locale $SLURM_LOCALID sur $(hostname)" echo "Variable CUDA_VISIBLE_DEVICES (potentiellement) mise à : $CUDA_VISIBLE_DEVICES" # Lancer le programme CUDA (qui n'utilisera que le GPU visible si CUDA_VISIBLE_DEVICES est respecté) echo "Lancement du test GPU pour la tâche $SLURM_PROCID (local $SLURM_LOCALID)" # ./mon_executable_cuda --device $CUDA_VISIBLE_DEVICES # Passe l'ID local au programme si besoin nvidia-smi # Vérifier quel GPU est effectivement utilisé par ce processus
SLURM_NODEID Description : L’indice du nœud courant au sein de l’allocation du job. Varie de 0 à - 1. Utile pour savoir sur quel "numéro" de nœud (parmi ceux alloués) la tâche s’exécute.$SLURM_NNODES
Use Case : Distribution de travail basée sur le nœud, logging, affectation spécifique (ex: nœud 0 fait le master I/O).
#!/bin/bash #SBATCH --job-name=NodeIdRole #SBATCH --output=nodeid_%j_%n.out # %n est l'indice du noeud (SLURM_NODEID) #SBATCH --nodes=3 #SBATCH --ntasks-per-node=1 # Ce script est exécuté sur chaque noeud alloué echo "Info: Tâche $SLURM_PROCID sur hôte $(hostname), ID de Noeud dans l'alloc: $SLURM_NODEID" if [ "$SLURM_NODEID" -eq 0 ]; then echo "Je suis sur le premier noeud de l'allocation ($SLURM_NODEID), je gère les I/O." # ... commandes spécifiques au noeud 0 ... elif [ "$SLURM_NODEID" -eq 1 ]; then echo "Je suis sur le deuxième noeud ($SLURM_NODEID), je fais le calcul principal." # ... commandes spécifiques au noeud 1 ... else echo "Je suis sur un autre noeud ($SLURM_NODEID), je fais un travail secondaire." # ... commandes pour les autres noeuds ... fi
SLURM_TASK_PID Description : Le Process ID (PID) Linux de la tâche courante.
Use Case : Débogage avancé (ex: attacher gdb ou strace), interaction avec d’autres outils Linux qui nécessitent un PID, création de fichiers temporaires très spécifiques (moins courant que $SLURM_JOB_ID).
#!/bin/bash
#SBATCH --job-name=TaskPidLog
#SBATCH --output=taskpid_%j.out
#SBATCH --nodes=1 --ntasks=2
echo "Tâche $SLURM_PROCID: Mon PID Linux est $SLURM_TASK_PID sur $(hostname)"
# Créer un fichier temporaire basé sur le PID (exemple)
TEMP_FILE="/tmp/job_${SLURM_JOB_ID}_task_${SLURM_PROCID}_pid_${SLURM_TASK_PID}.tmp"
echo "Données temporaires" > "$TEMP_FILE"
echo "Tâche $SLURM_PROCID: Fichier temporaire créé : $TEMP_FILE"
# Simuler un travail
sleep 20
# Nettoyer
rm "$TEMP_FILE"
echo "Tâche $SLURM_PROCID: Fichier temporaire supprimé."
Ces variables n’existent que pour les jobs soumis avec l’option --array.
SLURM_ARRAY_JOB_ID Description : L’ID du job "maître" de l’array (le même pour toutes les tâches de l’array). Différent de qui est unique pour chaque tâche individuelle.$SLURM_JOB_ID
Use Case : Créer des répertoires ou fichiers communs pour tout l’array. Nommer les fichiers de sortie avec l’ID global (%A dans #SBATCH --output).
#!/bin/bash
#SBATCH --job-name=ArrayCommonDir
# Utilisation de %A pour l'ID du job array, %a pour l'ID de la tâche
#SBATCH --output=array_output_%A/task_%a.out
#SBATCH --error=array_output_%A/task_%a.err
#SBATCH --array=1-3
#SBATCH --time=0:05:00
# Définir le répertoire commun basé sur l'ID de l'Array Job
ARRAY_DIR="/scratch/users/$USER/array_job_${SLURM_ARRAY_JOB_ID}" # Adapter /scratch
# La première tâche (celle avec l'indice minimum) crée le répertoire
if [ "$SLURM_ARRAY_TASK_ID" -eq "$SLURM_ARRAY_TASK_MIN" ]; then
echo "[Tâche $SLURM_ARRAY_TASK_ID] Création du répertoire commun: $ARRAY_DIR"
mkdir -p "$ARRAY_DIR"
# On pourrait y copier des fichiers communs à toutes les tâches
# cp $SLURM_SUBMIT_DIR/common_data.txt $ARRAY_DIR/
fi
# Attente simple pour s'assurer que le répertoire est créé (pas idéal pour beaucoup de tâches)
# Une meilleure approche utiliserait un fichier 'lock' ou une dépendance
sleep 5
echo "[Tâche $SLURM_ARRAY_TASK_ID] Travail en cours..."
# Chaque tâche peut lire depuis $ARRAY_DIR ou y écrire (attention aux conflits d'écriture!)
# Exemple: lire un fichier commun
# COMMON_DATA=$(cat "$ARRAY_DIR/common_data.txt")
# Exemple: écrire un résultat propre à la tâche
echo "Résultat de la tâche $SLURM_ARRAY_TASK_ID" > "$ARRAY_DIR/result_task_${SLURM_ARRAY_TASK_ID}.txt"
echo "[Tâche $SLURM_ARRAY_TASK_ID] Terminé."
# Le nettoyage pourrait être fait par une tâche dépendante séparée (dependency=afterany:$SLURM_ARRAY_JOB_ID)
# Ou par la dernière tâche :
# if [ "$SLURM_ARRAY_TASK_ID" -eq "$SLURM_ARRAY_TASK_MAX" ]; then
# echo "[Tâche $SLURM_ARRAY_TASK_ID] Nettoyage final..."
# # Attention: s'assurer que toutes les autres tâches ont *vraiment* fini d'écrire!
# # rm -rf "$ARRAY_DIR"
# fi
SLURM_ARRAY_TASK_ID Description : L’indice numérique de la tâche courante au sein de l’array. C’est la variable la plus utilisée dans les job arrays.
Use Case Principal : Sélectionner le fichier d’entrée spécifique, définir un paramètre unique, construire le nom du fichier de sortie pour cette tâche.
Exemple Concret : (Voir l’exemple détaillé du Job Array dans la section 4.2 du cours précédent - il utilise pour construire les noms $SLURM_ARRAY_TASK_ID INPUT_FILE et OUTPUT_FILE).
SLURM_ARRAY_TASK_COUNT Description : Le nombre total de tâches dans l’array.
Use Case : Information, calculs de distribution, logging.
SLURM_ARRAY_TASK_MIN Description : L’indice de la première tâche de l’array.
Use Case : Identifier la première tâche pour effectuer une initialisation (voir exemple ).$SLURM_ARRAY_JOB_ID
SLURM_ARRAY_TASK_MAX Description : L’indice de la dernière tâche de l’array.
Use Case : Identifier la dernière tâche pour effectuer une action finale (ex: agrégation de résultats, nettoyage).
#!/bin/bash #SBATCH --job-name=ArrayInfo #SBATCH --output=array_info_%A_%a.out #SBATCH --array=10-20%3 # Tâches 10 à 20 (11 tâches), 3 simultanées max #SBATCH --time=0:01:00 echo "--- Info Tâche Array ---" echo "Job Array ID : $SLURM_ARRAY_JOB_ID" echo "ID de cette Tâche : $SLURM_ARRAY_TASK_ID" echo "Nombre total tâches: $SLURM_ARRAY_TASK_COUNT" # Devrait être 11 echo "Indice Min Tâche : $SLURM_ARRAY_TASK_MIN" # Devrait être 10 echo "Indice Max Tâche : $SLURM_ARRAY_TASK_MAX" # Devrait être 20 echo "-------------------------" if [ "$SLURM_ARRAY_TASK_ID" -eq "$SLURM_ARRAY_TASK_MIN" ]; then echo "Je suis la première tâche de cet array!" fi if [ "$SLURM_ARRAY_TASK_ID" -eq "$SLURM_ARRAY_TASK_MAX" ]; then echo "Je suis la dernière tâche de cet array!" fi PERCENTAGE=$(echo "scale=2; ($SLURM_ARRAY_TASK_ID - $SLURM_ARRAY_TASK_MIN + 1) * 100 / $SLURM_ARRAY_TASK_COUNT" | bc -l) echo "Progression (approximative) : $PERCENTAGE %"
CUDA_VISIBLE_DEVICES Description : Ce n’est pas strictement une variable définie par SLURM lui-même, mais par l’intégration entre SLURM et CUDA (ou un script de démarrage). Elle indique aux applications CUDA quels GPU physiques (numérotés par le système localement au nœud) elles sont autorisées à utiliser. SLURM s’arrange (via des mécanismes internes comme les cgroups et des scripts hook) pour que chaque tâche ou job ne voie et n’utilise que les GPU qui lui ont été alloués via --gres=gpu….
Use Case : Vérifier quels GPU sont assignés à la tâche courante (pour le log ou le débogage). Les applications CUDA/PyTorch/TensorFlow l’utilisent automatiquement pour ne cibler que ces GPU. Vous n’avez normalement pas à la manipuler directement, sauf cas très spécifiques.
#!/bin/bash #SBATCH --job-name=CheckGpuVisibility #SBATCH --output=gpu_vis_%j.out #SBATCH --nodes=1 #SBATCH --ntasks=1 #SBATCH --gres=gpu:2 # Demande 2 GPUs sur le noeud echo "Tâche $SLURM_PROCID sur $(hostname)" # Vérifier si la variable est définie et afficher sa valeur if [ -z "$CUDA_VISIBLE_DEVICES" ]; then echo "WARNING: La variable CUDA_VISIBLE_DEVICES n'est pas définie !" echo " L'application CUDA risque d'essayer d'utiliser tous les GPUs du noeud." else echo "Mes GPU visibles (indices locaux au noeud) sont : $CUDA_VISIBLE_DEVICES" # La sortie pourrait être "0,1" si les GPUs locaux 0 et 1 ont été assignés. # Ou "2,3" si les GPUs locaux 2 et 3 ont été assignés, etc. # Les applications CUDA sauront interpréter cette liste. fi # Lancer une commande qui utilise CUDA echo "Lancement de nvidia-smi pour voir les GPUs..." nvidia-smi # echo "Lancement de mon application CUDA..." # ./mon_code_cuda
Parfois, vous voulez que votre job ait accès à une variable que vous avez définie avant de lancer sbatch.
sbatch (Héritage par Défaut)Par défaut, la plupart des variables que vous export dans votre session avant de lancer sbatch sont héritées par l’environnement du job. C’est souvent le plus simple.
---- export MON_PARAMETRE="valeur_importante" export SEUIL_ANALYSE=0.05 echo "Variable MON_PARAMETRE positionnée à '$MON_PARAMETRE'" sbatch mon_script.sh ----
---- #!/bin/bash #SBATCH --job-name=InheritVar #SBATCH --output=inherit_%j.out #SBATCH --time=00:01:00
echo "--- Variables Héritées ---" echo "Mon paramètre spécial reçu : '$MON_PARAMETRE'" # Doit afficher valeur_importante echo "Le seuil utilisé sera : $SEUIL_ANALYSE" # Doit afficher 0.05 echo "--------------------------" # Utilisation dans une commande (exemple) # ./mon_programme --seuil $SEUIL_ANALYSE --param "$MON_PARAMETRE" ----
--export=… de sbatchPermet un contrôle fin sur les variables passées. Utile pour la clarté, la reproductibilité ou pour éviter de passer des variables non désirées.
--export=VAR1,VAR2 : Passe uniquement VAR1 et VAR2 (si elles existent dans l’environnement de soumission) + les variables SLURM_.
--export=ALL,VAR1=val1,VAR2=val2 : Passe toutes les variables héritées (comportement par défaut) ET définit/écrase VAR1 et VAR2.
--export=NONE,VAR1=val1 : Ne passe aucune variable héritée, sauf celles définies explicitement (et les SLURM_).
# Définir une variable localement (pas besoin d'export ici)
INPUT_DATA_PATH="/data/set1/input.dat"
THRESHOLD=1e-6
# Soumettre en passant explicitement ces variables, plus la version
sbatch --export=ALL,INPUT_FILE=${INPUT_DATA_PATH},CUTOFF=${THRESHOLD},CODE_VERSION=v3.alpha \
mon_script_export.sh
#!/bin/bash
#SBATCH --job-name=ExportVar
#SBATCH --output=export_%j.out
#SBATCH --time=00:02:00
echo "--- Variables via --export ---"
echo "Fichier d'entrée : $INPUT_FILE" # Doit afficher /data/set1/input.dat
echo "Seuil de coupure : $CUTOFF" # Doit afficher 1e-6
echo "Version du code : $CODE_VERSION" # Doit afficher v3.alpha
# Vérifier si une variable non exportée explicitement est passée (si ALL utilisé)
echo "Variable USER héritée : $USER"
echo "----------------------------"
# ./mon_programme --input "$INPUT_FILE" --cutoff $CUTOFF --version "$CODE_VERSION"
Les variables d’environnement SLURM sont une mine d’informations sur votre job, disponibles dans votre script via la syntaxe .$NOM_VARIABLE
Utilisez-les pour rendre vos scripts dynamiques, robustes et informatifs.
Les plus utiles : , $SLURM_JOB_ID , $SLURM_SUBMIT_DIR , $SLURM_NTASKS , $SLURM_CPUS_PER_TASK .$SLURM_ARRAY_TASK_ID
Bonnes Pratiques :
Utilisez (ou $SLURM_JOB_ID /%{j} dans les options %{A} #SBATCH) pour nommer les fichiers de sortie/log/temporaires de manière unique.
Utilisez pour accéder facilement aux fichiers relatifs à votre soumission ou pour y copier les résultats finaux.$SLURM_SUBMIT_DIR
Utilisez pour configurer $SLURM_CPUS_PER_TASK dans les jobs OpenMP.OMP_NUM_THREADS
Basez la logique des Job Arrays sur .$SLURM_ARRAY_TASK_ID
Pour passer vos propres paramètres, préférez l’option --export de sbatch pour la clarté et la reproductibilité, ou assurez-vous que la variable est exportée avant sbatch.
Vérifiez l’existence d’une variable (if [ -n "$VAR" ]) avant de l’utiliser si elle n’est pas garantie d’être définie dans tous les contextes (ex: variables d’array hors d’un array job).
N’oubliez pas que ces variables n’existent que dans l’environnement d’exécution du job SLURM, pas dans votre session interactive sur le nœud de connexion avant ou après le job.