Gestionnaire de travaux : SLURM

par redouane bouchouirbat
Annonces, Documentation | Pas de commentaire

SLURM (Simple Linux Utility for Ressource Management) est un gestionnaire de ressources de calcul sous linux, capable de gérer deux à des  milliers de serveurs et des centaines de clusters de plusieurs nœuds à la fois. Qui plus est SLURM est un système d'ordonnancement de tâches très puissant. ( pour plus de détails http://slurm.schedmd.com/).

Toutefois, pour un usage rapide de slurm, la page suivante décrit une base suffisante pour lancer ses premiers travaux.

Utilisation simple :

Tout d'abord vérifier votre connexion à la nouvelle plate forme, sinon demander un compte sur PlaFRIM.

Slurm est accessible sur la nouvelle Plate forme, il est installé sous forme module (voir MODULES).

Une fois connecter sur un des devels (devel11 à devel13), charger le module slurm :

module load slurm

Soumission d'un travail sur PlaFRIM :

Les travaux de calcul peuvent être soumis selon deux modes, en mode interactive ou en mode batch (via un script de soumission ) :

  • Mode interactive :

Méthode 1 :

Demander tout d'abord des ressources (nombre de nœuds/cores, durée d'exécution ... etc), par exemple taper la commande suivante :

$ salloc  -N2 -t 00:30:00 
salloc: Granted job allocation 7397

Pour voir l'état du travail, on utilise la commande squeue :

$ squeue 7397
JOBID PARTITION NAME USER      ST TIME NODES   NODELIST(REASON)
7397     defq   bash      bouchoui R   1:05      2    miriel[007-008]

Remarque :

  • queue peut donner plus d'info avec des options choisies au besoin, exemple :

$squeue -o "%.18i %.9P %.8j %.8u %.2t %.10M %.6D %.3C %.20R"
JOBID PARTITION NAME USER    ST TIME NODES CPUS NODELIST(REASON)
11411  defq       bash    bouchoui R  0:33    2    25       miriel[004-005]

  • Pour plus d'informations sur le travail lancé, utiliser la commande scontrol show job <JobId>.  (un man scontrol pour avoir plus de détails sur cette commande)

Signification de l'entête de la commande squeue :

JOBID l'identifiant du travail soumis
PARTTION la file d'attente sous laquelle tourne le travail, pour voir les partitions disponibles utiliser la commande sinfo
NAME le nom du travail, qu'on peut modifié par -J <nom_du_job>
USER l'utilisateur qui a lancé le travail
ST l'état du travail, exemples : PENDING (PD), RUNING(R), FAILED(F), COMPLETED, ... etc.
TIME le temps écoulé depuis l'exécution du travail, qui ne doit pas dépasser le WALLTIME demandé ou celui de la partition fixé par défaut.
NODE le nombre de nœuds alloués.
NODELIST la liste des nœuds alloués.

 

Il y a un format compact pour chaque état d'un travail :

  • PD (pending) : le travail est en attente,
  • R (running) : le travail a eu les ressources demandées,
  • CA (cancelled) : le travail a été détruit par l'utilisateur ou l'administrateur du cluster,
  • CF (configuring) : le travail est soumis avec succès et attend que tous les nœuds soient disponibles (ex : redémarrage du nœud),
  • CG (completing) : le travail est terminé et attend la libération des ressources (terminaison de tous les processus),
  • CD (completed) : le travail est terminé,
  • F (failed) : le travail est en échec,
  • TO (timeout) : le travail a dépassé la durée demandée,
  • NF (node failure) : un ou plusieurs nœuds alloués ne  répondent pas.

 

