Slurm

Le gestionnaire de travaux du cluster Curta 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:
    WIP
    

Exemple de script pour un job séquentiel

#!/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" 

Une fois le script lancé, par exemple avec

sbatch test.slurm

(en supposant que le script ci-dessus soit enregistré dans un fichier test.slurm), un numéro de job s'affichera à l'écran. Tous les affichages écran dûs au script test.slurm seront stockés dans des fichiers de la forme slurm-<jobid>.err (pour stderr) et slurm-<jobid>.out (pour stdout) 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.

Par exemple, pour le script donné en exemple, en supposant que l'ID du job soit 3088, à la fin du job, il y aura deux fichiers : slurm-3088.err et slurm-3088.out.

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 à 120 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 à 30 jours (voir Configuration Scheduler). L'option à utiliser est "--time=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 17280 heures (~ 144 cœurs sur 5 jours, 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 320 cœurs avec 10 nœuds complets:
    sbatch --nodes=10 --tasks-per-node=32 <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 gpu):

sinfo -p gpu

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: Pour l'instant, 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
  • MVAPICH2
  • IntelMPI

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

#! /bin/bash

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

module load mpi/openmpi

mpiexec <monexecutable>

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

Partitionnement du cluster

Le cluster Curta est principalement composé de plusieurs types de serveurs de calcul (voir Présentation-de-la-machine-Curta):
  • les nœuds de calcul classiques (aussi appelés compute): n001 à n336
  • les nœuds dits bigmem: bigmem01 à bigmem04
  • les nœuds visu: visu01 à visu04
  • les nœuds gpu: gpu01 à gpu04
La partition par défaut est la partition compute. Pour lancer un job sur la partition bigmem, il y a plusieurs façons de procéder:
  • demander des ressources sur la partition compute:
    # demande de 4 cœurs sur 1 nœud "compute" 
    #SBATCH --constraint=compute
    
  • demander des ressources ayant "l'étiquette" bigmem:
    # demande de 4 cœurs sur 1 nœud "bigmem" 
    #SBATCH --nodes=1
    #SBATCH --tasks-per-node=4
    #SBATCH --constraint=bigmem
    

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 Curta. 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)