2-mpi.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50aabbf7-5cf0-4eb8-a5f2-b91861c410a0",
   "metadata": {},
   "source": [
    "# Premiers pas avec MPI"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36cb8e06-833c-44b6-bbff-147d2f0ec51f",
   "metadata": {},
   "source": [
    "## Qu'est-ce que MPI?\n",
    "\n",
    "* **Message Passing Interface** (interface de transmission de messages)\n",
    "* Ce n'est **pas** un langage de programmation\n",
    "* C'est une **bibliothèque de fonctions** qu'on peut\n",
    "  appeler à partir du Fortran, du C ou encore du C++\n",
    "* C'est une [norme officielle](https://www.mpi-forum.org/docs/)\n",
    "  (de MPI 1.0 en 1994 à\n",
    "  [MPI 4.1](https://www.mpi-forum.org/docs/mpi-4.1/mpi41-report.pdf)\n",
    "  depuis novembre 2023)\n",
    "* Hors norme, il existe des interfaces en d'autres langages\n",
    "  (Python, R, Perl, Java)\n",
    "    * Par exemple, [`mpi4py`](https://mpi4py.readthedocs.io/en/latest/overview.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bebbb642-dcf8-4bde-93f9-79c360c1e9f6",
   "metadata": {},
   "source": [
    "## Structure d'un code MPI\n",
    "\n",
    "* Dans un programme MPI, on doit d'abord appeler la fonction\n",
    "  [`MPI_Init()`](https://www.mpi-forum.org/docs/mpi-4.1/mpi41-report.pdf#subsection.11.2.1)\n",
    "* Avant de terminer l'exécution, on appelle la fonction\n",
    "  [`MPI_Finalize()`](https://www.mpi-forum.org/docs/mpi-4.1/mpi41-report.pdf#subsection.11.2.2)\n",
    "* Tous les autres appels à MPI doivent se\n",
    "  faire entre les deux nommés ci-dessus\n",
    "* Pour une fin d'exécution prématurée, un\n",
    "  processus appelle la fonction\n",
    "  [`MPI_Abort()`](https://www.mpi-forum.org/docs/mpi-4.1/mpi41-report.pdf#subsection.11.4.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90b73dab-fddd-4083-80a4-9a2b0ff82e7b",
   "metadata": {},
   "source": [
    "```C\n",
    "MPI_init()\n",
    "\n",
    "// Code parallèle\n",
    "\n",
    "// En cas d’erreur\n",
    "{\n",
    "    MPI_Abort()\n",
    "}\n",
    "\n",
    "MPI_Finalize()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95bf917f-a104-408b-82f4-832e727c16a0",
   "metadata": {},
   "source": [
    "### Programme MPI de base\n",
    "\n",
    "En C :\n",
    "\n",
    "```C\n",
    "#include \"mpi.h\"\n",
    "\n",
    "int main(int argc, char **argv)\n",
    "{\n",
    "    int ierr;\n",
    "    ierr = MPI_Init(&argc, &argv);\n",
    "\n",
    "    /* On insère le reste du programme ici. */\n",
    "\n",
    "    ierr = MPI_Finalize();\n",
    "}\n",
    "```\n",
    "\n",
    "En Python :\n",
    "\n",
    "```Python\n",
    "#!/usr/bin/env python\n",
    "\n",
    "from mpi4py import MPI  # MPI.Init() implicite\n",
    "\n",
    "def main():\n",
    "    \"\"\"\n",
    "    Programme principal\n",
    "    \"\"\"\n",
    "\n",
    "    MPI.Finalize()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4da31386-cc47-4daf-a46f-5a3701b3189d",
   "metadata": {},
   "source": [
    "## Parallélisation explicite\n",
    "\n",
    "* C'est la responsabilité de la programmeuse ou du\n",
    "  programmeur de dire à chaque processus ce qu'il doit\n",
    "  faire selon son _rang_ dans la liste des processus\n",
    "* Chaque processus échange avec les autres les données\n",
    "  dont ils ont besoin pour résoudre un problème\n",
    "* Un code source appelant la bibliothèque MPI utilise donc (en\n",
    "  général) le concept de programme unique travaillant sur des\n",
    "  données multiples (_Single Program, Multiple Data_ ou SPMD)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1592c52e-1077-47bb-8b62-f4655ced75fe",
   "metadata": {},
   "source": [
    "### Communicateurs\n",
    "\n",
    "* Un communicateur désigne un ***groupe de\n",
    "  processus*** pouvant communiquer ensemble\n",
    "* La majorité des fonctions MPI prennent comme argument un\n",
    "  communicateur pour savoir sur quel groupe de processus agir\n",
    "* Un communicateur initial englobe tous les processus :\n",
    "    * `MPI_COMM_WORLD`\n",
    "      [en **C**](https://www.mpi-forum.org/docs/mpi-4.1/mpi41-report.pdf#section.11.2)\n",
    "    * `MPI.COMM_WORLD`\n",
    "      [en **Python**](https://mpi4py.readthedocs.io/en/latest/reference/mpi4py.MPI.COMM_WORLD.html)\n",
    "* On peut en créer d'autres au besoin\n",
    "\n",
    "![Communicateurs (groupes)](images/communicators.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e62b6ea7-f2d7-470d-8a4e-3c4c518a75d1",
   "metadata": {},
   "source": [
    "### Nombre de processus et un rang unique\n",
    "\n",
    "* Dans l'optique SPMD, un processus doit savoir\n",
    "  le **nombre de processus total** (`size`) et\n",
    "  **son rang** (`rank`) dans le communicateur\n",
    "* Le rang est un identifiant entier unique dont\n",
    "  la valeur est de `0` à `size-1`, inclusivement\n",
    "\n",
    "[En **C**](https://www.mpi-forum.org/docs/mpi-4.1/mpi41-report.pdf#subsection.7.4.1) :\n",
    "\n",
    "```C\n",
    "int MPI_Comm_size(MPI_Comm comm, int *size)\n",
    "int MPI_Comm_rank(MPI_Comm comm, int *rank)\n",
    "```\n",
    "\n",
    "[En **Python**](https://mpi4py.readthedocs.io/en/latest/reference/mpi4py.MPI.Comm.html#mpi4py.MPI.Comm.Get_rank) :\n",
    "\n",
    "```Python\n",
    "size = comm.Get_size()\n",
    "rank = comm.Get_rank()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13d2a29a-0608-4f91-bfd9-908cdb41de32",
   "metadata": {},
   "source": [
    "#### Exemple en C - `demos/bonjour.c`\n",
    "\n",
    "```C\n",
    "#include <stdio.h>\n",
    "#include <mpi.h>\n",
    "\n",
    "int main(int argc, char *argv[])\n",
    "{\n",
    "    int p, np;\n",
    "\n",
    "    MPI_Init(&argc, &argv);\n",
    "\n",
    "    MPI_Comm_rank(MPI_COMM_WORLD, &p);\n",
    "    MPI_Comm_size(MPI_COMM_WORLD, &np);\n",
    "    printf(\"Ici le processus %d de %d\\n\", p, np);\n",
    "\n",
    "    MPI_Finalize();\n",
    "    return 0;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73b20db5-3b80-41c6-9d57-cfc4b13afd9d",
   "metadata": {},
   "source": [
    "#### Exemple en Python - `demos/bonjour.py`\n",
    "\n",
    "```Python\n",
    "#!/usr/bin/env python\n",
    "\n",
    "from mpi4py import MPI  # MPI.Init() implicite\n",
    "\n",
    "def main():\n",
    "    \"\"\"\n",
    "    Programme principal\n",
    "    \"\"\"\n",
    "\n",
    "    p = MPI.COMM_WORLD.Get_rank()\n",
    "    np = MPI.COMM_WORLD.Get_size()\n",
    "    print(f'Ici le processus {p} de {np}')\n",
    "\n",
    "    MPI.Finalize()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be406fa0-7b42-4093-bda0-837271b6f531",
   "metadata": {},
   "source": [
    "## Environnement requis pour utiliser MPI\n",
    "\n",
    "En **C** :\n",
    "\n",
    "* Un module permettant de compiler et d’exécuter un\n",
    "  programme MPI est chargé par défaut (`openmpi/4.1.5`)\n",
    "* Pour voir tous les modules chargés :\n",
    "```Bash\n",
    "module list\n",
    "```\n",
    "* Pour voir les différentes versions disponibles de Open MPI :\n",
    "```Bash\n",
    "module spider openmpi\n",
    "```\n",
    "* Pour voir les dépendances possibles :\n",
    "```Bash\n",
    "module spider openmpi/4.1.5\n",
    "```\n",
    "\n",
    "En **Python** :\n",
    "\n",
    "* Un module `mpi4py` est requis, mais n'est pas chargé par défaut :\n",
    "```Bash\n",
    "module spider mpi4py\n",
    "module spider mpi4py/3.1.4\n",
    "module load mpi4py/3.1.4  # python/3.11.5 est chargé automatiquement\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "148ea4fb-2be1-4ded-a914-f2a02d7b346b",
   "metadata": {},
   "source": [
    "### Compilation d'un programme MPI\n",
    "\n",
    "En **C** :\n",
    "\n",
    "* Lorsque l’environnement est adéquatement configuré pour la\n",
    "  version désirée de MPI, on a accès aux commandes `mpif90`,\n",
    "  `mpicc` et `mpicxx` que l'on peut utiliser à la place des\n",
    "  compilateurs Fortran, C et C++, respectivement. Par exemple :\n",
    "```Bash\n",
    "mpicc -o programme source.c\n",
    "```\n",
    "* Ces commandes trouvent les fichiers d'inclusion et les\n",
    "  bibliothèques ou les modules Fortran nécessaires à MPI\n",
    "\n",
    "En **Python** :\n",
    "\n",
    "* La compilation se fait lors de l'exécution du script."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdacf7c2-b245-45a1-9979-e4baf0c4f997",
   "metadata": {},
   "source": [
    "### Lancement d'un programme MPI\n",
    "\n",
    "Le lancement d'un programme MPI se fait typiquement à l'aide d'une\n",
    "commande souvent appelée `mpirun` ou `mpiexec`. Par exemple :\n",
    "\n",
    "```Bash\n",
    "mpiexec -n 120 ./programme\n",
    "# ou\n",
    "mpiexec -n 120 python script.py\n",
    "```\n",
    "\n",
    "Notes :\n",
    "\n",
    "* Chacune des commandes ci-dessus lancerait 120 processus identiques,\n",
    "  chacun exécutant le `programme` ou `python` sur un processeur\n",
    "* Avec l’ordonnanceur [Slurm](https://slurm.schedmd.com/),\n",
    "  nous allons plutôt utiliser la commande `srun`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0a95fc5-6985-422c-8573-53117a8c7212",
   "metadata": {},
   "source": [
    "#### Exemple d’exécution\n",
    "\n",
    "```Bash\n",
    "$ srun -n 10 hostname\n",
    "compute-node2\n",
    "compute-node2\n",
    "compute-node2\n",
    "compute-node2\n",
    "compute-node2\n",
    "compute-node1\n",
    "compute-node1\n",
    "compute-node1\n",
    "compute-node1\n",
    "compute-node1\n",
    "\n",
    "$\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e01864a-260e-4781-bfe2-a6b8b109ec10",
   "metadata": {},
   "source": [
    "### Exercice #1 - Premier lancement\n",
    "\n",
    "1. Validez les modules et chargez les modules manquants, au besoin :\n",
    "```Bash\n",
    "module list\n",
    "module load ...\n",
    "```\n",
    "2. Dans le répertoire `demos/`, compilez le code\n",
    "   `bonjour.c` ou localisez le fichier `bonjour.py`\n",
    "3. Avec `srun`, lancez 4 processus en parallèle\n",
    "   avec l'exécutable compilé ou avec `python`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73a7dfb9-176c-46ac-a9cf-a3a70891398d",
   "metadata": {},
   "source": [
    "## Les communications via MPI\n",
    "\n",
    "### Types de données\n",
    "\n",
    "En **C** :\n",
    "\n",
    "* Les fonctions MPI transférant des données sont conçues de façon\n",
    "  générique et peuvent donc traiter des données de différents types\n",
    "* Par exemple, en C/C++, pour envoyer des nombres à\n",
    "  virgule flottante à double précision, on utilisera les\n",
    "  fonctions de communication avec l'argument `MPI_DOUBLE`\n",
    "* On peut passer des scalaires ou des vecteurs, mais\n",
    "  on doit indiquer le nombre d'éléments du type indiqué\n",
    "\n",
    "Les principaux\n",
    "[types de données](https://www.mpi-forum.org/docs/mpi-4.1/mpi41-report.pdf#page=76) sont :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a688e725-3979-467f-b641-9a74cb3ef0a5",
   "metadata": {},
   "source": [
    "Type en C/C++ | Type MPI\n",
    "--------------|-------------\n",
    "`char`        | `MPI_CHAR`\n",
    "`short`       | `MPI_SHORT`\n",
    "`int`         | `MPI_INT`\n",
    "`long int`    | `MPI_LONG`\n",
    "`float`       | `MPI_FLOAT`\n",
    "`double`      | `MPI_DOUBLE`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90a64162-098a-4b9b-aaac-8cb56034aba5",
   "metadata": {},
   "source": [
    "En **Python** :\n",
    "\n",
    "* La bibliothèque `mpi4py`\n",
    "  [_sérialise_](https://fr.wikipedia.org/wiki/S%C3%A9rialisation)\n",
    "  automatiquement tout objet et envoie simplement un vecteur d'octets\n",
    "* À la réception d'un message, l'objet est reconstitué\n",
    "* La gestion des types se fait donc automatiquement"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48ed4818-3bad-4e72-a6e5-beeba666116e",
   "metadata": {},
   "source": [
    "### Types de communications\n",
    "\n",
    "Il y a deux grands types de communications :\n",
    "\n",
    "* **Communications point-à-point**\n",
    "  ([chapitre 3](3-point-a-point.ipynb)) :\n",
    "  deux processus d'un même communicateur\n",
    "  communiquent au moyen de deux actions :\n",
    "    * Un envoi\n",
    "    * Une réception\n",
    "* **Communications collectives**\n",
    "  ([chapitre 4](4-collectives.ipynb)) :\n",
    "  tous les processus d'un même communicateur\n",
    "  appellent la même fonction et communiquent ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3dbef11f-1c17-42e9-926b-6a5f31460dea",
   "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": 5
}