Le travail 7397 est en mode running (R), il utilise deux nœuds, miriel007 et miriel008, tourne sous la partition defq (la file d'attente par défaut).

Ensuite sur le même shell taper la commande srun <votre commande> ( tout les commandes seront exécuté sur les ressources allouées ).

$ srun hostname
miriel007
miriel008

ou tout simplement se connecter au nœud alloué en utilisant ssh, cependant les variables d'environnement slum ne sont plus reconnus.

$ssh miriel007

Pour exécuter des commandes sur l'ensemble des ressources allouées, il faut utiliser le jobid associé.

@miriel007~$ srun --jobid=7397 hostname
miriel007
miriel008

Méthode 2 :

Lancer la session interactive depuis un des devels (devel11 par exemple)

$hostname
devel11
$ srun -N1 - -exclusive - -time=30:00 - -pty bash -i
$hostname
miriel006

Cette commande permet d'exécuter un shell en interactif sur un nœud et sous la partition defq, en donnant accès aux ressources demandées.

NB : Pour avoir le portage graphique, il faut rajouter l'option "--x11=[batch|first|all|last]", cela va activer le plugin du portage graphique X11 sur les nœuds alloués .

  • Mode Batch :

$ cat script-slurm.sh
#!/usr/bin/env bash
#Job name
#SBATCH -J TEST_Slurm
# Asking for one node
#SBATCH -N 1
# Output results message
#SBATCH -o slurm.sh%j.out
# Output error message
#SBATCH -e slurm.sh%j.err
module purge
module load slurm/14.03.0
echo "=====my job informations ==== "echo "Node List: " $SLURM_NODELIST
echo "my jobID: " $SLURM_JOB_ID
echo "Partition: " $SLURM_JOB_PARTITION
echo "submit directory:" $SLURM_SUBMIT_DIR
echo "submit host:" $SLURM_SUBMIT_HOST
echo "In the directory: `pwd`"
echo "As the user: `whoami`"

Soumettre le travail avec la commande sbatch,  sbatch <script_à_soumettre>

         $sbatch script-slurm.sh

Submitted batch job 7421

des infos sur les travaux en cours

$squeue

et pour avoir plus d'informations

$scontrol show job <jobid>

pour supprimer un travail en cours

$scancel <jobid>

Voir la sortie du job soumis  7421

$cat slurm.sh7421.out

=====my job informations ====

Node List: miriel003

my jobID: 7449

Partition: defq

submit directory: /home/bouchoui/Tests

submit host: devel12

In the directory: /home/bouchoui/Tests

As the user: bouchoui

Historique des travaux :

La commande sacct permet d'afficher l'historique,  les détails des travaux terminés, leurs étapes, leur état de terminaison et les ressources consommées ( partition, nombre de cpus, mémoire consommé, ... etc),  enregistré dans la base de données de SLURM.

Pour afficher l'historique des travaux soumis pendant une période écoulée, il faut préciser la date de début (avec l'option -S ou --starttime)  et la date  de fin ( avec l'option -E ou --endtime ), et pour afficher l'historique d'un seul travail, utiliser  seulement le numéro du travail, sacct -j <jobid>.

exemple :

sacct -j 7397
JobID JobName Partition Account AllocCPUS State ExitCode
------------ ---------- ---------- ---------- ---------- ---------- --------
7397 bash defq 48 COMPLETED 0:0
7397.0 hostname 2 COMPLETED 0:0

Pour filtrer les travaux avec un état particulier, utiliser l'option -s (ou --state ), pour une période donnée  (exemple  du 10 septembre 2015  au 12 septembre 2015 ) :

sacct -S 09/10 -E 09/12 -s timeout
JobID JobName Partition Account AllocCPUS State ExitCode
------------ ---------- ---------- ---------- ---------- ---------- --------
13584 bash defq sed-bdx 1 TIMEOUT 0:1
13619 bash defq sed-bdx 12 TIMEOUT 0:1

On peut rajouter un format d'affichage, pour n'afficher que les champs qui nous intéressent, à l'aide de l'option --format.

exemple :

sacct -s completed
--format=jobid,jobname,partition,maxvmsize,maxvmsizenode,
avevmsize,averss,avecpu,ntasks,alloccpus,elapsed,state,exitcode,submit,end
-S 09/10 -E 09/15

un man sacct pour plus de détails.

Terminaison des travaux par SLURM (Epilogue)

Un script, est mis en place, qui se déclenche immédiatement après la terminaison du travail, pour détruire tous les processus, de l'utilisateur, sur les nœuds qu'ont été alloués pour ce même travail.  Qui plus est ce script actionne trois tâches en même temps :

  • Le nettoyage des travaux terminés  et ses sous-processus qui tournent encore sur le nœud,
  • La terminaison des applications qui continuent à s'exécuter sur le nœud sans être gérer par SLURM (en dehors d'une réservation).
  • Le nettoyage du /tmp des répertoires temporaires et les fichiers associés, de l'utilisateur, créés par le travail.

