Slurm¶

• Contenu
• Slurm
  • Introduction
  • Commandes de gestion des jobs
  • Exemple de script pour un job séquentiel
  • Demander des ressources
    • Exemples
  • Interroger le système de batchs
    • Connaître les ressources disponibles
    • Evaluer la date de départ d'un job
    • Avoir des informations sur les jobs (actifs, en attente ou bloqués)
  • Lancer des jobs interactifs
  • Lancer des jobs MPI
  • Se connecter quand même aux nœuds pendant un job
  • Utilisation "avancée"
    • Tableau de jobs

Le gestionnaire de travaux du cluster Poudlard est Slurm.

Introduction¶

On peut trouver une introduction au gestionnaire de travaux Slurm ici.

Commandes de gestion des jobs¶

• Lancer un job décrit dans le script <jobscript>

  sbatch <jobscript>
  

• Consulter la liste des jobs soumis:

  squeue
  

• Supprimer un job:

  scancel <jobid>
  

• Obtenir des informations sur un job soumis:

  scontrol show job <jobid>
  ou
  sacct -j <jobid> --format=User%20,JobID%20,Jobname%60,partition,state%20,time,start,end,elapsed,MaxRss,MaxVMSize,ReqMem,nnodes,ncpus,nodelist%60,submit%40,AllocTRES%60
  

Exemple de script pour un job séquentiel¶

• Script test.slurm

#!/bin/bash

#############################
# les directives Slurm vont ici:

# Your job name (displayed by the queue)
#SBATCH -J HelloWorld

# walltime (hh:mm::ss)
#SBATCH -t 00:10:00

# Specify the number of nodes(nodes=) and the number of cores per nodes(tasks-pernode=) to be used
#SBATCH -N 1
#SBATCH --ntasks-per-node=1

# change working directory
#SBATCH --chdir=.

# fin des directives PBS
#############################

# useful informations to print
echo "#############################"
echo "User:" $USER
echo "Date:" `date`
echo "Host:" `hostname`
echo "Directory:" `pwd`
echo "SLURM_JOBID:" $SLURM_JOBID
echo "SLURM_SUBMIT_DIR:" $SLURM_SUBMIT_DIR
echo "SLURM_JOB_NODELIST:" $SLURM_JOB_NODELIST
echo "#############################"

#############################

# What you actually want to launch
echo "Hello World"
sleep 1m # fake to work

# all done
echo "Job finished"

• Soumission du script à l'ordonnanceur

sbatch test.slurm

• Un numéro de job s'affichera à l'écran.

Tous les affichages écran (stderr et stdout) dûs au script test.slurm seront stockés dans un fichier de la forme slurm-< jobid >.out dans le dossier défini par #SBATCH --chdir ., c'est à dire, dans le cas présent, le répertoire courant (".") lors de la soumission du job par sbatch.

Donc, par exemple, en supposant que le script précédent soit soumis et que l'ID du job retourné soit 3088, le fichier généré sera : slurm-3088.out.

Il est possible de séparer les flux de sortie standard (stdout) et d'erreur standard (stdout) dans deux fichiers distincts mais il faudra ajouter dans le script ces deux directives:

#SBATCH -o slurm-%j.out
#SBATCH -e slurm-%j.err

Le symbole %j sera remplacé par l'ID du job.
D'autres directives sont également disponibles. Vous trouverez plus d'informations ici

NB: Afin d'être correctement lues et prises en compte par Slurm, les directives SBATCH ("#SBATCH") doivent impérativement se situer au début du fichier script, avant toute commande de type shell. Dans le cas contraire elles seront ignorées.

Demander des ressources¶

Afin de permettre un fonctionnement normal du gestionnaire de travaux, vous êtes obligés de spécifier les ressources dont vous avez besoin pour votre calcul. Dans le cas où vous omettez de les spécifier, une valeur par défaut est prise.

Les ressources importantes:

• walltime: le nombre d'heures pendant lequel votre calcul est autorisé a tourner. Au delà, le système l'arrêtera (i.e.: le tuera sauvagement).
  • Valeur par défaut: 1 heure.
  • Si vous demandez un walltime supérieur à 48 heures, vous serez dirigé automatiquement dans la file d’attente longq qui présente certaines restrictions.
  • La durée maximale d'un job est fixée à 10 jours (voir Configuration Scheduler).
  • L'option à utiliser est --time=DD-HH:MM:SS.
