corrections mineures

GroupeCalcul · Sep 24, 2024 · 6395579 · 6395579
1 parent e5a6e25
commit 6395579
Show file tree

Hide file tree

Showing 5 changed files with 73 additions and 50 deletions.
diff --git a/_quarto.yml b/_quarto.yml
@@ -2,7 +2,7 @@ project:
   type: website
 
 website:
-  title: "ANF R Calcul Rmpi"
+  title: ""
   description: "Supports du cours Rmpi"
   site-url: "https://groupecalcul.github.io/ANFRCalculRmpi"
   repo-url: "https://github.com/GroupeCalcul/ANFRCalculRmpi"
@@ -17,12 +17,14 @@ website:
       - href: com_collectives.qmd
         text: Communications collectives
       - href: exercice.qmd
-        text: Travaux pratiques
+        text: Conclusion
     tools:
       - icon: github
         href: https://github.com/GroupeCalcul/ANFRCalculRmpi
 
 format:
   html:
-    theme: cosmo
+    theme:
+       light: flatly
+       dark: darkly
     toc: true
diff --git a/com_collectives.qmd b/com_collectives.qmd
@@ -1,5 +1,5 @@
 ---
-title: "Communications collectives"
+title: "Rmpi : Communications collectives"
 lang: fr
 format:
   html:
@@ -34,7 +34,6 @@ Il y a trois types de sous-programmes :
  - diffusion globale de données : `mpi.bcast`
  - diffusion sélective de données : `mpi.scatter`
  - collecte de données réparties : `mpi.gather`
- - collecte par tous les processus de données réparties : `mpi.allgather`
 
 3. ceux qui, en plus de la gestion des communications, effectuent des opérations sur les données transférées :
 
@@ -44,8 +43,7 @@ Il y a trois types de sous-programmes :
 
 ## Diffusion générale `mpi.bcast`
 
-1. Envoi, à partir de l’adresse message, d’un message constitué de longueur élément de type `type_message`, par le processus `rank`, à tous les autres processus du communicateur `comm`.
-
+1. Envoi, à partir de l’adresse `obj`, d’un message constitué de type `type`, par le processus `rank`, à tous les autres processus du communicateur `comm`.
 2. Réception de ce message à l’adresse message pour les processus autre que `rank`.
 
 ```R
@@ -67,6 +65,10 @@ invisible(mpi.barrier(comm=0))
 invisible(mpi.finalize())
 ```
 
+::: {.callout-warning}
+Habituellement avec MPI, le même appel `mpi.bcast` devrait pouvoir être effectué sur tous les processus. Je n'ai pas réussi à le faire avec Rmpi...
+:::
+
 ```bash
 $ mpirun -np 4 Rscript bcast.R
 vector on  3  =  1 2 3 4
@@ -105,10 +107,10 @@ invisible(mpi.finalize())
 
 ```bash
 $ mpirun -np 4 Rscript scatter.R
-data on  0 : 1 2 9 10 17 18
-data on  3 : 7 8 15 16 23 24
-data on  2 : 5 6 13 14 21 22
-data on  1 : 3 4 11 12 19 20
+data on 0 : 1 2 9 10 17 18
+data on 3 : 7 8 15 16 23 24
+data on 2 : 5 6 13 14 21 22
+data on 1 : 3 4 11 12 19 20
 ```
 
 ## Collecte `mpi.gather`
@@ -126,6 +128,10 @@ Correspond à un `mpi.gather` suivi d’un `mpi.bcast`
 
 ![](allgather.png)
 
+::: {.callout-warning}
+Attention avec ces fonctions `mpi.all*` elles peuvent être très gourmandes...
+:::
+
 # Réductions réparties
 
 Une réduction est une opération appliquée à un ensemble d’éléments pour en
@@ -134,21 +140,21 @@ d’un vecteur ou la recherche de l’élément de valeur maximum dans un vecteu
 
 MPI propose des sous-programmes de haut-niveau pour opérer des réductions
 sur des données réparties sur un ensemble de processus. Le résultat est obtenu
-sur un seul processus (MPI_Reduce()) ou bien sur tous (MPI_Allreduce(),
-qui est en fait équivalent à un MPI_Reduce()suivi d’unMPI_Bcast()).
+sur un seul processus (`mpi.reduce`) ou bien sur tous (`mpi.allreduce`,
+qui est en fait équivalent à un `mpi.reduce` suivi d’un `mpi.bcast`).
 Si plusieurs éléments sont concernés par processus, la fonction de réduction est
 appliquée à chacun d’entre eux (par exemple à tous les éléments d’un vecteur).
 
 ## `mpi.reduce`
 
 Opérations pour réductions réparties
 
- - "sum" Somme des éléments
- - "prod" Produit des éléments
- - "max" Recherche du maximum
- - "min" Recherche du minimum
- - "maxloc" Recherche de l’indice du maximum
- - "minloc" Recherche de l’indice du minimum
+ - "sum" : Somme des éléments
+ - "prod" : Produit des éléments
+ - "max" : Recherche du maximum
+ - "min" : Recherche du minimum
+ - "maxloc" : Recherche de l’indice du maximum
+ - "minloc" : Recherche de l’indice du minimum
 
 ```R
 library(Rmpi)
