Tutorials - Slurm

Utilisation de Slurm sur le Cluster i-Trop

Description	Savoir utiliser Slurm
Auteur	Ndomassi TANDO (ndomassi.tando@ird.fr)
Date de création	08/11/2019
Date de modification	26/01/2021

Sommaire

Objectifs
Lancer des jobs avec Slurm
Supervision des ressources avec Slurm
Liens
License

Objectifs

Savoir lancer différents types de jobs avec Slurm.

Savoir surveiller ses jobs

Lancer des jobs avec Slurm:

Lancer des commandes depuis le master

La commande suivante permet d'allouer les ressources Slurm (noeuds, mémoire, coeurs) et de lancer la commande passée en arguments.

$ srun + command

Exemple:

$ srun hostname

Permet d'obtenir le nom du noeud sur lequel la ressource est reservée.

Se connecter à un noeud en interactif et lancer des commandes:

Pour se connecter à un noeud en intéractif pendant X minutes :

$ srun -p short --time=X:00 --pty bash -i

Les commandes peuvent être ensuite lancées directement sur ce noeud sans taper le préfixe srun

Se connecter à un noeud en interactif avec le support x11:

Le support x11 permet de lancer des applications graphiques depuis un noeud.

Il faut d'abord se connecter à bioinfo-master.ird.fr avec l'option -X:

$ ssh -X login@bioinfo-master.ird.fr

Ensuite lancer la commande suivante avec l'option --x11

$ srun -p short --x11 --pty bash -i

Les partitions disponibles :

Selon le type de jobs(analyses) que vous souhaitez lancer, vous avez le choix entre différentes partitions.

Les partitions sont des files d'attentes d'analyses avec chacune des priorités et des contraintes spécifiques telles que la taille ou le temps limite d'un job, les utilisateurs autorisés à l'utiliser etc...

Les jobs sont classés par priorité et traités grâce aux ressources (CPU et RAM) des l noeuds constituant ces partitions

partition	role	liste des noeuds	Nombre de coeurs	Ram
short	Jobs courts < 1 jour (priorité haute,jobs intéractifs)	node0,node1,node2,node13,node14	12 coeurs	48 à 64 Go
normal	jobs d'une durée de 7 jours maximum	node0,node1,node2,node13,node14,node15,node16,node17,node18,node19,node20,node22,node23,node24	12 à 24 coeurs	64 à 96Go
long	<7 jours< long jobs< 45 jours	node3,node8,node9,node10,node11,node12	12 à 24 coeurs	48 Go
highmem	jobs avec des besoins mémoire	node4, node7,node17,node21	12 à 24 coeurs	144 Go
supermem	jobs avec des besoins mémoire important	node25	40 coeurs	1 To
gpu	Besoins d'analyses sur des coeurs GPU	node26	24 cpus et 8 GPUS coeurs	192 Go

A noter que l'accès à la parttion gpu est restreint, une demande peut être faite ici: request access to gpu

Prinicipales options dans Slurm:

srun or sbatch peuvent être utilisés avec les options suivantes:

actions	Options Slurm	options SGE
Choisir une partition	-p [queue]	-q [queue]
Nombre de noeuds à utiliser	-N [min[-max]]	N/A
Nombre d'instance à lancer	-n [count]	-pe [PE] [count]
Limitation de temps	-t [min] ou -t [days-hh:mm:ss]	-l h_rt=[seconds]
Préciser un fichier de sortie	-o [file_name]	-o [file_name]
Préciser une fichier d'erreur	-e [file_name]	-e [file_name]
Combiner les fichiers STDOUT et STDERR	utiliser -o sans -e	-j yes
Copier l' environnement	--export=[ALL , NONE , variables]
Envoyer un email	--mail-user=[address]	-M [address]
Type de notifications à envoyer	--mail-type=[events]	-V
Nom du job	--job-name=[name]	-N [name]
Relancer le job en cas de problème	--requeue	-r [yes,no]
Préciser le répertoire de travail	--workdir=[dir_name]	-wd [directory]
Fixer la taille de mémoire à réserver	--mem=[mem][M,G,T] ou-mem-per-cpu=[mem][M,G,T]	-l mem_free=[memory][K,M,G]
Lancer avec un Account partticulier	--account=[account]	-A [account]
Nombre d'instance par noeud	--tasks-per-node=[count]	(Fixed allocation_rule in PE)
Nombre de cpu par tâche	--cpus-per-task=[count]	N/A
Dépendance à un job	--depend=[state:job_id]	-hold_jid [job_id , job_name]
Choix d'un noeud	--nodelist=[nodes] ET/OU --exclude=[nodes]	-q [queue]@[node] OR -q
Job arrays	--array=[array_spec]	-t [array_spec]
Date de lancement	--begin=YYYY-MM-DD[THH:MM[:SS]]	-a [YYMMDDhhmm]

Lancer des jobs via un script

Le mode batch permet de lancer une analyse en suivant les étapes définies dans un script.

Slurm permet d'utiliser différents langages de scripts tels que bash, perl ou python.

Slurm alloue ensuite les ressources désirées et lance les analyses sur ces ressources en arrière plan.

Pour être interprété par Slurm, un script doit contenir une entête contenant toutes les options Slurm précédées par le nom clé #BATCH.

Exemple de script Slum:

#!/bin/bash
## Définir le nom du job 
#SBATCH --job-name=test
## Définir le fichier de sortie
#SBATCH --output=res.txt
## Définir le nombre de tâches 
#SBATCH --ntasks=1
## Définir la limite d'exécution
#SBATCH --time=10:00
## Définir 100Mo de mémoire par cpu
#SBATCH --mem-per-cpu=100
sleep 180 #lance une pause de 180s

