Poudlard

# Slurm

{{>toc}}

Le gestionnaire de travaux du cluster Poudlard est [Slurm](https://slurm.schedmd.com/overview.html).

## Introduction

On peut trouver une introduction au gestionnaire de travaux Slurm [ici](https://slurm.schedmd.com/quickstart.html).

## Commandes de gestion des jobs

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

```bash

sbatch <jobscript>

```

- Consulter la liste des jobs soumis:

```bash

squeue

```

- Supprimer un job:

```bash

scancel <jobid>

```

- Obtenir des informations sur un job soumis:

```bash

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`

```bash

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

```bash

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:

```bash

#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](https://slurm.schedmd.com/sbatch.html)

**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

```bash

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

```

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

```bash

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

```

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

```bash

sbatch --ntasks=300 <script>

```

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

```bash

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:

```bash

sinfo -p `id -gn`

```

Pour une autre partition (par exemple longq):

```bash

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:

```bash

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:

```bash

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:

```bash

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

```bash

$ sbatch <monscript>

Submitted batch job <jobid>

```

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

```bash

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 :

```bash

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](https://slurm.schedmd.com/job_array.html))