@@ -178,10 +184,10 @@ invisible(mpi.finalize())
 
 ```bash
 $ mpirun -np 4 Rscript reduce.R
-data on  2 : 5 6 13 14 21 22
-data on  3 : 7 8 15 16 23 24
-data on  0 : 1 2 9 10 17 18
-data on  1 : 3 4 11 12 19 20
+data on 2 : 5 6 13 14 21 22
+data on 3 : 7 8 15 16 23 24
+data on 0 : 1 2 9 10 17 18
+data on 1 : 3 4 11 12 19 20
 
 16 20 48 52 80 84
 ```

diff --git a/com_point_a_point.qmd b/com_point_a_point.qmd
@@ -1,5 +1,5 @@
 ---
-title: "Communications point à point"
+title: "Rmpi : communications point à point"
 lang: fr
 format:
   html:
@@ -14,11 +14,11 @@ L’émetteur et le récepteur sont identifiés par leur rang dans le communicat
 L’entité transmise entre deux processus est appelée message.
 Un message est caractérisé par son enveloppe. Celle-ci est constituée :
 
-- du rang du processus émetteur ;
-- du rang du processus récepteur ;
-- de l’étiquette (tag) du message ;
-- du communicateur qui définit le groupe de processus et le contexte de communication.
-- Les données échangées sont typées (entiers, réels, etc...)
+- du rang du processus émetteur `source`;
+- du rang du processus récepteur `dest` ;
+- de l’étiquette du message `tag`;
+- du communicateur qui définit le groupe de processus et le contexte de communication `comm`.
+- Les données échangées sont typées (entiers, réels, etc...) `type`.
 
 Cette opération est bloquante : l’exécution reste bloquée jusqu’à ce que le contenu de
 message puisse être réécrit sans risque d’écraser la valeur qui devait être envoyée.
@@ -29,10 +29,15 @@ message puisse être réécrit sans risque d’écraser la valeur qui devait êt
 `type` : 1 pour les entiers, 2 pour les flottants, 3 pour les caractères.
 
 L’appel `mpi.recv` pourra fonctionner avec une opération `mpi.send` si ces
-deux appels ont la même enveloppe (`rang_source`, `rang_dest`, `etiquette`, `comm`).
+deux appels ont la même enveloppe (`source`, `dest`, `tag`, `comm`).
 
 Cette opération est bloquante : l’exécution reste bloquée jusqu’à ce que le contenu de message corresponde au message reçu.
 
+::: {.callout-note}
+Les fonctions `mpi.send.Robj` et `mpi.recv.Robj` permettent d'envoyer et recevoir des objets R à condition qu'ils soient sérialisables comme les `data.frame` par exemple.
+Il existe des versions non bloquantes `mpi.isend` et `mpi.irecv` ainsi qu'une version contractée `mpi.sendrecv` bidirectionnel. Ces concepts ne seront pas abordés ici.
+:::
+
 ## Exemple 
 
 ```R
@@ -66,9 +71,9 @@ Process 0: Received from process 2 saying: 2
 Process 0: Received from process 3 saying: 3
 ```
 
