3-point-a-point.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e90f3f2a-0edb-4d88-9b0c-b160a53527f5",
   "metadata": {},
   "source": [
    "# Communications point-à-point\n",
    "\n",
    "* Elles sont _locales_, c'est-à-dire que seuls **deux\n",
    "  processus** sont impliqués : ils sont les seuls à\n",
    "  appeler réciproquement des fonctions de communication,\n",
    "  donc ils sont les seuls à participer à cet échange\n",
    "    * Note : les appels aux fonctions d'envoi et de réception\n",
    "      viennent toujours par paires sur des processus différents\n",
    "* Les fonctions d’envoi et de réception peuvent être bloquantes ou non"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c347c05f-ef9f-4b02-9d67-86a588d85ac6",
   "metadata": {},
   "source": [
    "## `MPI_Send()` (bloquant)\n",
    "\n",
    "[En **C**](https://www.mpi-forum.org/docs/mpi-4.1/mpi41-report.pdf#section.3.2) :\n",
    "\n",
    "```C\n",
    "int MPI_Send(void *envoi, int compte, MPI_Datatype type,\n",
    "             int dest, int etiquette, MPI_Comm comm)\n",
    "```\n",
    "\n",
    "* `envoi` : adresse en mémoire du premier élément à envoyer\n",
    "* `compte` : nombre d’éléments de type `type`\n",
    "* `type` : type MPI tel que `MPI_INT`, `MPI_DOUBLE`, etc.\n",
    "* `dest` : rang du processus recevant\n",
    "* `etiquette` : nombre entier identifiant le type de transfert"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87d7cd1b-7231-46ef-9f66-5aa3a569ce41",
   "metadata": {},
   "source": [
    "[En **Python**](https://mpi4py.readthedocs.io/en/latest/reference/mpi4py.MPI.Comm.html#mpi4py.MPI.Comm.send) :\n",
    "\n",
    "```Python\n",
    "comm.send(objet, dest=dest, tag=etiquette)\n",
    "```\n",
    "\n",
    "* `objet` : n'importe quel objet sérialisable via\n",
    "  [`pickle`](https://docs.python.org/3/library/pickle.html#module-pickle)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "370d0313-6453-4b7f-9a84-375cae86e175",
   "metadata": {},
   "source": [
    "## `MPI_Recv()` (bloquant)\n",
    "\n",
    "[En **C**](https://www.mpi-forum.org/docs/mpi-4.1/mpi41-report.pdf#subsection.3.2.4) :\n",
    "\n",
    "```C\n",
    "int MPI_Recv(void *recept, int compte, MPI_Datatype type,\n",
    "             int source, int etiquette, MPI_Comm comm,\n",
    "             MPI_Status *etat)\n",
    "```\n",
    "\n",
    "* `recept` : adresse en mémoire du premier élément à recevoir\n",
    "* `compte` : nombre maximal d'éléments de type `type`\n",
    "* `source` : rang du processus transmettant,\n",
    "  ça peut être `MPI_ANY_SOURCE`\n",
    "* `etiquette` : ça peut être `MPI_ANY_TAG`\n",
    "* `etat` : informations sur le transfert\n",
    "    * `.count` : nombre d’éléments reçus de type `type`\n",
    "    * `.MPI_SOURCE` : rang de la source des données\n",
    "    * `.MPI_TAG` : étiquette du transfert"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3814bbce-5760-42eb-b3e7-badd7d7b4624",
   "metadata": {},
   "source": [
    "[En **Python**](https://mpi4py.readthedocs.io/en/latest/reference/mpi4py.MPI.Comm.html#mpi4py.MPI.Comm.recv) :\n",
    "\n",
    "```Python\n",
    "objet = comm.recv(source=source, tag=etiquette, status=etat)\n",
    "```\n",
    "\n",
    "* `objet` : une variable ou une partie d'un objet modifiable,\n",
    "  pour recevoir l'objet désérialisé\n",
    "* `source` : `MPI.ANY_SOURCE` (valeur par défaut) ou un rang précis\n",
    "* `etiquette` : `MPI.ANY_TAG` (valeur par défaut) ou un nombre précis\n",
    "* `etat` : `None` (valeur par défaut) ou objet de type `MPI.Status`\n",
    "    * `.count` : nombre d’octets reçus\n",
    "    * `.source` : rang de la source des données\n",
    "    * `.tag` : étiquette du transfert"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f9e6bff-772b-4ec0-a499-5b5534274f20",
   "metadata": {},
   "source": [
    "### Exemple - `MPI_Send` et `MPI_Recv`\n",
    "\n",
    "Chaque processus a ses propres variables `a` et `b`.\n",
    "Le processus 2 envoie la valeur de son `a` vers\n",
    "le processus 0 qui reçoit cette valeur via son `b`.\n",
    "\n",
    "![Figure - Communication point à point](images/mpi_point2point.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2c0784e-e3d6-49d2-88f7-b00a2e95aec1",
   "metadata": {},
   "source": [
    "En **C** :\n",
    "\n",
    "```C\n",
    "if (proc == 2) {\n",
    "    MPI_Send(&a, 1, MPI_INT, 0, 746, MPI_COMM_WORLD);\n",
    "}\n",
    "else if (proc == 0) {\n",
    "    MPI_Recv(&b, 1, MPI_INT, 2, 746, MPI_COMM_WORLD, &etat);\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebbddd3a-a4d0-426c-bfc0-f5dd923282ec",
   "metadata": {},
   "source": [
    "En **Python** :\n",
    "\n",
    "```Python\n",
    "if proc == 2:\n",
    "    MPI.COMM_WORLD.send(a, dest=0, tag=746)\n",
    "elif proc == 0:\n",
    "    b = MPI.COMM_WORLD.recv(source=2, tag=746)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be4f63de-b409-4d16-99c2-b2a9f6c08426",
   "metadata": {},
   "source": [
    "### Exercice #2 - Envoi d'une matrice\n",
    "\n",
    "Votre objectif : envoyer une matrice 4x4 du processus 0 au processus 1 :\n",
    "\n",
    "1. Dans le répertoire `exercices`, éditez le fichier `send_matrix.c`\n",
    "   (ou `send_matrix.py`) pour programmer le transfert de la matrice\n",
    "1. Compilez le code et lancez-le avec deux (2) processus"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89bd805b-4c5e-4983-8188-01043770a0e0",
   "metadata": {},
   "source": [
    "## Éviter les situations d'interblocage\n",
    "\n",
    "Soit le code C suivant :\n",
    "\n",
    "```C\n",
    "if (proc == 0) {\n",
    "    MPI_Ssend(&a, 1, MPI_INT, 2, 10, MPI_COMM_WORLD);\n",
    "    MPI_Recv( &b, 1, MPI_INT, 2, 11, MPI_COMM_WORLD, &etat);\n",
    "}\n",
    "else if (proc == 2) {\n",
    "    MPI_Ssend(&b, 1, MPI_INT, 0, 11, MPI_COMM_WORLD);\n",
    "    MPI_Recv( &a, 1, MPI_INT, 0, 10, MPI_COMM_WORLD, &etat);\n",
    "}\n",
    "```\n",
    "\n",
    "* [`MPI_Ssend()`](https://www.mpi-forum.org/docs/mpi-4.1/mpi41-report.pdf#page=70)\n",
    "  (ou [`comm.Send()`](https://mpi4py.readthedocs.io/en/latest/reference/mpi4py.MPI.Comm.html#mpi4py.MPI.Comm.Send)\n",
    "  en Python) est une version sans mémoire\n",
    "  tampon, ce qui la rend toujours bloquante\n",
    "* Dans le cas ci-haut, les deux processus attendent que l’autre\n",
    "  fasse appel à `MPI_Recv`. Bref, ce code est **erroné**!\n",
    "* Avec `MPI_Send` (ou `comm.send()` en Python), le code\n",
    "  resterait à risque ; la quantité de mémoire tampon étant\n",
    "  limitée, le code bloquera lors de l’échange de gros messages"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0154fd09-1174-4e3d-808c-0816e005632b",
   "metadata": {},
   "source": [
    "### Solution 1\n",
    "\n",
    "On change l'ordre des appels à `MPI_Ssend`\n",
    "et `MPI_Recv` sur un des deux processus :\n",
    "\n",
    "```C\n",
    "if (proc == 0) {\n",
    "    MPI_Ssend(&a, 1, MPI_INT, 2, 10, MPI_COMM_WORLD);\n",
    "    MPI_Recv( &b, 1, MPI_INT, 2, 11, MPI_COMM_WORLD, &etat);\n",
    "}\n",
    "else if (proc == 2) {\n",
    "    MPI_Recv( &a, 1, MPI_INT, 0, 10, MPI_COMM_WORLD, &etat);\n",
    "    MPI_Ssend(&b, 1, MPI_INT, 0, 11, MPI_COMM_WORLD);\n",
    "}\n",
    "```\n",
    "\n",
    "On peut généraliser la technique à plus de processus :\n",
    "\n",
    "* Les processus pairs commencent par envoyer\n",
    "* Les processus impairs commencent par recevoir"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cae823b-34e0-4352-ac7d-1752a73ffe41",
   "metadata": {},
   "source": [
    "### Exercice #3 - Échange de vecteurs\n",
    "\n",
    "L'objectif : échanger un petit vecteur de données.\n",
    "\n",
    "1. Dans le répertoire `exercices`, éditez le fichier `exchange.c`\n",
    "   (ou `exchange.py`) pour programmer l’échange de données\n",
    "1. Compilez le code et lancez-le avec deux (2) processus"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9551e8a-2256-424f-993c-d17993821c3b",
   "metadata": {},
   "source": [
    "### Solution 2\n",
    "\n",
    "On utilise des communications non bloquantes pour démarrer\n",
    "les transferts. Ainsi, même si l'envoi n'est pas terminé,\n",
    "on peut commencer la réception tout en évitant l'interblocage."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "162853c5-5e5a-46a7-bde1-35d065474c05",
   "metadata": {},
   "source": [
    "Exemple en **C** :\n",
    "\n",
    "```C\n",
    "if (proc == 0) {\n",
    "    MPI_Isend(&a, 1, MPI_INT, 2, 10, MPI_COMM_WORLD, &requete);\n",
    "    MPI_Recv( &b, 1, MPI_INT, 2, 11, MPI_COMM_WORLD, &etat);\n",
    "}\n",
    "else if (proc == 2) {\n",
    "    MPI_Isend(&b, 1, MPI_INT, 0, 11, MPI_COMM_WORLD, &requete);\n",
    "    MPI_Recv( &a, 1, MPI_INT, 0, 10, MPI_COMM_WORLD, &etat);\n",
    "}\n",
    "\n",
    "MPI_Wait(&requete, &etat);\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7885947-0371-4951-9656-7d757ae3bb4c",
   "metadata": {},
   "source": [
    "Exemple en **Python** :\n",
    "\n",
    "```Python\n",
    "if proc == 0:\n",
    "    requete = comm.isend(a, dest=2, tag=10)\n",
    "    b = comm.recv(source=2, tag=11)\n",
    "elif proc == 2:\n",
    "    requete = comm.isend(b, dest=0, tag=11)\n",
    "    a = comm.recv(source=0, tag=10)\n",
    "\n",
    "requete.wait()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6d2c8c7-425b-470f-92f0-76ce07c4a09f",
   "metadata": {},
   "source": [
    "## Communications non bloquantes\n",
    "\n",
    "[En **C**](https://www.mpi-forum.org/docs/mpi-4.1/mpi41-report.pdf#subsection.3.7.2) :\n",
    "\n",
    "```C\n",
    "int MPI_Isend(void *envoi, int compte, MPI_Datatype type,\n",
    "              int dest, int etiquette, MPI_Comm comm,\n",
    "              MPI_Request *requete)\n",
    "\n",
    "int MPI_Irecv(void *recept, int compte, MPI_Datatype type,\n",
    "              int source, int etiquette, MPI_Comm comm,\n",
    "              MPI_Request *requete)\n",
    "```\n",
    "\n",
    "* Il n'est pas nécessaire que l'envoi et la réception\n",
    "  soient tous les deux bloquants ou non bloquants\n",
    "  (toutes les combinaisons sont permises)\n",
    "* Après l'appel à `MPI_Isend` ou `MPI_Irecv`,\n",
    "  on doit utiliser l'argument `requete` pour\n",
    "  s'assurer que la communication est complétée"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a12fa9e5-300f-48ae-9797-2a0d3de23276",
   "metadata": {},
   "source": [
    "```C\n",
    "int MPI_Wait(MPI_Request *requete, MPI_Status *etat)\n",
    "```\n",
    "\n",
    "* `MPI_Wait` est bloquante.\n",
    "  Elle retourne quand la communication liée à `requete` est terminée\n",
    "* Quand la communication a terminé, on peut\n",
    "  réutiliser les vecteurs transmis ou reçus"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71bfed31-e1fe-4729-a989-21f909e39345",
   "metadata": {},
   "source": [
    "[En **Python**](https://mpi4py.readthedocs.io/en/latest/reference/mpi4py.MPI.Comm.html) :\n",
    "\n",
    "```Python\n",
    "requete = comm.isend(envoi, dest, tag=0)\n",
    "requete.wait()\n",
    "\n",
    "requete = comm.irecv(source=ANY_SOURCE, tag=ANY_TAG)\n",
    "recept = requete.wait()\n",
    "```\n",
    "\n",
    "* Lors de la réception, c'est\n",
    "  [`requete.wait()`](https://mpi4py.readthedocs.io/en/latest/reference/mpi4py.MPI.Request.html#mpi4py.MPI.Request.wait)\n",
    "  qui retourne l'objet reçu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c4c5125-e8a5-404d-825f-9e930c9e28d4",
   "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
}