Skip to content

Allocation de ressources

Gérer l'allocation de ressources dans SLURM est essentiel pour optimiser l'utilisation des ressources disponibles (CPU, mémoire, GPU, etc.) et garantir que vos jobs s'exécutent efficacement. Voici un guide complet pour gérer l'allocation de ressources dans SLURM :

1. Comprendre les ressources disponibles

Avant de soumettre un job, il est important de connaître les ressources disponibles sur votre cluster. Utilisez les commandes suivantes pour obtenir des informations :

a. Afficher les partitions

Les partitions sont des groupes de nœuds avec des configurations spécifiques (par exemple, CPU, GPU).

sinfo

Options utiles :

  • -p <partition> : Filtrer par partition.
  • -o "%P %N %C %G" : Afficher les partitions, nœuds, CPU disponibles et GPU disponibles.

Exemple :

sinfo -o "%P %N %C %G"

b. Afficher les détails des nœuds

Utilisez scontrol show node pour afficher des informations détaillées sur les nœuds.

scontrol show node <nom_du_noeud>

Cela affiche des détails tels que :

  • Nombre de CPU (CPUs).
  • Mémoire totale (RealMemory).
  • GPU disponibles (Gres).

2. Allouer des ressources dans un job

a. Options de base pour l'allocation de ressources

Lorsque vous soumettez un job avec sbatch ou srun, vous pouvez spécifier les ressources nécessaires. Voici les options courantes :

Option Description
--ntasks=<nombre> Nombre de tâches (par défaut, 1).
--cpus-per-task=<n> Nombre de CPU par tâche.
--mem=<taille> Mémoire allouée (par exemple, 8G pour 8 Go).
--time=<durée> Durée maximale du job (format jours-heures:minutes:secondes).
--gres=gpu:<nombre> Demander des GPU (par exemple, --gres=gpu:1 pour 1 GPU).
--partition=<nom> Partition à utiliser (par exemple, defq, gpu, etc.).

Exemple de script de job :

#!/bin/bash
#SBATCH --job-name=mon_job
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4
#SBATCH --mem=8G
#SBATCH --time=01:00:00
#SBATCH --gres=gpu:1
#SBATCH --partition=gpu

# Charger les modules nécessaires
module load cuda/11.0

# Exécuter le programme
./mon_programme

b. Allocation de GPU

Si votre job nécessite des GPU, utilisez l'option --gres=gpu:<nombre>. Assurez-vous de sélectionner une partition qui supporte les GPU.

Exemple :

sbatch --gres=gpu:2 --partition=gpu mon_script_job.sh

c. Allocation de mémoire

Spécifiez la mémoire requise avec --mem. Si vous avez besoin de mémoire par CPU, utilisez --mem-per-cpu.

Exemple :

sbatch --ntasks=4 --cpus-per-task=2 --mem-per-cpu=4G mon_script_job.sh

d. Allocation de temps

Spécifiez la durée maximale du job avec --time. Si le job dépasse cette durée, il sera automatiquement annulé.

Exemple :

sbatch --time=2-12:00:00 mon_script_job.sh  # 2 jours et 12 heures

3. Optimiser l'allocation des ressources

a. Estimer les besoins

  • CPU : Utilisez --cpus-per-task pour spécifier le nombre de CPU nécessaires par tâche.
  • Mémoire : Estimez la mémoire requise en fonction de vos tests préliminaires.
  • GPU : Utilisez --gres=gpu uniquement si votre application supporte et nécessite des GPU.

b. Éviter la surallocation

  • Ne demandez pas plus de ressources que nécessaire, car cela peut retarder l'exécution de votre job.
  • Utilisez des estimations réalistes pour --time afin d'éviter que le job ne soit annulé prématurément.

4. Modifier l'allocation des ressources

a. Modifier un job en attente

Utilisez scontrol update pour modifier les ressources d'un job en attente.

Exemples :

  • Changer la mémoire :

scontrol update jobid=12345 MinMemoryCPU=16G

  • Changer le nombre de CPU :

scontrol update jobid=12345 CPUs=8

  • Changer la durée :

scontrol update jobid=12345 Time=04:00:00

b. Réallouer des ressources en cours d'exécution

Il n'est généralement pas possible de modifier les ressources d'un job en cours d'exécution. Vous devrez annuler le job (scancel) et le soumettre à nouveau avec les nouvelles ressources.

5. Surveiller l'utilisation des ressources

a. Utilisation des CPU et de la mémoire

Utilisez sstat pour surveiller l'utilisation des ressources d'un job en cours.

sstat -j <job_id> --format=JobID,MaxRSS,MaxVMSize,NTasks,CPUTime

b. Utilisation des GPU

Si vous utilisez des GPU, vous pouvez surveiller leur utilisation avec des outils comme nvidia-smi sur le nœud d'exécution.

6. Bonnes pratiques

  • Testez avec des petits jobs pour estimer les ressources nécessaires.
  • Utilisez des partitions adaptées (par exemple, gpu pour les jobs GPU).
  • Surveillez l'utilisation des ressources avec sstat pour ajuster les allocations futures.
  • Évitez la surallocation pour ne pas bloquer inutilement les ressources du cluster.

7. Exemple complet

Voici un exemple de script de job avec une allocation de ressources optimisée :

#!/bin/bash
#SBATCH --job-name=mon_job
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=8
#SBATCH --mem=16G
#SBATCH --time=02:00:00
#SBATCH --gres=gpu:1
#SBATCH --partition=gpu
#SBATCH --output=mon_job_%j.out
#SBATCH --error=mon_job_%j.err

# Charger les modules nécessaires
module load cuda/11.0

# Exécuter le programme
./mon_programme

Soumettez le job avec :

sbatch mon_script_job.sh

En suivant ces étapes, vous pouvez gérer efficacement l'allocation de ressources dans SLURM et optimiser l'exécution de vos jobs.