-# Travaux pratiques MPI – Exercice 2 : Ping-pong
+## Exercice Ping-Pong
 
-L’exercice 2 est décomposé en 3 étapes :
+L’exercice est décomposé en 3 étapes :
 
 1. *Ping*: compléter le script `ping_pong_1.R` de manière à ce que le processus de rang
 0 envoie un message contenant une série aléatoire de 1000 réels au rang 1.

diff --git a/exercice.qmd b/exercice.qmd
@@ -1,5 +1,5 @@
 ---
-title: "Exercice"
+title: "Conclusion"
 lang: fr
 format:
   html:
@@ -13,11 +13,11 @@ format:
 - Limiter au maximum les messages avec un grand volume de données
 - Limiter l'empreinte mémoire en divisant les calculs mais aussi en divisant la mémoire.
 - Il est parfois plus intéressant de faire le même calcul sur tous les processus que de le faire sur un seul et ensuite faire une diffusion
-- Eviter de lire des données en parallèle si vous n'utilisez pas une bibliothèque dédiée (MPI-IO). Lire le fichier sur le processeur 0 puis faire un `bcast` ou mieux un `scatter`. 
+- Eviter de lire des données en parallèle si vous n'utilisez pas une bibliothèque dédiée (MPI-IO). Lire le fichier sur le processeur 0 puis faire un `mpi.bcast` ou mieux un `mpi.scatter`. 
 - Essayer d'équilibrer la charge sur vos processus
