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

Introduction

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

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

The square-bracket notation means that you must specify the number of GPUs, and you may optionally specify the GPU type. Choose a type from the "Available hardware" table below. Here are two examples:

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

The first example requests two GPUs per node, of any type available on the cluster. The second example requests one GPU per node, with the GPU being of the V100 type.

The following form can also be used:

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

This is older, and we expect it will no longer be supported in some future release of Slurm. We recommend that you replace it in your scripts with the above --gpus-per-node form.

There are a variety of other directives that you can use to request GPUs and related resources: --gpus, --gpus-per-socket, --gpus-per-task, --mem-per-gpu, and --ntasks-per-gpu. Please see the Slurm documentation for sbatch for more about these. Alliance staff have not tested many combinations of these, so if you try them and don't get the resources you expect or want, contact support.

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.

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

(**) To access large memory V100 nodes on Graham, use the following arguments in your sbatch/salloc command: "--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.

Dans le tableau ci-dessus, la colonne Type de GPU contient l'identifiant qu'il faut fournir à l'ordonnanceur Slurm pour un GPU en particulier, par exemple

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

For each GPU requested on:

• Béluga, we recommend no more than 10 CPU cores.
• Cedar, we recommend no more than 6 CPU cores per P100 GPU (p100 and p100l) and no more than 8 CPU cores per V100 GPU (v100l).
• Graham, we recommend no more than 16 CPU cores.

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

Message Passing Interface