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

Other languages:

English
français

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

Nœuds disponibles

Le tableau suivant décrit les nœuds avec GPU qui sont présentement disponibles.

Qté de nœuds	Grappe	Type de nœud	Cœurs CPU	Mémoire CPU	Qté de GPU par nœud	Modèle	Topologie
172	Béluga	-	40	191000M	4	V100-SXM2-16Go	tous les GPU associés au même socket CPU
114	Cedar, GPU P100	24	128000M	4	P100-PCIE-12Go	deux GPU par socket CPU
32	Cedar, GPU P100L	24	257000M	4	P100-PCIE-16Go	tous les GPU associés au même socket CPU
192	Cedar, GPU V100L	32	192000M	4	V100-PCIE-32Go	deux GPU par socket CPU; tous les GPU connectés via NVLink
160	Graham, Base GPU	44	127518M	2	P100-PCIE-12Go	un GPU par socket CPU
30	Graham, GPU	28	192000M	4	Tesla T4-16Go	deux GPU par socket CPU
15	Hélios, K20	20	110000M	8	K20-5Go	quatre GPU par socket CPU
6	Hélios, K80	24	257000M	16	K80-12Go	huit GPU par socket CPU
54	Niagara, IBM AC922	32 Power9	256GoB	4	V100-SMX2-32Go	tous les GPU sont connectés via NVLinks

Comment indiquer le type de GPU à utiliser

Plusieurs types de GPU sont disponibles sur la plupart des grappes. Pour indiquer le type de GPU à utiliser, ajoutez l'option appropriée, selon la grappe.

Some clusters have more than one GPU type available (Cedar, Graham, Hélios), and some clusters only have GPUs on certain nodes (Béluga, Cedar, Graham). You can choose the type of GPU to use by supplying the type specifier to Slurm. The following options are available:

Béluga

Comme il n'y a qu'un type de GPU, il n'est pas nécessaire d'en spécifier le type.

Cedar

Pour demander un P100 de 12G :

 #SBATCH --gres=gpu:p100:1

Pour demander un P100 de 16G :

 #SBATCH --gres=gpu:p100l:1

Pour demander un V100 de 32G :

 #SBATCH --gres=gpu:v100l:1

Si aucun type n'est spécifié, les tâches sur GPU demandant <=125G de mémoire seront exécutés sur des P100 de 12G.

Graham

Pour demander un P100 :

 #SBATCH --gres=gpu:p100:1

Pour demander un V100 :

 #SBATCH --gres=gpu:v100:1

Pour demander un T4 :

 #SBATCH --gres=gpu:t4:1

Si aucun type n'est spécifié, les tâches sur GPU seront exécutées sur des P100.

Hélios

Pour demander un K20 :

 #SBATCH --gres=gpu:k20:1

Pour demander un K80 :

 #SBATCH --gres=gpu:k80:1

Mist

Mist est une grappe qui comprend des CPU IBM Power9 (et non des Intel x86) et des GPU NVIDIA V100. Les utilisateurs ayant accès à Niagara ont aussi accès à Mist; voyez les directeives sur le site web de SciNet.

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 --gres=gpu:1              # Number of GPUs (per node)
#SBATCH --mem=4000M               # memory (per node)
#SBATCH --time=0-03:00            # time (DD-HH:MM)
./program

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 --gres=gpu: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            # time (DD-HH:MM)
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
./program

Pour chaque GPU, les tâches multifils ne devraient pas dépasser

avec Béluga, 10 cœurs;
avec Cedar, nous recommandons un maximum de 6 cœurs par GPU P100 (p100 et p100l) et un maximum de 8 cœurs par GPU V100 (v100l);
avec Graham, 16 cœurs.

Tâches MPI

File : gpu_mpi_job.sh

#!/bin/bash
#SBATCH --account=def-someuser
#SBATCH --gres=gpu:4              # Number of GPUs per node
#SBATCH --nodes=2                 # Number of nodes
#SBATCH --ntasks=48               # Number of MPI process
#SBATCH --cpus-per-task=1         # CPU cores per MPI process
#SBATCH --mem=120G                # memory per node
#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 --gres=gpu: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 --gres=gpu: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 --gres=gpu: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.