-- Jeter un oeil à [pdbMPI](https://github.com/RBigData/pbdMPI)
+- Jeter un oeil à [pdbMPI](https://github.com/RBigData/pbdMPI). La syntaxe me semble plus sympa.
 
-Cet exemple crée autant de vecteurs que de processus initialisés à la valeur du rang. Ces vecteurs sont collectés dans une matrice construite à partir de ces colonnes.
+Dans cet exemple, on crée autant de vecteurs que de processus initialisés à la valeur du rang. Ces vecteurs sont collectés dans une matrice construite par colonnes.
 
 ```R
 library(pbdMPI, quiet = TRUE)
@@ -59,7 +59,10 @@ for(k in 1 : my.loop){
 Sys.time() - start
 ```
 
-Voici la version MPMD, essayer d'en faire une version SPMD et comparer les performances.
+Voici la version MPMD venant de la même source, essayer d'en faire une version SPMD et comparer les performances.
+
+- Pouvez-vous réduire le nombre de messages ?
+- Votre code est-il plus conçis ?
 
 ```R
 

diff --git a/index.qmd b/index.qmd
@@ -8,7 +8,7 @@ format:
     code-fold: true
 ---
 
-Ces supports reprennent très largement les [supports de cours MPI de l'IDRIS](http://www.idris.fr/formations/mpi/) écrits par Dimitri Lecas, Rémi Lacroix, Serge Van Criekingen et Myriam Peyrounette. J'ai utilisé également les références suivantes:
+Ces supports reprennent très largement les [supports de cours MPI de l'IDRIS](http://www.idris.fr/formations/mpi/) écrits par Dimitri Lecas, Rémi Lacroix, Serge Van Criekingen et Myriam Peyrounette. J'ai utilisé également les ressources suivantes:
 
 - [Site officiel de Rmpi](https://fisher.stats.uwo.ca/faculty/yu/Rmpi/)
 - [How to run R programs on University of Maryland HPC facility](https://hpcf.umbc.edu/other-packages/how-to-run-r-programs-on-maya/)
@@ -38,7 +38,6 @@ Le message est constitué de paquets de données transitant du processus émette
 - Les données (variables scalaires, tableaux, etc.) 
 - l’identificateur du processus émetteur
 - le type de la donnée
-- sa longueur
 - l’identificateur du processus récepteur.
 
 ## Architecture des supercalculateurs
@@ -76,6 +75,8 @@ Bibliothèques scientifiques parallèles
 
 ## Exemple C
 
+Cloner le dépôt <https://github.com/GroupeCalcul/ANFRCalculRmpi> pour récupérer les exemples.
+
 ```C
 #include <mpi.h>
 #include <stdio.h>
@@ -114,10 +115,13 @@ par exemple `mpicc`
 ```bash
 > mpicc hello_mpi.c -o hello
 ```
+::: {.callout-note}
+Packages ubuntu : `libopenmpi-dev`et `openmpi-bin`
+:::
 
 Pour exécuter un code MPI, on utilise un lanceur d’application MPI
 qui ordonne le lancement de l’exécution sur un nombre de processus
-choisi.  Le lanceur défini par la norme MPI est `mpiexec`. Il existe
+choisi. Le lanceur défini par la norme MPI est `mpiexec`. Il existe
 également des lanceurs non standards, comme `mpirun`.
 
 ```bash
@@ -130,7 +134,8 @@ Hello world from processor ar039133.math.univ-rennes1.fr, rank 0 out of 4 proces
 
 ## Exemple Python
 
-Pour les langages interprétés, il est nécessaire de lancer plusieurs sessions pour utiliser MPI.
+Pour les langages interprétés, il est nécessaire de lancer plusieurs sessions avec `mpiexec` ou `mpirun`
+pour utiliser MPI.
 
 ```python
 #!/usr/bin/env python
@@ -152,7 +157,7 @@ Hello, World! I am process 3 of 4 on ar039133.math.univ-rennes1.fr
 Hello, World! I am process 0 of 4 on ar039133.math.univ-rennes1.fr
 ```
 
-## Exemple R SPMD
+## Exemple R SPMD (Single Program Multiple Data)
 
 ![](spmd.png)
 
@@ -169,12 +174,14 @@ cat(msg)
 invisible(mpi.barrier(comm=0))
 invisible(mpi.finalize())
 ```
+::: {.callout-note}
+Pour une raison qui m'est inconnue, si on laisse la valeur `comm=1` par défaut, l'exemple ne fonctionne pas.
+:::
 
 Installation de l'environnement logiciel
 
 ```bash
-$ conda create -y -n rmpi r-rmpi -c conda-forge
-$ conda activate rmpi
+$ Rscript -e 'install.packages("Rmpi")'
 ```
 
 ```bash
@@ -264,7 +271,7 @@ Hello world from task 002 of 004, on host dahu146
 Hello world from task 001 of 004, on host dahu146
 ```
 
-## Exemple R MPMD
+## Exemple R MPMD (Multiple Program Multiple Data)
 
 ![](mpmd.png)
 
@@ -300,14 +307,14 @@ Je n'ai pas réussi à faire tourner cet exemple dans l'environnement conda. En
 
 ## SPMD vs MPMD
 
-On retrouve plus d'exemples utilisant la méthode MPMD mais cette forme de parallélisation est plus difficile à faire fonctionner et semble moins rapide (voir [ici]( https://hpcf.umbc.edu/other-packages/how-to-run-r-programs-on-maya/#heading_toc_j_7))
+On retrouve plus d'exemples utilisant la méthode MPMD mais cette forme de parallélisation est plus difficile à faire fonctionner et semble moins rapide (voir [ici]( https://hpcf.umbc.edu/other-packages/how-to-run-r-programs-on-maya/#heading_toc_j_7)). La technique SPMD présente plusieurs avantages:
 
-- Plus proche du code séquentiel, c'est-à-dire que le SPMD est plus facile à coder à partir de la version séquentielle
-- Plus court que la version MPMD, donc moins d'erreurs potentielles.
+- Code plus proche du code séquentiel, c'est-à-dire que le SPMD est plus facile à coder à partir de la version séquentielle
+- Code plus court que la version MPMD, donc moins d'erreurs potentielles.
 - Le processeur 0 travaille également, ce qui permet d'utiliser pleinement les ressources.
-- En général la taille et nombre de messages sont plus réduites.
+- En général la taille et nombre de messages sont plus réduits.
 
-## MPI – Exercice 1 : Environnement MPI
+## Exercice 
 
 Implémenter un programme MPI SPMD dans lequel chaque processus affiche un
 message indiquant si son rang est pair ou impair. Par exemple :