Plateforme HPC LIMOS

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== 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 ([[:machines|voir les nœuds du cluster du LIMOS]]).

 


=====Accès au cluster=====
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). 




===== Qu'est-ce que SLURM ? =====

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/|http://slurm.schedmd.com/]].

==== Le vocabulaire ====

=== Les nœuds et CPUs ===

  * 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

[{{  :socket.jpg?direct&  | **Définition Socket, core, thread** - extrait de [[https://slurm.schedmd.com/mc_support.html|https://slurm.schedmd.com/mc_support.html]]}}]

=== Les jobs et les tasks ===

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.

=== Les partitions ===

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.

=== Les features ===

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.

===== Soumettre un job =====

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.

==== Soumettre un job en utilisant un script ====

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 :

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

</code>

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

<code powershell>
[toussain@frontalhpc ~]$ sbatch submit.sh
Submitted batch job 2906757
</code>

==== Soumettre directement avec srun ====

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 :

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

<color #8b0000>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.</color>