Pour lancer une analyse à patir d'un script script.sh:

$ sbatch script.sh

Avec script.sh le nom du script à utiliser

Lancer un job array

#!/bin/bash
#SBATCH --partition=short      ### Partition
#SBATCH --job-name=ArrayJob    ### Nom du job
#SBATCH --time=00:10:00        ### temps limite d'execution
#SBATCH --nodes=1              ### Nombre de noeuds
#SBATCH --ntasks=1             ### Nombre de tâches par job array
#SBATCH --array=0-19%4           ### Tableau d'index de 0  à 19 avec 4  jobs lancés à la fois

echo "I am Slurm job ${SLURM_JOB_ID}, array job ${SLURM_ARRAY_JOB_ID}, and array task ${SLURM_ARRAY_TASK_ID}."

Il faut utiliser $SBATCH --arraypour définir la plage

La variable ${SLURM_JOB_ID} précise le job id

${SLURM_ARRAY_JOB_ID}précise l'id du job array

${SLURM_ARRAY_TASK_ID} précise le nombre de tâches job array.

Ce script donne un résultat de ce type:

$ sbatch array.srun
Submitted batch job 20303
$ cat slurm-20303_1.out
I am Slurm job 20305, array job 20303, and array task 1.
$ cat slurm-20303_19.out
I am Slurm job 20323, array job 20303, and array task 19.

lancer un job R

On peut utiliser la même synthaxe que précédemment
Il suffit de lancer son script R avec la commande Rscript + script.R

#!/bin/bash
## Define the job name
#SBATCH --job-name=test
## Define the output file
#SBATCH --output=res.txt
## Define the number of tasks
#SBATCH --ntasks=1
## Define the execution time limit
#SBATCH --time=10:00
## Define 100Mo of memory per cpu
#SBATCH --mem-per-cpu=100
Rscript script.R #launch the R script script.R

Lancer un job avec plusieurs commandes en parallèle en même temps

Utiliser l'option --ntasks et --cpus-per-task

Exemple:

#!/bin/bash

#SBATCH --ntasks=2
#SBATCH --cpu-per-task=2

srun --ntasks=1 sleep 10 & 
srun --ntasks=1 sleep 12 &
wait

Dans cet exemple, on utilise 2 tâches avec 2 cpus alloués par tâche donc 4 cpus sont alloués pour ce job.

Pour chaque tâche, la commandfe sleep est lancée en même temps.

A noter que l'on utilise la commande srun pour lancer une commande parallèlisée et & pour lancer la commande en arrière plan.

Le wait est utile ici pour demander au job d'attendre la fin de chaque commande avant de s'arrêter.

Lancer un job OpenMP :

Un job OpenMP est un job utilisant plusieurs cpus sur le même noeud. Par conséquent, le nombre de noeud sera toujours 1.
Le script suivant fonctionne grâce à un programme compilé avec openMP.

#!/bin/bash
#SBATCH --partition=short   ### Partition
#SBATCH --job-name=HelloOMP ### Job Name
#SBATCH --time=00:10:00     ### WallTime
#SBATCH --nodes=1           ### Number of Nodes
#SBATCH --ntasks-per-node=1 ### Number of tasks (MPI processes)
#SBATCH --cpus-per-task=28  ### Number of threads per task (OMP threads)
#SBATCH --account=hpcrcf    ### Account used for job submission

export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK

./hello_omp

Variables d'environnement:

   SLURM_JOB_ID     ID  du job alloué.
   SLURM_JOB_NAME       Nom du job.
   SLURM_JOB_NODELIST   Liste des noeuds alloués au job.
   SLURM_JOB_NUM_NODES  Nombre des noeuds alloués au job.
   SLURM_NTASKS     Nombre de tâches CPU dans le job.
   SLURM_SUBMIT_DIR  le répertoire depuis lequel a été lancé le job.

Supprimer un job

$ scancel <job_id>

Avec <job_id>: l'ID du job

Monitorer les resources:

Avoir des infos sur les jobs:

$ squeue

Pour rafraichir les infos toutes les 5 secondes

$ squeue -i 5

Infos sur un job en particulier:

$ scontrol show job <job_id>

Avec <job_id>: l'ID du job

Infos sur les jobs d'un utilisateur

$ squeue -u <user>

Avec <user>: le login

Plus d'infos sur jobs:

$ sacct --format=JobID,elapsed,ncpus,ntasks,state,node

Infos sur les ressources utilisées par un job terminé

$ seff <job_id>

Avec <job_id>: le job ID

Rajoutez cette commande à la fin de vos scripts pour avoir plus d'infos.

$ seff $SLURM_JOB_ID

Avoir des infos sur une partition:

$ sinfo

Elle donne des infos sur les parttions et les noeuds

Plus d' informations:

$ scontrol show partitions

scontrol show peut être utilisée avec les noeuds, user, account etc...

Connaitre la limite de temps de chaque partition:

$sinfo -o "%10P %.11L %.11l"

obtenir des infos sur les noeuds

$ sinfo -N -l

Plusieurs états sont possibles:

alloc : les ressources du noeuds sont toutes utilisées
mix : Les ressources sont partiellement utilisées
idle : Pas de job lancé sur le noeud
drain : le noeud finit les jobs reçus et n'en acceptent pas de nouveaux

Plus d' informations :

$ scontrol show nodes

Liens

Cours liés : HPC Trainings

License

The resource material is licensed under the Creative Commons Attribution 4.0 International License (here).

Tutorials – Slurm