Ordonnancement Slurm des tâches exécutées avec GPU

From CC Doc
Jump to navigation Jump to search
This site replaces the former Compute Canada documentation site, and is now being managed by the Digital Research Alliance of Canada.

Ce site remplace l'ancien site de documentation de Calcul Canada et est maintenant géré par l'Alliance de recherche numérique du Canada.

This page is a translated version of the page Using GPUs with Slurm and the translation is 100% complete.
Other languages:
English • ‎français

Introduction

Pour demander un ou plusieurs GPU pour une tâche, lancez

 --gpus-per-node=[type:]number

À l'intérieur des crochets, vous pouvez indiquer la quantité et le type de GPU. Pour les types, voyez le tableau dans la section GPU disponibles ci-dessous. Voici deux exemples :

 --gpus-per-node=2
 --gpus-per-node=v100:1

Sur la première ligne, on demande deux GPU par nœud, peu importe le type de GPU. Sur la deuxième ligne, on demande 1 GPU par nœud, de type V100.

La forme suivante peut aussi être utilisée

 --gres=gpu[[:type]:number]

Cette forme est cependant moins récente et ne sera probablement plus prise en charge dans les versions de Slurm à venir. Nous vous recommandons de la remplacer dans vos scripts par --gpus-per-node.

Il y a plusieurs autres directives que vous pouvez utiliser pour demander des GPU  par exemple --gpus, --gpus-per-socket, --gpus-per-task, --mem-per-gpu, and --ntasks-per-gpu. Voyez la documentation de Slurm sur sbatch. Notre équipe n'a pas testé toutes les combinaisons; si vous n'obtenez pas le résultat voulu, contactez le soutien technique.

Pour l'information générale sur l'ordonnancement des tâches, consultez Exécuter des tâches.

GPU disponibles

Le tableau suivant liste les GPU qui sont présentement disponibles.

Grappe Qté de nœuds Type de GPU Par nœud Modèle de GPU Attribut
compute
capability(*)
Mémoire GPU (GiB) Remarques
Cœurs CPU Mémoire CPU GPU
Béluga 172 v100 40 191000M 4 V100-SXM2 70 16 tous les GPU sont associés au même socket CPU et connectés via NVLink
Cedar 114 p100 24 128000M 4 P100-PCIE 60 12 deux GPU par socket CPU
32 p100 24 257000M 4 P100-PCIE 60 16 tous les GPU sont associés au même socket CPU
192 v100l 32 192000M 4 V100-SXM2 70 32 deux GPU par socket CPU; tous les GPU sont connectés via NVLink
Graham 160 p100 32 127518M 2 P100-PCIE 60 12 un GPU par socket CPU
7 v100 28 183105M 8 V100-PCIE 70 16 voir Nœuds GPU Volta
2 v100(**) 28 183105M 8 V100-PCIE 70 32 voir Nœuds GPU Volta-
30 t4 44 192000M 4 Tesla T4 75 16 deux GPU par socket CPU
6 t4 16 192000M 4 Tesla T4 75 16 &nbsp
Hélios 15 k20 20 110000M 8 K20 35 5 quatre GPU par socket CPU
6 k80 24 257000M 16 K80 37 12 huit GPU par socket CPU
Mist 54 n.a. 32 256GiB 4 V100-SXM2 70 32 voir Mist specifications
Narval 159 a100 48 510000M 4 A100 80 40 deux GPU par socket CPU; tous les GPU sont connectés via NVLink
Arbutus L'ordonnanceur Slurm ne gère pas les ressources infonuagiques. Voir Ressources infonuagiques pour l'information sur le matériel disponible.

(*) Le terme compute capability est utilisé par NVIDIA pour indiquer les fonctionnalités matérielles spécifiques à un GPU particulier et n'a aucun rapport avec la performance des dispositifs. Cet attribut n'est utile que si vous compilez vos propres programmes GPU. Pour plus d'information, voir la page CUDA.

(**) Pour avoir accès aux nœuds V100 à grande mémoire de Graham, utilisez les arguments suivants dans la commande sbatch/salloc : "--constraint=cascade,v100".

Mist

Mist est une grappe qui comprend des CPU IBM Power9 (et non des Intel x86) et des GPU NVIDIA V100. Si vous avez accès à Niagara, vous avez aussi accès à Mist; voyez les directives sur le site web de SciNet.

Comment indiquer le type de GPU à utiliser

Certaines grappes possèdent plus d'un type de GPU; c'est le cas de Cedar, Graham et Hélios.
Sur Béluga, Cedar et Graham les GPU sont uniquement disponibles sur certains nœuds.

Si le type de GPU n'est pas spécifié, Slurm pourrait acheminer aléatoirement votre tâche vers un nœud équipé avec n'importe quel type de GPU. Dans certains cas, ceci pourrait ne pas être souhaitable. Par exemple, le code utilisé en mécanique moléculaire nécessite une haute performance en double précision pour laquelle les GPU T4 ne sont pas appropriés. Assurez-vous donc de spécifier le type de GPU.