Utilisation Avancée :

Applications parallèles (mpi) :

Lancer une application parallèle sur la plate forme sous slurm dépendra de l’implémentation MPI utilisée et de la bibliothèque MPI qui gère les communications entre les processeurs (voir  http://slurm.schedmd.com/mpi_guide.html).

Voici un exemple d'utilisation des bibliothèques MPI les plus utilisées sur la plate forme PlaFRIM (Open MPI, Intel MPI, MVAPICH2).

OpenMPI :

Vous devez tout d'abord charger l'un des modules OpenMPI dans votre environnement en respectant les dépendances :

module avail mpi/openmpi

mpi/openmpi/gcc/1.10.0-tm mpi/openmpi/gcc/1.8.1 mpi/openmpi/gcc/1.8.5-tm

mpi/openmpi/gcc/1.10.0-tm-mlx mpi/openmpi/gcc/1.8.4-tm mpi/openmpi/gcc/1.8.6-tm

Chargement du module openmpi.1.8.5

module load mpi/openmpi/gcc/1.8.5-tm

Le  travail se lance avec la commande mpirun.

$ salloc  -n 3              # demande des ressources : trois tâches mpi

> mpirun ./a.out       # lancer le code sur les 3 tâches

exit                         #  pour terminer le travail et libérer les ressources.

 

Remaque : Sur les nœuds sirocco, mistral il faut charger la bibliothèque openmpi du module mpi/openmpi/gcc/1.10.0-tm-mlx pour utiliser l'infiniband.

  • compilation du code :

mpicc -o a.out  programme.c

 

  • exécution du code :

mpirun --mca btl openib,self ./a.out

ces commandes fonctionnent aussi dans le mode batch.

Intel MPI :

Vous devez tout d'abord charger l'un des modules Intel MPI dans votre environnement en respectant les dépendances  .

Les modules à charger  : compilateur intel, compilateur gnu-gcc, intel-mpi.

Exemple :

module load compiler/gcc/4.9.0
module add compiler/intel/64/2015.3.187
module add mpi/intel-mpi

Lancement avec mpiexec.hydra :

  • Création du fichier mpd.hosts, qui contient les nœuds alloués pour le job.

 srun hostname  -s| sort -u > mpd.hosts

  • Lancement de l'application :

 export I_MPI_FABRICS=shm:tmi

mpiexec.hydra -f mpd.hosts -n $SLURM_NPROCS ./a.out

Lancement avec srun (Utilisation de SLURM) :

  • Lancement de l'application :

export I_MPI_PMI_LIBRARY=/cm/shared/apps/slurm/14.03.0/lib64/libpmi.so
export I_MPI_FABRICS=shm:tmi

srun -n $SLURM_NPROCS  ./a.out

NB : $SLURM_NPROCS désigne le nombre de tâches mpi.

MVAPICH2 :

Choisir l'environnement d'exécution du code parallèle à utiliser, pour utiliser MVAPICH2 , charger le module en respectant les dépendances.

Les jobs sous MVAPICH2 peuvent être lancer directement avec la commande srun, par contre il faut rajouter pendant l'édition de lien la bibliothèque pmi.so de SLURM :

mpicc -L/cm/shared/apps/slurm/14.03.0/lib64 -lpmi ...
srun -n 4 ./a.out

Application hybride ( mpi + openmp )

  • Utilisation d'un code MPI + OMP :

$cat hMPI_OMP.f90

Program hello

use omp_lib

IMPLICIT NONE

include 'mpif.h'

integer np,rank,ierr,rc,len

character*(MPI_MAX_PROCESSOR_NAME) name

integer tid,size_thread

!Initialize the MPI library

call MPI_INIT(ierr)

if(ierr.ne.MPI_SUCCESS) then

print*,'Error starting program. Terminating ...'

call MPI_ABORT(MPI_COMM_WORLD,rc,ierr)

end if

!number of cpus

call MPI_COMM_SIZE(MPI_COMM_WORLD,np,ierr)

!rank of cpu

call MPI_COMM_RANK(MPI_COMM_WORLD, rank, ierr)

!Get the name of each cpu

call MPI_GET_PROCESSOR_NAME(name,len,ierr)

if(ierr.ne.MPI_SUCCESS) then

print*,'Error getting processor name. Terminating ...'

call MPI_ABORT(MPI_COMM_WORLD,rc,ierr)

end if

print "('hMPI_OMP.f90: Number of tasks = ',I3,' My rank=',I3,' My name =',A,'')",&

np,rank, trim(name)

!$OMP PARALLEL PRIVATE(tid)

tid=OMP_GET_THREAD_NUM()

size_thread=OMP_GET_NUM_THREADS()

write(*,*)'from :',trim(name),'rak:',rank,', my tid is ',tid,' i have ',size_thread,'sisters'

!$OMP END PARALLEL

! Tell to the MPI library to release all ressources it is using :

call MPI_FINALIZE(ierr)

end program hello

  • Utilisation du mpi+openmp avec slurm en interactive :

$ module list

Currently Loaded Modulefiles:

1) slurm/14.03.0 2) compiler/gcc/4.9.0 3) mpi/mvapich2/gcc/64/2.0b

