3-lots-taches.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lots de tâches\n",
    "Le calcul haute-performance consiste non seulement au calcul parallèle par tâche (***parallélisme des tâches***),\n",
    "mais aussi au calcul de données en parallèle dans plusieurs tâches et/ou processus en simultané (***parallélisme de données***).\n",
    "Ce chapitre vous donnera les outils nécessaires pour gérer un grand nombre de tâches\n",
    "lorsque le projet de recherche requiert plusieurs centaines de résultats."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GNU Parallel\n",
    "La commande `parallel` de\n",
    "[GNU Parallel](https://docs.alliancecan.ca/wiki/GNU_Parallel/fr)\n",
    "permet d'utiliser pleinement les ressources locales d'un noeud de\n",
    "calcul, et ce, en gérant l'exécution d'une **longue liste de tâches\n",
    "de *petite* taille**.\n",
    "C'est un peu comme l'ordonnanceur Slurm, mais à plus petite échelle et\n",
    "en gérant des processus au lieu de scripts de tâche.\n",
    "\n",
    "![Fonctionnement de GNU Parallel](images/gnu-parallel.svg)\n",
    "\n",
    "* [Documentation officielle](https://www.gnu.org/software/parallel/parallel.html)\n",
    "* [Tutoriel](https://www.gnu.org/software/parallel/parallel_tutorial.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pourquoi pas Slurm?\n",
    "OK, mais pourquoi ne pas tout simplement soumettre\n",
    "**des centaines de tâches à Slurm**?\n",
    "* À tout moment, Slurm **limite chaque usager à 1000 tâches**\n",
    "  au total dans `squeue` (*pending* + *running*)\n",
    "* Certains calculs sont tellement **courts (< 5 minutes)** que le\n",
    "  démarrage et la fin de la tâche compteraient pour un pourcentage\n",
    "  significatif du temps réel utilisé, ce qui diminue leur efficacité"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les avantages de GNU Parallel à considérer :\n",
    "* Nous **évite d'utiliser une boucle** soumettant des centaines de\n",
    "  scripts similaires, ce qui, dans bien des cas, facilite\n",
    "  l'exécution de centaines de cas de calcul semblables\n",
    "* Le nombre de **processeurs disponibles limite** automatiquement le\n",
    "  nombre de cas de calcul exécutés en simultané\n",
    "  * Dans le cas de calculs parallèles, c'est possible de spécifier\n",
    "    le nombre de cas en simultané\n",
    "* GNU Parallel peut\n",
    "  [reprendre la séquence des cas de calcul](https://docs.alliancecan.ca/wiki/GNU_Parallel/fr#Suivi_des_commandes_ex.C3.A9cut.C3.A9es_ou_des_commandes_ayant_.C3.A9chou.C3.A9.3B_fonctionnalit.C3.A9s_de_red.C3.A9marrage)\n",
    "  en situation de fin hâtive de la tâche Slurm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntaxe de la commande GNU Parallel\n",
    "Les éléments de base de la commande `parallel` :\n",
    "```Bash\n",
    "parallel options gabarit_de_commande ::: liste de valeurs\n",
    "```\n",
    "\n",
    "Voir la page de manuel :\n",
    "```Bash\n",
    "man parallel  # Appuyez sur Q pour quitter\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modes d'utilisation\n",
    "#### Une seule séquence de paramètres\n",
    "Le paramètre changeant est donné via une paire d'`{}` :\n",
    "```Bash\n",
    "parallel echo fichier{}.txt ::: 1 2 3 4\n",
    "# parallel --citation  # S'engager à citer les développeurs\n",
    "```\n",
    "\n",
    "On peut réécrire la première commande en utilisant l'expansion des\n",
    "accolades Bash `{a..b}` :\n",
    "```Bash\n",
    "parallel echo fichier{}.txt ::: {1..4}\n",
    "parallel echo fichier{}.txt ::: {01..10}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Combinaisons de paramètres\n",
    "**a)** Lorsqu'il y a **plusieurs séquences de paramètres à combiner**,\n",
    "on peut utiliser des paires d'accolades numérotées telles que\n",
    "`{1}`, `{2}`, etc. :\n",
    "```Bash\n",
    "parallel echo fichier{1}{2}.txt ::: {01..10} ::: a b\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**b)** Dans le cas où on retrouve les **combinaisons de paramètres\n",
    "dans un fichier texte** :\n",
    "```Bash\n",
    "cat scripts/param.txt\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande `parallel` aura `-C ' '` pour spécifier le séparateur de\n",
    "paramètres dans `param.txt`, ainsi que l'argument `::::` pour\n",
    "spécifier ensuite ce nom de fichier :\n",
    "```Bash\n",
    "# parallel -C ' ' echo '$(({1}*{2}))' :::: scripts/param.txt\n",
    "cat scripts/prll-exec-param.sh\n",
    "sbatch scripts/prll-exec-param.sh\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**c)** Si on préfère valider la **liste des commandes dans un\n",
    "fichier texte** avant leur exécution sur un noeud de calcul :\n",
    "```Bash\n",
    "cat scripts/cmd.txt\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le script de tâche aura une commande `parallel` simplifiée :\n",
    "```Bash\n",
    "# parallel < scripts/cmd.txt\n",
    "cat scripts/prll-exec-cmd.sh\n",
    "sbatch scripts/prll-exec-cmd.sh\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nombre limité de cas en parallèles\n",
    "Le paramètre `--jobs` permet de forcer une limite sur le nombre de\n",
    "processus lancés à la fois. Par exemple, 8 cas avec 2 processus\n",
    "en simultané :\n",
    "```Bash\n",
    "parallel --jobs 2 'echo {} && sleep 3' ::: {1..8}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Exercice** - Aligner des séquences d'ADN\n",
    "Dans le dossier `donnees/`, vous devriez avoir plusieurs\n",
    "fichiers Fasta (`*.fa`) qui ont été créés au premier\n",
    "chapitre via le script de tâche `scripts/blastn-gen-seq.sh`.\n",
    "**Si ce n'est pas le cas**, faites :\n",
    "```Bash\n",
    "sbatch scripts/blastn-gen-seq.sh\n",
    "```\n",
    "\n",
    "On devrait y retrouver :\n",
    "* pour chaque espèce fictive A, B, C et D,\n",
    "  un fichier de séquences d'ADN \"connues\"\n",
    "  * Ces fichiers sont convertis en bases de données Blast\n",
    "* pour 16 espèces \"inconnues\" K à Z, des séquences d'ADN à aligner\n",
    "  sur les séquences \"connues\" des espèces A, B, C et D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On cherche donc à calculer l'alignement de toutes les\n",
    "combinaisons `{A,B,C,D}` x `{K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z}`,\n",
    "ce qui donne 64 combinaisons.\n",
    "Le script de tâche suivant utilise GNU Parallel pour calculer les\n",
    "différents cas avec 4 processeurs :\n",
    "```Bash\n",
    "cat scripts/blastn-parallel.sh\n",
    "sbatch scripts/blastn-parallel.sh\n",
    "```\n",
    "\n",
    "Pour surveiller l'état de la tâche :\n",
    "```Bash\n",
    "squeue -u $USER\n",
    "ls donnees/res_prll/\n",
    "```\n",
    "À la fin de la tâche, il est bon d'analyser les ressources utilisées :\n",
    "```\n",
    "seff <jobid>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Autres outils\n",
    "* GLOST\n",
    "  [pour des calculs séquentiels seulement](https://docs.alliancecan.ca/wiki/GLOST/fr)\n",
    "\n",
    "* META-Farm\n",
    "  [pour le meilleur de GNU Parallel et GLOST](https://docs.alliancecan.ca/wiki/META-Farm/fr)\n",
    "\n",
    "Alors que les précédents outils s'utilisent bien avec un lot de\n",
    "calculs séquentiels ou parallèles de petite taille (16 processeurs\n",
    "ou moins), **ils ne sont pas** vraiment **appropriés pour**\n",
    "un lot de **longs calculs parallèles de plus grande taille**\n",
    "(plus de 16 processeurs par calcul) :\n",
    "1. on veut éviter les longues tâches qui dépassent trois (3) jours et\n",
    "1. on veut réduire le risque de subir une défaillance matérielle.\n",
    "\n",
    "C'est pourquoi, dans certains cas, il vaut\n",
    "mieux utiliser les vecteurs de tâches."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vecteurs de tâches\n",
    "Dans le cas où un même programme doit être exécuté avec différentes\n",
    "combinaisons de paramètres, il y a moyen de soumettre un seul\n",
    "[vecteur de tâches](https://docs.alliancecan.ca/wiki/Job_arrays/fr)\n",
    "et de coder le script de tâche de telle sorte que les paramètres\n",
    "seront déterminés **en fonction d'un indice unique** du vecteur de tâches.\n",
    "\n",
    "![Fonctionnement des vecteurs de tâches](images/vecteur-taches.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pour soumettre un vecteur de tâches** à l'ordonnanceur\n",
    "Slurm, **on doit ajouter l'option** `--array=<indices>`\n",
    "à l'entête `#SBATCH` du script de tâche.\n",
    "Voir [quelques exemples ici](https://docs.alliancecan.ca/wiki/Job_arrays/fr).\n",
    "\n",
    "L'identifiant d'une tâche Slurm dans un vecteur de tâches contient :\n",
    "* L'identifiant du vecteur de tâches\n",
    "* Caractère de soulignement (`_`)\n",
    "* L'indice unique associé à la tâche\n",
    "\n",
    "**Par exemple :** `25249551_15`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans le script de tâche, la **variable d'environnement**\n",
    "`$SLURM_ARRAY_TASK_ID` peut être utilisée pour retrouver la valeur\n",
    "actuelle de l'indice unique associé à la tâche en cours d'exécution.\n",
    "Il s'agit d'un **entier parmi** les `<indices>`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La variable `$SLURM_ARRAY_TASK_ID` peut être utilisée de différentes\n",
    "façons. L'exemple ci-dessous utilise `$N`, mais\n",
    "`$SLURM_ARRAY_TASK_ID` fonctionne de la même manière :\n",
    "```Bash\n",
    "export N=71  # Requis uniquement pour cet exemple\n",
    "\n",
    "echo fichier.$N\n",
    "echo répertoire-$N\n",
    "```\n",
    "\n",
    "![Entier à coordonnées 2D](images/n2r_c.svg)\n",
    "```Bash\n",
    "PARAM_R=$((N / 12))  # Division entière\n",
    "PARAM_C=$((N % 12))  # Modulo (reste de division)\n",
    "echo $PARAM_R $PARAM_C\n",
    "\n",
    "head -n $((PARAM_R + 1)) scripts/param.txt | tail -1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Exercice** - Vecteur de tâches\n",
    "Lancez le vecteur de tâches :\n",
    "```Bash\n",
    "cat scripts/blastn-array.sh\n",
    "sbatch scripts/blastn-array.sh\n",
    "\n",
    "squeue -u $USER\n",
    "```\n",
    "\n",
    "Après l'exécution des quatre tâches, inspectez les résultats :\n",
    "```Bash\n",
    "ls slurm-*_*.out\n",
    "ls -l donnees/res_array/\n",
    "```\n",
    "\n",
    "* **Corrigez le script de tâche** pour que les 16 inconnues K à Z\n",
    "  soient traitées, avec une limite de **quatre** tâches à la fois.\n",
    "* Relancez le vecteur de tâches pour tester la correction.\n",
    "* Utilisez la commande `seff` pour étudier une des 16 tâches."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Points à retenir\n",
    "* **GNU Parallel**\n",
    "  [pour lancer de multiples combinaisons de paramètres](https://docs.alliancecan.ca/wiki/GNU_Parallel/fr)\n",
    "\n",
    "```Bash\n",
    "parallel 'gabarit_cmd({1})' ::: valeurs1\n",
    "parallel 'gabarit_cmd({1}, {2})' ::: valeurs1 ::: valeurs2\n",
    "parallel -C <sep> 'gabarit_cmd({1}, {2})' :::: paires_param.txt\n",
    "parallel --jobs 'N_cas_par_noeud' < liste_commandes.txt\n",
    "```\n",
    "\n",
    "* **Vecteurs de tâches**\n",
    "  [pour lancer une série de longues ou de larges tâches](https://docs.alliancecan.ca/wiki/Job_arrays/fr)\n",
    "\n",
    "```Bash\n",
    "# $SLURM_ARRAY_TASK_ID aura une seule valeur dans ...\n",
    "sbatch --array=0-7      # [0, 7]\n",
    "sbatch --array=1,3,5,7  # {1,3,5,7}\n",
    "sbatch --array=1-7:3    # {1,4,7}\n",
    "sbatch --array=0-99%10  # [0, 99], mais 10 tâches à la fois\n",
    "```"
   ]
  },
  {
   "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
}