Exemples

Tâches avec un seul cœur

Pour une tâche qui nécessite un seul cœur CPU et un GPU,

File : gpu_serial_job.sh

#!/bin/bash
#SBATCH --account=def-someuser
#SBATCH --gpus-per-node=1
#SBATCH --mem=4000M               # memory per node
#SBATCH --time=0-03:00
./program                         # you can use 'nvidia-smi' for a test


Tâches multifils

Pour une tâche GPU qui nécessite plusieurs CPU dans un seul nœud,

File : gpu_threaded_job.sh

#!/bin/bash
#SBATCH --account=def-someuser
#SBATCH --gpus-per-node=1         # Number of GPU(s) per node
#SBATCH --cpus-per-task=6         # CPU cores/threads
#SBATCH --mem=4000M               # memory per node
#SBATCH --time=0-03:00
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
./program


Pour un GPU demandé, nous recommandons

  • sur Béluga, un maximum de 10 cœurs CPU;
  • sur Cedar,
    • un maximum de 6 cœurs CPU par GPU de type P100 (p100 et p100l)
    • un maximum de 8 cœurs CPU par GPU de type V100 (v100l)
  • sur Graham, un maximum de 16 cœurs CPU

Tâches MPI

File : gpu_mpi_job.sh

#!/bin/bash
#SBATCH --account=def-someuser
#SBATCH --gpus=8                  # total number of GPUs
#SBATCH --ntasks-per-gpu=1        # total of 8 MPI processes
#SBATCH --cpus-per-task=6         # CPU cores per MPI process
#SBATCH --mem-per-cpu=5G          # host memory per CPU core
#SBATCH --time=0-03:00            # time (DD-HH:MM)
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
srun ./program


Nœuds entiers

Si votre application peut utiliser efficacement un nœud entier et ses GPU associés, vous pouvez probablement réduire le temps d'attente si vous demandez un nœud entier. Utilisez les scripts suivants comme modèle.

Demander un nœud GPU sur Graham

File : graham_gpu_node_job.sh

#!/bin/bash
#SBATCH --nodes=1
#SBATCH --gpus-per-node=p100:2
#SBATCH --ntasks-per-node=32
#SBATCH --mem=127000M
#SBATCH --time=3:00
#SBATCH --account=def-someuser
nvidia-smi


Demander un nœud GPU P100 sur Cedar

File : cedar_gpu_node_job.sh

#!/bin/bash
#SBATCH --nodes=1
#SBATCH --gpus-per-node=p100:4
#SBATCH --ntasks-per-node=24
#SBATCH --exclusive
#SBATCH --mem=125G
#SBATCH --time=3:00
#SBATCH --account=def-someuser
nvidia-smi


Demander un nœud P100-16G sur Cedar

Sur Cedar se trouve un groupe particulier de nœuds qui ont chacun quatre cartes Tesla P100 16Go, alors que les autres GPU P100 sont de 12Go et les GPU V100 de 32Go. Les GPU dans les nœuds P100L utilisent le même connecteur PCI, ce qui fait que la latence dans les communications entre GPU est plus faible; cependant, la bande passante entre CPU et GPU est plus basse qu'avec des nœuds GPU réguliers. De plus, la mémoire vive des nœuds est de 256Go. Pour utiliser ces nœuds, il faut demander des nœuds entiers et indiquer --gres=gpu:p100l:4. Le temps d'exécution maximal pour les tâches sur GPU P100L est de 28 jours.


File : p100l_gpu_job.sh

#!/bin/bash
#SBATCH --nodes=1 
#SBATCH --gpus-per-node=p100l:4     
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=24    # There are 24 CPU cores on P100 Cedar GPU nodes
#SBATCH --mem=0               # Request the full memory of the node
#SBATCH --time=3:00
#SBATCH --account=def-someuser
hostname
nvidia-smi


Regroupement de tâches pour un seul GPU

Pour exécuter pendant plus de 24 heures quatre programmes qui utilisent un seul GPU ou deux programmes qui utilisent deux GPU, nous recommandons GNU Parallel. Voici un exemple simple :

cat params.input | parallel -j4 'CUDA_VISIBLE_DEVICES=$(({%} - 1)) python {} &> {#}.out'

L'identifiant du GPU est calculé en soustrayant 1 de l'identifiant de la fente (slot), représenté par {%}. L'identifiant de la tâche est représenté par {#}, avec des valeurs partant de 1.

Le fichier params.input devrait contenir les paramètres sur des lignes distinctes, comme suit :

code1.py
code2.py
code3.py
code4.py
...

Vous pouvez ainsi soumettre plusieurs tâches. Le paramètre -j4 fait en sorte que GNU Parallel exécutera quatre tâches concurremment en lançant une tâche aussitôt que la précédente est terminée. Pour éviter que deux tâches se disputent le même GPU, utilisez CUDA_VISIBLE_DEVICES.