Pour commencer
Warning
Avant de commencer, assurez-vous d'avoir lu la charte d'utilisation
Introduction à SLURM
SLURM (Simple Linux Utility for Resource Management) est un planificateur de tâches et un gestionnaire de ressources open source pour les clusters Linux. Il est utilisé pour gérer et allouer des ressources telles que le processeur, la mémoire et les GPU pour les tâches soumises par les utilisateurs.
Access au Cluster
Ce guide vous aide à accéder au cluster et à soumettre votre premier travail.
Pour acceder au cluster SLURM, vous devez disposer d'un compte. Si vous n'en avez pas , contatcer votre responsable.
La frontale du cluster (la machine d'accès) est accessible à l'adresse login01.mi.parisdescartes.fr
La connexion au cluster s'effectue par SSH
ssh username@cluster-headnode
Mot de passe.
Votre mot de passe est celui qui vous a été fourni
Transfert de données
Pour le transfert des données il faut utiliser les commandes scp ou rsync.
Les utilisateurs sous Windows peuvent par exemple utiliser le logiciel filezilla ou winscp pour le transfert des données.
Chaque utilisateur dispose d'un espace de données sous /home/login.
Note
Le stockage de données sur le cluster est temporaire, les utilisateurs doivent régulièrement sauvegarder dans leurs laboratoires les données générées sur le cluster.
Spécifications du compte Slurm
Les informations du compte Slurm reposent sur quatre paramètres : « cluster », « utilisateur », « compte » et « partition », qui forment ce que l’on appelle une association.
Selon votre laboratoire ou vos projets scientifiques, vous aurez accès à différentes partitions et comptes.
Les partitions désignent un groupe de nœuds caractérisés par leur entité, et les comptes désignent les projets scientifiques auxquels vous participez. La partition default est accessible à l’ensemble de la communauté.
Vous pouvez consulter les associations de vos utilisateurs avec :
sacctmgr show user $USER withassoc
Les calculs sur le cluster s'effectuent par l'intermédiaire du gestionnaire de travaux Slurm.
Ce dernier gère une file d'attente et lance les travaux soumis sur les serveurs dédiés au calcul lorsque les ressources demandées sont disponibles.
Au lieu d'exécuter directement son programme, l'utilisateur soumet donc des scripts à Slurm. Ces scripts spécifient les ressources demandées - quel(s) machine(s) pour combien de temps? etc - et les commandes à exécuter sur les machines allouées.
Il est donc très important que les ressources demandées soient adéquates pour le code à executer. Tant que les ressources demandées ne sont pas disponibles, le script ne démarrera pas (demander trop est donc inutile, en plus d'être peu respectueux des autres utilisateurs) - et si les ressources sont insuffisantes, alors le code ne pourra pas s'exécuter correctement.
Walltime maximum
Caractéristiques du walltime :
Format : Le walltime est généralement spécifié au format jours-heures:minutes:secondes. Par exemple, 2-12:30:00 signifie 2 jours, 12 heures, 30 minutes et 0 secondes.
Importance : Si un job dépasse le walltime spécifié, SLURM l'arrête automatiquement. Cela permet d'éviter que les jobs ne monopolisent les ressources indéfiniment.
Estimation : Il est important de fournir une estimation réaliste du walltime pour éviter que le job ne soit interrompu prématurément. Cependant, il ne faut pas non plus surestimer excessivement, car cela peut retarder l'allocation des ressources.
Exemple d'utilisation :
Lorsque vous soumettez un job avec sbatch, vous pouvez spécifier le walltime avec l'option --time. Par exemple :
sbatch --time=1-05:00:00 mon_script.sh
Cela signifie que le job a un walltime de 1 jour et 5 heures.
Conseils : Si vous ne connaissez pas la durée exacte, estimez légèrement au-dessus du temps attendu.
Surveillez l'historique des jobs similaires pour ajuster votre estimation.
Si un job est souvent interrompu, augmentez le walltime dans les soumissions futures.
En résumé, le walltime est un paramètre clé pour gérer efficacement les ressources dans un environnement SLURM.
Job interactifs
Dans SLURM, les jobs interactifs permettent d'exécuter des tâches en mode interactif, c'est-à-dire en ayant un accès direct à un shell ou à une interface utilisateur sur un nœud de calcul. Cela est particulièrement utile pour du débogage, du développement, ou pour exécuter des tâches qui nécessitent une interaction en temps réel.
Voici comment exécuter des jobs interactifs dans SLURM :
1. Utiliser srun pour un job interactif simple
La commande srun permet de lancer un job interactif en demandant des ressources spécifiques (comme le nombre de CPU, la mémoire, etc.).
Exemple :
srun --ntasks=1 --cpus-per-task=4 --mem=8G --time=01:00:00 --pty bash
-
--ntasks=1 : Nombre de tâches (ici, 1).
-
--cpus-per-task=4 : Nombre de CPU par tâche.
- --mem=8G : Mémoire allouée (8 Go ici).
- --time=01:00:00 : Durée maximale du job (1 heure ici).
- --pty bash : Ouvre un shell interactif (bash) sur le nœud alloué.
Une fois la commande exécutée, vous serez connecté à un shell sur le nœud de calcul, et vous pourrez exécuter des commandes interactivement.
2. Utiliser salloc pour allouer des ressources et interagir
La commande salloc permet d'allouer des ressources sans lancer immédiatement une tâche. Vous pouvez ensuite exécuter des commandes interactives dans l'environnement alloué.
Exemple :
salloc --ntasks=1 --cpus-per-task=4 --mem=8G --time=01:00:00
Une fois les ressources allouées, vous pouvez ouvrir un shell interactif avec :
srun --pty bash
3. Utiliser srun pour lancer une application interactive
Si vous avez besoin de lancer une application interactive (comme un IDE, un interpréteur Python, etc.), vous pouvez utiliser srun directement.
Exemple pour lancer un interpréteur Python :
srun --ntasks=1 --cpus-per-task=4 --mem=8G --time=01:00:00 --pty python3
4. Options supplémentaires
Vous pouvez ajouter des options pour spécifier des contraintes supplémentaires, comme :
--partition=
--gres=gpu:
--nodelist=
Exemple avec GPU :
srun --ntasks=1 --cpus-per-task=4 --mem=16G --gres=gpu:1 --time=02:00:00 --pty bash
5. Arrêter un job interactif
Pour quitter un job interactif, il suffit de taper exit ou Ctrl+D dans le shell. Les ressources seront libérées automatiquement.
6. Bonnes pratiques
N'oubliez pas de spécifier un --time réaliste pour éviter de monopoliser les ressources inutilement.
Utilisez srun ou salloc en fonction de vos besoins (exécution directe ou allocation préalable).
Si vous avez besoin d'une interface graphique, assurez-vous que votre environnement SLURM est configuré pour le support X11 (avec --x11 ou --export=DISPLAY).
En résumé, les jobs interactifs dans SLURM sont très utiles pour des tâches nécessitant une interaction en temps réel, et les commandes srun et salloc sont les outils principaux pour les gérer.
Soumettre des travaux
La soumission d'un job se fait avec la commande
sbatch job.slurm
où job.slurm est un fichier de script dans lequel sont contenues des instructions pour Slurm ainsi que des instructions pour le lancement de votre programme. Cette commande retourne un numéro de job (JOBID).
Par exemple, le script suivant décrit un job qui reserve un nœud (--nodes=1) pour une durée d'au plus 10 minutes et exécute la commande hostname suivi de la commande sleep 60.
#!/bin/bash
#SBATCH --nodes=1
#SBATCH --time=00:10:00
hostname
sleep 60
Les instructions pour Slurm se trouvent dans l'en-tête dans les lignes commençant par #SBATCH. Ci-dessous vous trouvez les options les plus importantes.
1. Créer un script de job
Un script de job est un fichier texte contenant les directives SLURM et les commandes à exécuter. Voici un exemple de script de job simple :
#!/bin/bash
#SBATCH --job-name=mon_job # Nom du job
#SBATCH --output=mon_job_%j.out # Fichier de sortie (avec l'ID du job)
#SBATCH --error=mon_job_%j.err # Fichier d'erreur (avec l'ID du job)
#SBATCH --ntasks=1 # Nombre de tâches (1 par défaut)
#SBATCH --cpus-per-task=4 # Nombre de CPU par tâche
#SBATCH --mem=8G # Mémoire allouée (8 Go ici)
#SBATCH --time=01:00:00 # Durée maximale du job (1 heure ici)
#SBATCH --partition=defq # Partition (remplacez par votre partition)
# Charger les modules nécessaires (si applicable)
module load python/3.8
# Exécuter la commande ou le script
python3 mon_script.py
2. Soumettre le job avec sbatch
Une fois le script de job créé (par exemple, mon_script_job.sh), vous pouvez le soumettre avec la commande suivante :
sbatch mon_script_job.sh
SLURM retournera l'ID du job soumis, par exemple : Submitted batch job 12345
3. Options courantes de sbatch
Les options peuvent être spécifiées directement dans le script (comme dans l'exemple ci-dessus) ou en ligne de commande avec sbatch. Voici quelques options courantes :
| Option | Description |
|---|---|
--job-name=<nom> |
Nom du job. |
--output=<fichier> |
Fichier de sortie standard (utilisez %j pour inclure l'ID du job). |
--error=<fichier> |
Fichier d'erreur standard (utilisez %j pour inclure l'ID du job). |
--ntasks=<nombre> |
Nombre de tâches (par défaut, 1). |
--cpus-per-task=<n> |
Nombre de CPU par tâche. |
--mem=<taille> |
Mémoire allouée (par exemple, 8G pour 8 Go). |
--time=<durée> |
Durée maximale du job (format jours-heures:minutes:secondes). |
--partition=<nom> |
Partition à utiliser (par exemple, defq, gpu, etc.). |
--gres=gpu:<nombre> |
Demander des GPU (par exemple, --gres=gpu:1 pour 1 GPU). |
--mail-type=<type> |
Recevoir un e-mail à certaines étapes (par exemple, BEGIN, END, FAIL). |
--mail-user=<email> |
Adresse e-mail pour les notifications. |
Exemple en ligne de commande :
sbatch --job-name=mon_job --ntasks=1 --cpus-per-task=4 --mem=8G --time=01:00:00 --output=mon_job_%j.out --error=mon_job_%j.err mon_script_job.sh
- Suivre l'état du job Une fois le job soumis, vous pouvez suivre son état avec les commandes suivantes :
squeue : Affiche la liste des jobs en attente ou en cours d'exécution.
squeue -u $USER
sacct : Affiche les informations sur les jobs terminés ou annulés.
sacct -j <job_id>
- Annuler un job Pour annuler un job, utilisez la commande scancel avec l'ID du job :
scancel <job_id>
6. Exemple complet
Voici un exemple complet de script de job pour exécuter un programme Python avec des ressources spécifiques :
#!/bin/bash
#SBATCH --job-name=python_job
#SBATCH --output=python_job_%j.out
#SBATCH --error=python_job_%j.err
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4
#SBATCH --mem=8G
#SBATCH --time=01:00:00
#SBATCH --partition=defq
# Charger le module Python
module load python/3.8
# Exécuter le script Python
python3 mon_script.py
Soumettez-le avec :
sbatch python_job.sh
7. Bonnes pratiques
Testez vos scripts avec un walltime court avant de soumettre des jobs longs.
Utilisez --output et --error pour capturer les sorties et les erreurs.
Si vous utilisez des modules, assurez-vous qu'ils sont disponibles sur les nœuds de calcul.
Pour les jobs GPU, spécifiez --gres=gpu:
En suivant ces étapes, vous pouvez soumettre et gérer efficacement vos travaux dans SLURM.