compilation avec mpif90

$mpif90 -fopenmp hMPI_OMP.f90 -L/cm/shared/apps/slurm/current/lib64 -lpmi -o a.out

demander  deux nœuds sur la partition defq, pour lancer le travail :

$salloc -N2 -n 2 -c 4

Sur chaque taĉhe MPI, on utilise quatres processus openmp  (il y a deux tâches MPI)

$export OMP_NUM_THREADS=4

$ srun -n 2 --mpi=none ./a.out

ou en interactive :

srun -N2 -n 2  -c 4 -E "OMP_NUM_THREADS=4" --mpi=none ./a.out

hMPI_OMP.f90: Number of tasks = 2 My rank= 0 My name =miriel061

hMPI_OMP.f90: Number of tasks = 2 My rank= 1 My name =miriel062

from :miriel061rak: 0 , my tid is 0 i have 4 sisters

from :miriel062rak: 1 , my tid is 0 i have 4 sisters

from :miriel061rak: 0 , my tid is 3 i have 4 sisters

from :miriel062rak: 1 , my tid is 3 i have 4 sisters

from :miriel061rak: 0 , my tid is 2 i have 4 sisters

from :miriel062rak: 1 , my tid is 2 i have 4 sisters

from :miriel061rak: 0 , my tid is 1 i have 4 sisters

from :miriel062rak: 1 , my tid is 1 i have 4 sisters

  • Utilistation d'un script pour lancer le travail :

$cat testMpi.sh

#!/bin/sh

#BATCH --job-name=OMPItest

#SBATCH -o batch%j.out

#SBATCH -e batch%j.err

#SBATCH --time=00:00:20

#SBATCH --exclusive

#SBATCH -N 2-2

#SBATCH -n 2

#SBATCH -c 4

module load slurm/14.03.0  compiler/gcc/4.9.0 mpi/mvapich2/gcc/64/2.0b

echo "Liste des nœuds alloués : "$SLURM_JOB_NODELIST

echo "=========="

$export OMP_NUM_THREADS=4

srun -n 2 --mpi=none ./a.out

Tableau de travaux ( Array of Jobs  )

Travaux itératifs (staged jobs)

Analyse de performance et débogage

Réservation des ressources

NB : (Passage de Torque à SLURM ) Pour l'ensemble des utilisateurs de la plate forme PlaFRIM ayant pris l'habitude de travailler avec Torque, nous mettons à leur disposition ce document qui permet le passage de Torque à Slurm (Ce document permet de prendre en main les différentes fonctionnalités d'un ordonnanceur au regard de l'usage fait de l'autre). Qui plus est, le plafrim-support pourra répondre à toute question liée à SLURM ou tout autre problème technique lié à la plate forme.

Sur la même thématique