Utilisation du cluster et de SLURM

Un cluster est un regroupement de machines dédiées au calcul. Il est composé d'une machine frontale ("porte d'entrée" du cluster) et de plusieurs machines de calcul, appelées nœuds, et éventuellement hétérogènes (voir les nœuds du cluster du LIMOS).

On accède au cluster en se connectant (en ssh) sur le serveur frontalhpc2020 et en utilisant le login / mot de passe de son compte habituel. Pour exécuter un programme sur un nœud de calcul, l'utilisateur doit obligatoirement passer par l'ordonnanceur de tâches SLURM (voir section suivante).

SLURM (Simple Linux Utility for Resource Management) est un gestionnaire de ressources et ordonnanceur de tâches pour des clusters LINUX. Il permet de répartir au mieux les ressources de calcul (CPU, GPU, RAM) entre utilisateurs en gérant des files d'attente avec priorité.

Les processus d'un utilisateur sont confinés aux ressources (CPU notamment) qu'il a réservées : il ne peut pas accéder aux CPU réservés par d'autres utilisateurs. Cela permet d'assurer une certaine reproductibilité des exécutions d'un même programme, notamment au niveau des temps de calcul (contrairement à ce qu'il se passe sur des machines en libre accès).

Une documentation complète est disponible sur le site de SLURM : http://slurm.schedmd.com/.

• Un nœud de calcul correspond à une machine de calcul du cluster (i.e. une machine physique),
• un nœud contient des processeurs physiques (sockets) contenant eux-mêmes des cœurs physiques (cores),
• dans le cas où l'hyperthreading est activé sur le nœud alors chaque cœur physique donne 2 cœurs logiques (threads). Autrement dit, si l'hyperthreading est activé alors un cœur physique permet d'exécuter 2 threads en parallèle.

Lorsqu'on parle de CPU dans SLURM on fait référence à une unité de calcul logique (i.e. un cœur logique), donc :

• sans l'hyperthreading : 1 cœur physique = 1 CPU SLURM
• avec l'hyperthreading : 1 cœur physique = 2 CPU SLURM

Définition Socket, core, thread - extrait de https://slurm.schedmd.com/mc_support.html

Dans SLURM un job correspond à une requête d'allocation de ressources (CPU, RAM, temps de calcul) par un utilisateur. Un job est composé d'étapes (steps) et chaque étape effectue une tâche (task) ou plusieurs en parallèle. Une task correspond à un processus, une task peut utiliser un ou plusieurs CPU.

Une partition dans SLURM correspond à un groupement logique de nœuds de calcul. Chaque partition est associée à des contraintes en termes de ressources (en particulier le temps de calcul maximum d'un job). Une partition peut être vue comme une file d'attente : l'utilisateur choisit la partition dans laquelle il soumet ses jobs en fonction de ses besoins.

L'administrateur peut affecter des features (tags) aux nœuds en fonction de leurs caractéristiques. L'utilisateur peut alors préciser les features nécessaires pour ses jobs afin que SLURM affecte les jobs uniquement aux nœuds possédant le / les features demandés.

Pour soumettre un job (demande d'allocation de ressources pour exécuter un programme), l'utilisateur doit :

• soit définir son job dans un script et le lancer à l'aide de la commande sbatch,
• soit lancer directement son job en ligne de commande à l'aide de la commande srun.

L'utilisateur crée un script bash (.sh) dans lequel il précise les ressources dont il a besoin puis appelle son programme (étape 1). Ce script est ensuite soumis à SLURM via la commande sbatch qui affecte un numéro au job (étape 2).

Etape 1 : Description du job dans un fichier bash (.sh)

Un script de soumission SLURM est composé de deux parties :

• un ensemble d'options, correspondant à des options de la commande sbatch, et permettant de préciser certaines caractéristiques du job telles que la quantité de ressources requise (CPU, RAM, temps) pour le programme que l'on souhaite exécuter,

• la ligne de commande du programme à exécuter. On peut aussi définir plusieurs étapes dans un job (et donc lancer plusieurs programmes en parallèle ou en séquentiel) via la commande srun.

Les options dans le script doivent être précédées de la directive #SBATCH. Un exemple de script permettant d'exécuter un programme monothread est donné ci-dessous :

#!/bin/bash
 
#===============================================================================
# exemples d'options
 
#SBATCH --partition=normal    # choix de la partition où soumettre le job
#SBATCH --time=10:0           # temps max alloué au job (format = m:s ou h:m:s ou j-h:m:s)
#SBATCH --ntasks=1            # nb de tasks total pour le job
#SBATCH --cpus-per-task=1     # 1 seul CPU pour une task
#SBATCH --mem=1000            # mémoire nécessaire (par noeud) en Mo
 
#===============================================================================
#exécution du programme (remplacer exe par le nom du programme
# ou la ligne de commande à exécuter)
./exe

Remarques

• Les ressources demandées par un job lui sont allouées pour toute la durée de son exécution. Un job ne peut pas avoir accès à plus de ressources que celles demandées, en particulier s'il dépasse le temps précisé en option (ou à défaut le temps max autorisé par la partition) il est automatiquement tué.

• si l'utilisateur ne précise pas d'option ce sont celles par défaut qui sont appliquées :
  • 1 CPU
  • 2Go de RAM par CPU
  • soumission dans la partition " normal" : jobs limités à 7 jours

• la priorité d'un job dépend, entre autre, de la quantité de ressources demandées : plus un utilisateur demande de ressources, plus la priorité de son job tend à être faible.

Etape 2. Soumission du job via la commande sbatch

Le job décrit dans un script est soumis via la commande sbatch suivie du nom du script. SLURM affecte alors un numéro au job et le place dans la file d'attente (celle par défaut si l'utilisateur n'a pas précisé dans quelle partition il désirait soumettre son job, celle correspondant à la partition demandée sinon). Le job est exécuté quand les ressources sont disponibles.

[toussain@frontalhpc ~]$ sbatch submit.sh
Submitted batch job 2906757

La commande srun permet de définir une étape dans un script mais on peut aussi l'utiliser en ligne de commande pour soumettre directement un job (sans écrire de script). Le résultat d'exécution s'affiche alors directement à l'écran (il n'y a pas de création de fichier résultat). Les options sont les mêmes qu'avec le script, elles sont passées en ligne de commande. Exemple de soumission d'un exécutable (exe) dans la partition court pour 10 minutes :

[toussain@frontalhpc ~]$ srun --partition=court --time=10:0 ./exe 

Attention, les jobs soumis directement avec srun sont attachés au terminal, ils sont donc tués si vous fermez le terminal ou si vous vous déconnectez.