2-ressources.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bien choisir les ressources\n",
    "Il y a plusieurs **ressources de calcul haute performance** qui vous\n",
    "sont disponibles à l'Alliance de recherche numérique du Canada :\n",
    "* Grappes de calcul :\n",
    "  * Béluga, Cedar, Graham, Narval, Niagara\n",
    "* Stockage :\n",
    "  * Temporaire, projet, *nearline*\n",
    "\n",
    "Malgré qu'elles soient grandes, tout en ayant une taille limitée,\n",
    "ces ressources devraient être utilisées parcimonieusement par\n",
    "chaque personne afin de maximiser la quantité de résultats\n",
    "scientifiques produits pour soi-même et pour les autres."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objectif - construction d'un script de tâche Slurm\n",
    "Le principal objectif de ce chapitre est de vous permettre d'analyser\n",
    "vos besoins dans le but de **déterminer les ressources nécessaires**\n",
    "pour vos tâches de calcul.\n",
    "Chaque tâche de calcul est définie par un **script de tâche** destiné à\n",
    "[l'ordonnanceur Slurm](https://slurm.schedmd.com/documentation.html).\n",
    "Typiquement écrit en commandes Bash, on y retrouve :\n",
    "* Le [shebang](https://fr.wikipedia.org/wiki/Shebang) en toute\n",
    "  première ligne. Par exemple : `#!/bin/bash`\n",
    "* Les options `#SBATCH` en entête pour les besoins de la tâche. Les\n",
    "  options en entête seront lues par la commande de soumission de tâche\n",
    "  [`sbatch`](https://slurm.schedmd.com/sbatch.html)\n",
    "* [Chargement des modules](https://docs.alliancecan.ca/wiki/Utiliser_des_modules) requis\n",
    "* Les commandes Bash qui seront exécutées automatiquement sur des\n",
    "  processeurs réservés pour la tâche"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Par exemple : [`scripts/mpi-pi/pi-job.sh`](https://github.com/calculquebec/cip201-serveurs-calcul/blob/main/scripts/mpi-pi/pi-job.sh)\n",
    "\n",
    "```Bash\n",
    "cat scripts/mpi-pi/pi-job.sh\n",
    "```\n",
    "```\n",
    "#!/bin/bash\n",
	"\n",
	"#SBATCH --job-name=pi\n",
    "#SBATCH --ntasks=4\n",
    "#SBATCH --mem-per-cpu=1G\n",
    "#SBATCH --time=00:05:00\n",
    "\n",
    "module load StdEnv/2023 gcc/12.3 openmpi/4.1.5\n",
    "\n",
    "srun ./pi 10000000000\n",
    "```\n",
    "\n",
    "Notre documentation à cet effet débute à la page :\n",
    "[Exécuter des tâches](https://docs.alliancecan.ca/wiki/Running_jobs/fr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analyse des calculs localement\n",
    "Lorsqu'une tâche est en cours d'exécution sur votre ordinateur,\n",
    "vous pouvez surveiller différentes métriques :\n",
    "* Utilisation CPU (et GPU, s'il y a lieu)\n",
    "* Mémoire-vive utilisée\n",
    "* Accès au stockage (lectures et écritures par seconde, bande-passante)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sous Windows\n",
    "* [Gestionnaire des tâches Windows](https://fr.wikipedia.org/wiki/Gestionnaire_des_t%C3%A2ches_Windows)\n",
    "* Pour le faire afficher, on le trouve de deux manières :\n",
    "  * Chercher *Gestionnaire des tâches* dans le menu Démarrer\n",
    "  * Raccourcis clavier Ctrl+Alt+Suppr\n",
    "\n",
    "![Aperçu du gestionnaire des tâches Windows](images/win-task-manager.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sous macOS\n",
    "* [Moniteur d’activité](https://support.apple.com/fr-ca/guide/activity-monitor/actmntr1001/mac)\n",
    "* Pour le faire afficher :\n",
    "  * Démarrer l'application à partir des *Applications et Utilitaires* de macOS\n",
    "  * Sinon, utiliser le raccourcis clavier Commande+Espace et taper les\n",
    "    premières lettres de \"Moniteur d'activité\" pour pouvoir sélectionner\n",
    "    cette application\n",
    "\n",
    "![Aperçu du moniteur d'activité macOS](https://help.apple.com/assets/5FDCF1894EB74318147EC0CF/5FDCF18A4EB74318147EC0D6/fr_CA/ad6337d66061aa27122e75521960fc5a.png)\n",
    "_Image tirée du soutien technique d'Apple_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sous Linux\n",
    "Dans un terminal Unix, on peut utiliser :\n",
    "* La [commande `top`](https://man7.org/linux/man-pages/man1/top.1.html)\n",
    "  (appuyez sur Q pour quitter)\n",
    "\n",
    "![Capture de top](images/linux-top.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La [commande `htop`](https://man7.org/linux/man-pages/man1/htop.1.html)\n",
    "  (appuyez sur Q pour quitter)\n",
    "\n",
    "![Capture de htop](images/linux-htop.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analyse des tâches sur la grappe de calcul\n",
    "On commence par **se connecter au noeud frontal** de la grappe :\n",
    "```Bash\n",
    "ssh login1\n",
    "...\n",
    "```\n",
    "**Notes** :\n",
    "* Pour accéder aux grappes de calcul en production, il vaut mieux\n",
    "  utiliser [une paire de clés SSH](https://docs.alliancecan.ca/wiki/Using_SSH_keys_in_Linux/fr).\n",
    "* [L'authentification multifacteur](https://docs.alliancecan.ca/wiki/Multifactor_authentication/fr)\n",
    "  est maintenant obligatoire sur les grappes nationales.\n",
    "  [Vidéo d'introduction ici](https://www.youtube.com/watch?v=ciycOUbchl8).\n",
    "* Avec votre accès par défaut, vous avez un compte de calcul\n",
    "  `def-*` de base qui vous permet de lancer des tâches."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour soumettre un script de tâche, on utilise la\n",
    "[commande `sbatch`](https://slurm.schedmd.com/sbatch.html) :\n",
    "```Bash\n",
    "sbatch scripts/blastn-gen-seq.sh\n",
    "```\n",
    "\n",
    "Et pour voir l'état de la tâche, on utilise la\n",
    "[commande `squeue`](https://slurm.schedmd.com/squeue.html) :\n",
    "```Bash\n",
    "squeue -u $USER  # ou 'sq'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ressources utilisées d'une tâche terminée\n",
    "Avec la [commande `sacct`](https://slurm.schedmd.com/sacct.html),\n",
    "on peut obtenir un tableau détaillé de nos tâches exécutées\n",
    "depuis minuit :\n",
    "```Bash\n",
    "sacct\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avec la [commande `seff`](https://docs.alliancecan.ca/wiki/Running_jobs/fr#T.C3.A2ches_termin.C3.A9es),\n",
    "on peut obtenir un court rapport d'exécution d'une tâche.\n",
    "Ce rapport inclut une mesure du temps écoulé, une mesure du temps CPU\n",
    "et une mesure de consommation maximale de la mémoire-vive.\n",
    "Des valeurs d'efficacité en pourcentages sont données pour les cycles CPU\n",
    "et la mémoire-vives en fonction des quantités réservées.\n",
    "```Bash\n",
    "seff <No_tâche>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ressources utilisées par une tâche CPU en cours\n",
    "Étant donné un certain calcul matriciel dans le script Python \n",
    "[`scripts/crunch.py`](https://github.com/calculquebec/cip201-serveurs-calcul/blob/main/scripts/crunch.py) :\n",
    "\n",
    "```Bash\n",
    "cat scripts/crunch.py\n",
    "```\n",
    "\n",
    "Lors d'une tâche interactive, on peut utiliser `top` et `htop` pour surveiller les ressources utilisées :\n",
    "\n",
    "```Bash\n",
    "# Tâche interactive\n",
    "salloc --cpus-per-task=4 --mem=8000M --time=0:15:0\n",
    "\n",
    "cat scripts/crunch.sh\n",
    "\n",
    "# Exécution avec un (1) processeur\n",
    "bash scripts/crunch.sh --cpu 1\n",
    "top -u $USER  # q pour quitter\n",
    "\n",
    "# Exécution avec quatre (4) processeurs\n",
    "bash scripts/crunch.sh --cpu 4\n",
    "htop -u $USER  # q pour quitter\n",
    "\n",
    "# Comparer les résultats\n",
    "grep sec *.log\n",
    "\n",
    "exit  # Pour revenir à login1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si vous utilisez\n",
    "[JupyterHub](https://docs.alliancecan.ca/wiki/JupyterHub/fr)\n",
    "pour profiler votre programme, vous pouvez visualiser en temps\n",
    "réel la consommation de ressources dans l'onglet _GPU Dashboards_:\n",
    "\n",
    "![NV Dashboard CPU](images/nv-dashboard_cpu.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Exercice** - Valider le comportement d'une tâche active\n",
    "Pendant que vos tâches sont actives, vous pouvez vous connecter par\n",
    "SSH aux noeuds de calcul correspondants afin de valider que\n",
    "l'exécution se passe bien :\n",
    "```Bash\n",
    "cat scripts/inv-mat.sh\n",
    "sbatch scripts/inv-mat.sh\n",
    "```\n",
    "\n",
    "Voici les étapes de validation (à adapter pour l'exercice) :\n",
    "* Identification du ou des noeud(s) avec : `squeue -u $USER`\n",
    "* Connexion avec : `ssh <nom_noeud>`\n",
    "* Inspection avec `top` et/ou `htop` :\n",
    "  * Est-ce que vos processus s'exécutent avec un **pourcentage de 100%?**\n",
    "  * Est-ce que vos processus parallèles s'exécutent avec un\n",
    "    **pourcentage de $n$ * 100%**, où $n$ est le nombre de processeurs\n",
    "    par tâche Slurm?\n",
    "  * Est-ce que le **noeud de calcul** semble pleinement utilisé?\n",
    "* **Inspection des résultats** dans `temps_inv.csv`\n",
    "  * Identifier tout problème, s'il y a lieu; trouver la cause\n",
    "  * Corriger le code source, la compilation, le script ou les\n",
    "    paramètres de la tâche de calcul\n",
    "  * Relancer la tâche de calcul et refaire les précédentes étapes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### (Démo) Ressources utilisées par une tâche GPU en cours\n",
    "```Bash\n",
    "# Tâche interactive\n",
    "salloc --cpus-per-task=4 --mem=8000M --time=0:15:0 --gres=gpu:1\n",
    "```\n",
    "\n",
    "* Pour Windows et macOS, il existe des outils propriétaires\n",
    "  permettant de visualiser en temps réel l'utilisation du GPU.\n",
    "  Veuillez vous référer au site Web du manufacturier de votre GPU\n",
    "  pour les détails\n",
    "* Sous Linux, il y a d'abord la\n",
    "  [commande `nvidia-smi`](https://developer.nvidia.com/nvidia-system-management-interface)\n",
    "\n",
    "```Bash\n",
    "nvidia-smi\n",
    "```\n",
    "\n",
    "![Capture nvidia-smi](images/nvidia-smi.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Il existe aussi un projet [`nvtop`](https://github.com/Syllo/nvtop)\n",
    "  permettant de visualiser l'utilisation d'un ou plusieurs GPU dans\n",
    "  un terminal :\n",
    "\n",
    "```Bash\n",
    "# Exécution avec un GPU\n",
    "bash scripts/crunch.sh --gpu\n",
    "nvtop  # q pour quitter\n",
    "```\n",
    "![Capture nvtop](https://raw.githubusercontent.com/Syllo/nvtop/master/screenshot/NVTOP_ex1.png)\n",
    "\n",
    "```Bash\n",
    "# Regarder le résultat\n",
    "grep sec tg.log\n",
    "\n",
    "exit  # Pour revenir à login1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si vous utilisez\n",
    "[JupyterHub](https://docs.alliancecan.ca/wiki/JupyterHub/fr)\n",
    "pour profiler votre programme GPU, vous pouvez visualiser en temps\n",
    "réel la consommation de ressources GPU dans l'onglet _GPU Dashboards_:\n",
    "\n",
    "![NV Dashboard GPU](images/nv-dashboard_gpu.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Exercice** - Tester `crunch.py` avec un GPU\n",
    "```Bash\n",
    "cat    scripts/crunch-sbatch-1gpu.sh\n",
    "sbatch scripts/crunch-sbatch-1gpu.sh\n",
    "\n",
    "squeue -u $USER  # Pour vérifier l'état de la tâche\n",
    "tail -24 $(ls slurm-* | tail -1)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comparer la vitesse CPU vs GPU\n",
    "Avant d'utiliser massivement les GPU d'une grappe de calcul, il faut\n",
    "tout d'abord que l'application ou l'algorithme puisse démontrer une\n",
    "\"bonne performance\" en utilisant plusieurs processeurs en parallèle.\n",
    "\n",
    "Quelques définitions :\n",
    "* **Temps écoulé** = temps d'exécution total que l'on perçoit et non le temps CPU\n",
    "* **Accélération** = (temps avec `1` processeur) / (temps avec `N` processeurs)\n",
    "* **Efficacité** = (Accélération) / `N`\n",
    "\n",
    "Le coût d'un noeud GPU étant huit fois (8x) supérieur à celui d'un noeud\n",
    "régulier, l'utilisation d'un seul GPU doit permettre une accélération\n",
    "d'au moins huit fois (8x) la vitesse de 8 à 16 processeurs.\n",
    "* **Accélération GPU** = (temps avec 8 à 16 processeur) /\n",
    "  (temps avec un GPU) >= 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analyse des tâches via les portails\n",
    "Béluga et Narval ont chacun un portail pour l'analyse des tâches :\n",
    "* [https://portail.beluga.calculquebec.ca/](https://portail.beluga.calculquebec.ca/)\n",
    "* [https://portail.narval.calculquebec.ca/](https://portail.narval.calculquebec.ca/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estimer les ressources nécessaires\n",
    "### Efficacité cible d'une tâche\n",
    "À coût d'essais et erreurs avec une **tâche de petite taille**,\n",
    "la cible pour :\n",
    "* **Le calcul** est une **efficacité d'au moins 90%**\n",
    "  * Tâches séquentielles : il faut **optimiser les accès aux données**\n",
    "    * Utiliser adéquatement les différents types de stockage\n",
    "  * Tâches parallèles : il existe un **nombre maximal de processeurs**\n",
    "    à utiliser pour respecter ce seuil :\n",
    "    * Principe de [scalabilité](https://docs.alliancecan.ca/wiki/Scalability/fr)\n",
    "      et la [loi d'Amdahl](https://fr.wikipedia.org/wiki/Loi_d%27Amdahl)\n",
    "* **La mémoire-vive** est une consommation **de l'ordre de 80%**\n",
    "  de ce qui est demandé à l'ordonnanceur Slurm\n",
    "\n",
    "**Rappel** - vous pouvez obtenir ces pourcentages via les commandes\n",
    "`sacct -X` (surtout pour obtenir les numéros de tâches) et `seff`.\n",
    "Les valeurs à considérer sont :\n",
    "* `CPU Utilized` et `CPU Efficiency`\n",
    "* `Memory Utilized` et `Memory Efficiency`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Exercice** - Efficacité des tâches\n",
    "Pour quelques-unes de vos tâches listées par la commande suivante :\n",
    "```Bash\n",
    "sacct -X\n",
    "```\n",
    "Obtenez le `CPU Efficiency` et le `Memory Efficiency` via la commande :\n",
    "```Bash\n",
    "seff <No_tâche>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extrapoler les ressources nécessaires\n",
    "**En augmentant la ou les dimensions du problème**, quelles devraient\n",
    "  être la durée du calcul et la consommation en mémoire-vive?\n",
    "[Une analyse détaillée du code](https://fr.wikipedia.org/wiki/Analyse_de_la_complexit%C3%A9_des_algorithmes)\n",
    "n'est pas nécessaire pour déterminer le type de calcul qui est fait :\n",
    "\n",
    "* Vous pouvez **mesurer le temps d'exécution** (avec la\n",
    "  commande `time`) en fonction de la taille du problème.\n",
    "  En extrapolant les résultats, il serait possible de prévoir\n",
    "  le comportement du programme sur une grappe de calcul.\n",
    "\n",
    "```Bash\n",
    "time -p sleep 2\n",
    "```\n",
    "\n",
    "* Vous pouvez considérer le **format des données en entrées** pour\n",
    "  deviner l'ordre du calcul principal. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Taille des données et nombre de fichiers à traiter\n",
    "En plus du temps de calcul et de l'espace mémoire, il faut aussi\n",
    "considérer **l'utilisation du stockage**. Les valeurs à tenir compte :\n",
    "1. La **quantité** en octets (ou Go)\n",
    "    * Peut servir à **estimer** l'utilisation de la mémoire-vive\n",
    "    * Tenir compte de la taille du **stockage local rapide** pour\n",
    "      optimiser les accès aux fichiers\n",
    "1. Le **nombre** de fichiers à traiter\n",
    "    * Considérer le **parallélisme de données**\n",
    "    * **Multiplier la durée moyenne** du traitement d'un fichier par\n",
    "      le nombre de fichiers pour estimer la durée d'une tâche\n",
    "    * **Multiplier la taille moyenne** des fichiers par leur nombre\n",
    "      pour estimer l'espace en mémoire-vive (par exemple : des images)\n",
    "    * Utiliser le stockage rapide pour **optimiser les accès**\n",
    "      aléatoires et nombreux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour obtenir le nombre de fichiers et la taille totale :\n",
    "* **Sous Windows** : dans l'explorateur Windows (raccourcis clavier : Windows + E)\n",
    "  * Sélectionner un dossier ou plusieurs fichiers\n",
    "  * Bouton droit de la souris -> *Propriétés*\n",
    "\n",
    "![Windows data properties](images/win-data-size.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Sous macOS** : dans *Finder*\n",
    "  * Sélectionner un dossier ou plusieurs fichiers\n",
    "  * Bouton droit de la souris -> *Get Info*\n",
    "  * Autrement : avec l'affichage *Par liste*\n",
    "    * [Activer *Calculer toutes les tailles*](https://www.solutionenligne.org/comment-afficher-taille-dossiers-fichiers-dans-finder-mac-os/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Sous Linux** et sur les **grappes de calcul** :\n",
    "  * L'environnement graphique peut offrir le même genre d'outils,\n",
    "    mais tout dépend de la distribution et du bureau.\n",
    "  * La commande `du -sb RÉPERTOIRE` (`s` : somme totale, `b` :\n",
    "    taille apparente en octets) calcule récursivement et affiche\n",
    "    la taille totale en octets. La taille apparente est celle qui\n",
    "    importe lors d'un transfert ou d'une sauvegarde de données.\n",
    "  * La commande `find RÉPERTOIRE | wc -l` compte récursivement\n",
    "    et affiche le nombre de fichiers et de sous-répertoires.\n",
    "\n",
    "```Bash\n",
    "du -sb donnees\n",
    "find donnees | wc -l\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparaison entre les grappes de calcul\n",
    "* À propos des grappes :\n",
    "\n",
    "| | [Béluga](https://docs.alliancecan.ca/wiki/B%C3%A9luga) | [Cedar](https://docs.alliancecan.ca/wiki/Cedar/fr) | [Graham](https://docs.alliancecan.ca/wiki/Graham/fr) | [Narval](https://docs.alliancecan.ca/wiki/Narval) | [Niagara](https://docs.alliancecan.ca/wiki/Niagara/fr) |\n",
    "|-----------------------:|:---------:|:---------:|:---------:|:------------:|:----------:|\n",
    "| **Mise en production** | Mars 2019 | Juin 2017 | Juin 2017 | Octobre 2021 | Avril 2018 |\n",
    "|              **Ville** | Montréal  |  Burnaby  | Waterloo  |   Montréal   |   Toronto  |\n",
    "|           **Province** |  Québec   |    C.-B.  |  Ontario  |    Québec    |   Ontario  |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Nombre de processeurs (coeurs CPU) selon le cas :\n",
    "\n",
    "| Processeur Intel/AMD  | [Béluga](https://docs.alliancecan.ca/wiki/B%C3%A9luga) | [Cedar](https://docs.alliancecan.ca/wiki/Cedar/fr) | [Graham](https://docs.alliancecan.ca/wiki/Graham/fr) | [Narval](https://docs.alliancecan.ca/wiki/Narval) | [Niagara](https://docs.alliancecan.ca/wiki/Niagara/fr) |\n",
    "|----------------------:|:--------:|:--------:|:--------:|:---------:|:---------:|\n",
    "|      Broadwell (avx2) |          | 724 * 32 | 983 * 32 |           |           |\n",
    "|      Skylake (avx512) | 802 * 40 | 640 * 48 |          |           | 1548 * 40 |\n",
    "| Cascade Lake (avx512) |          | 768 * 48 | 136 * 44 |           |  476 * 40 |\n",
    "|      EPYC Rome (avx2) |          |          |          | 1181 * 64 |           |\n",
    "\n",
    "| Mémoire par proc. | [Béluga](https://docs.alliancecan.ca/wiki/B%C3%A9luga) | [Cedar](https://docs.alliancecan.ca/wiki/Cedar/fr) | [Graham](https://docs.alliancecan.ca/wiki/Graham/fr) | [Narval](https://docs.alliancecan.ca/wiki/Narval) | [Niagara](https://docs.alliancecan.ca/wiki/Niagara/fr) |\n",
    "|-------:|:--------:|:---------:|:--------:|:---------:|:---------:|\n",
    "|  2400M | 160 * 40 |           |          |           |           |\n",
    "|  4000M |          | 1408 * 48 | 903 * 32 | 1145 * 64 |           |\n",
    "|  4000M |          |  576 * 32 |          |           |           |\n",
    "|  4400M |          |           | 136 * 44 |           |           |\n",
    "|  4800M | 589 * 40 |           |          |           | 2024 * 40 |\n",
    "|  8000M |          |   96 * 32 |  56 * 32 |           |           |\n",
    "| 16000M |          |   24 * 32 |  24 * 32 |           |           |\n",
    "| 19200M |  53 * 40 |           |          |           |           |\n",
    "| 32000M |          |           |          |   36 * 64 |           |\n",
    "| 48000M |          |   24 * 32 |   3 * 64 |           |           |\n",
    "| 96000M |          |    4 * 32 |          |           |           |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [Nombre de GPU](https://docs.alliancecan.ca/wiki/Using_GPUs_with_Slurm/fr) selon le cas :\n",
    "\n",
    "| Accélérateurs | [Béluga](https://docs.alliancecan.ca/wiki/B%C3%A9luga) | [Cedar](https://docs.alliancecan.ca/wiki/Cedar/fr) | [Graham](https://docs.alliancecan.ca/wiki/Graham/fr) | [Mist (Power9)](https://docs.scinet.utoronto.ca/index.php/Mist) | [Narval](https://docs.alliancecan.ca/wiki/Narval) |\n",
    "|----------------:|:---:|:---:|:---:|:---:|:---:|\n",
    "| NVIDIA P100 12G |     | 456 | 320 |     |     |\n",
    "| NVIDIA P100 16G |     | 128 |     |     |     |\n",
    "|   NVIDIA T4 16G |     |     | 144 |     |     |\n",
    "| NVIDIA V100 16G | 688 |     |  54 |     |     |\n",
    "| NVIDIA V100 32G |     | 768 |  16 | 216 |     |\n",
    "| NVIDIA A100 40G |     |     |     |     | 636 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Réseau haute-performance et ordonnancement :\n",
    "\n",
    "| | [Béluga](https://docs.alliancecan.ca/wiki/B%C3%A9luga) | [Cedar](https://docs.alliancecan.ca/wiki/Cedar/fr) | [Graham](https://docs.alliancecan.ca/wiki/Graham/fr) | [Narval](https://docs.alliancecan.ca/wiki/Narval) | [Niagara](https://docs.alliancecan.ca/wiki/Niagara/fr) |\n",
    "|-----------------------:|:----------:|:-----------:|:----------:|:-----------:|:----------:|\n",
    "|       Connexion rapide | InfiniBand |   OmniPath  | InfiniBand | InfiniBand  | InfiniBand |\n",
    "|              Topologie |  En arbre  |   En arbre  |  En arbre  |  En arbre   | DragonFly+ |\n",
    "|    Taille îlots (proc) | 640 à 1200 | 1024 à 1536 |    1024    | 3072 à 3584 |    17280   |\n",
    "|    Facteur de blockage |   max 5:1  |   max 2:1   |   max 8:1  |  max 4.7:1  |   max 2:1  |\n",
    "| Granularité des tâches (par) | proc, GPU | proc, GPU | proc, GPU | proc, GPU |    noeud   |\n",
    "|         Durée maximale |   7 jours  |   28 jours  |   7 jours  |   7 jours   |   1 jour   |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Stockage : le tout sera décrit au dernier chapitre."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Points à retenir\n",
    "* Prévoir les **paramètres d'une tâche Slurm**\n",
    "  * Nombre de processeurs (CPU) et de noeuds de calcul\n",
    "  * Nombre d'accélérateurs (GPU)\n",
    "  * Quantité de mémoire-vive (RAM)\n",
    "  * Temps du calcul (`JJ-H:M` ou `H:M:S`)\n",
    "* Différents **outils pour monitorer** les ressources utilisées\n",
    "  * `time` et autres bibliothèques de mesure du temps écoulé\n",
    "  * `top`, `htop`, `nvtop`, `nvidia-smi`\n",
    "  * `sacct`, `seff`\n",
    "  * `du -sb`, `find | wc -l` et autres outils du système d'exploitation\n",
    "* On vise une **efficacité de 90%** et plus pour les tâches CPU\n",
    "  * L'accélération avec un accélérateur (GPU) doit être significative (>8x)\n",
    "* Le choix de la grappe dépend des besoins de chaque type de calcul"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}