• nombre de processeurs: votre calcul aura à disposition le nombre de processeurs désigné.
  • Vous pouvez demander un certain nombre de nœuds (défaut: 1) ainsi qu'un certain nombre de processeurs par nœuds (défaut: 1). Ceci se décompose habituellement en 2 options (--nodes=<nnodes> --tasks-per-node=<ppn>).
  • Dans le cas d'un job avec des processus multithreadés, on devra utiliser l'option --cpus-per-task=<nthreads>.
• cputime: il s'agit de la durée CPU cumulée sur tous les processeurs du job (grosso modo walltime * nb cœurs).
  • Il n'est pas possible de spécifier directement cette durée au lancement du job, mais vous ne pouvez pas dépasser 768 heures (voir Configuration Scheduler)

Exemples¶

Il est utile d'ajouter des options à un sbatch si ces options ne sont pas déjà spécifiées dans le script de job <script>, ou bien quand on veut redéfinir leur valeur.

• job séquentiel de 2 heures

sbatch --time=2:00:00 <script>

• job openmp 4 cœurs (sur un seul nœud) de 1 jour

sbatch --time=24:00:00 --ntasks=1 --cpus-per-task=4 <script>

• job parallèle de 300 cœurs (répartis au hasard)

  sbatch --ntasks=300 <script>
  

• job parallèle de 640 cœurs avec 10 nœuds complets:

  sbatch --nodes=10 --tasks-per-node=64 <script>
  

Interroger le système de batchs¶

Connaître les ressources disponibles¶

Pour connaître les nœuds disponibles (idle) dans sa file d'attente de groupe, on peut utiliser la commande:

sinfo -p `id -gn`

Pour une autre partition (par exemple longq):

sinfo -p longq

Cette commande fournit le nombre de nœuds selon leur état:

• idle: libre
• alloc: entièrement alloué
• mix: partiellement alloué
• down: inaccessible
• drain: drainé

Evaluer la date de départ d'un job¶

La commande:

squeue --start [-j <jobid>]

donne des informations utiles sur la date de départ (prévisible) d'un job.

Avoir des informations sur les jobs (actifs, en attente ou bloqués)¶

Jobs en attente classés par priorité décroissante:

squeue --sort=p --state=PENDING

Faire "man squeue" pour plus de détails

Lancer des jobs interactifs¶

On peut avoir besoin d'accéder à une ressource de calcul pour y exécuter des commandes interactivement (cycle développement<->compilation) ou lancer des logiciels qui nécessitent l'intervention de l'utilisateur (debugger, etc...).

Pour avoir une connexion sur un nœud de calcul, il suffit d'utiliser la commande "srun --pty /bin/bash -i" à la place de la commande "sbatch". On se passe alors de script et un shell est ouvert sur la ressource dès qu'elle est allouée. Les entrées-sorties de ce shell sont connectées sur le terminal qui exécute "srun". Les options pour spécifier les ressources du job sont sensiblement les mêmes entre "sbatch et "srun".

Note: Il n'est pas possible de lancer des applications graphiques à partir du nœud de calcul de cette manière.

Lancer des jobs MPI¶

Le cluster dispose de plusieurs implémentations de MPI:

• OpenMPI
• MPICH2 (version Spack)

Pour un simple test, OpenMPI sera le plus simple à mettre en œuvre:

#! /bin/bash

#SBATCH --nodes=2
#SBATCH --tasks-per-node=32

module load openmpi

mpiexec <monexecutable>

Pour des instructions spécifiques aux différentes implémentations, voir Jobs MPI

Se connecter quand même aux nœuds pendant un job¶

La connexion directe sur les nœuds de calcul est interdite dans le cluster Poudlard. Le seul moyen d'accéder aux ressources est de soumettre un job.

Cependant, il peut être souhaitable de disposer d'une connexion aux nœuds de calcul dont on a obtenu la réservation à travers une soumission de job.

Pour ce faire, on peut utiliser la commande srun pour se connecter à l'intérieur du job. En supposant qu'on ai soumis un job batch:

$ sbatch <monscript>
Submitted batch job <jobid>

Il suffit d'utiliser le <jobid> alloué par Slurm pour se connecter sur le nœud correspondant:

srun --pty --jobid <jobid> /bin/bash -i

Utilisation "avancée"¶

Tableau de jobs¶

Il est possible avec une commande sbatch, de lancer un grand nombre de jobs en une seule fois, en utilisant l'argument -a. On peut spécifier le nombre de jobs via une liste d'indexes, exemple :

sbatch -a 1-3 <script>
sbatch -a 1,3,4,5-10 <script>

A l'intérieur du job, Slurm positionne des variables d'environnement qu'on pourra utiliser dans le script pour différentier les différentes instances de job dans le tableau (voir la documentation de Slurm)