Updated doc

src/my.bib

@@ -3,15 +3,11 @@
 	title = {Message Passing Interface},
 	rights = {Creative Commons Attribution-{ShareAlike} License},
 	url = {https://fr.wikipedia.org/w/index.php?title=Message_Passing_Interface},
-	abstract = {Message Passing Interface ({MPI}), est une norme conçue en 1993-94 pour le passage de messages entre ordinateurs distants ou dans un ordinateur multiprocesseur. Elle est devenue de facto un standard de communication pour des nœuds exécutant des programmes parallèles sur des systèmes à mémoire distribuée. Elle définit une bibliothèque de fonctions, utilisable avec les langages C, C++ et Fortran.
-{MPI} a été écrite pour obtenir de bonnes performances aussi bien sur des machines massivement parallèles à mémoire partagée que sur des clusters d'ordinateurs hétérogènes à mémoire distribuée. Elle est disponible sur de très nombreux matériels et systèmes d'exploitation. Ainsi, {MPI} possède l'avantage par rapport aux plus vieilles bibliothèques de passage de messages d'être grandement portable (car {MPI} a été implémentée sur presque toutes les architectures de mémoires) et rapide (car chaque implémentation a été optimisée pour le matériel sur lequel il s'exécute).
-Depuis 1997, une nouvelle version de {MPI} est disponible, {MPI}-2, qui apporte quelques puissantes[évasif] fonctionnalités supplémentaires[Lesquels ?].
-Depuis 2015, une nouvelle version de {MPI} est disponible, {MPI}-3, qui apporte des écritures parallèles dans les fichiers.
-Depuis 2020, une nouvelle version de {MPI} est disponible, {MPI}-4, qui apporte le {RDMA} et la prévision de détection automatique en cas de panne. ({MPI} Forum)},
 	booktitle = {Wikipédia},
 	urldate = {2021-07-22},
 	date = {2021-03-17},
 	langid = {french},
+	note = {Page Version {ID}: 180967726},
 	file = {Snapshot:/Users/baptistecdr/Zotero/storage/GLQPSHE4/index.html:text/html},
 }
 
@@ -29,26 +25,24 @@ Depuis 2020, une nouvelle version de {MPI} est disponible, {MPI}-4, qui apporte
 @inreference{noauthor_amdahls_2021,
 	title = {Amdahl's law},
 	rights = {Creative Commons Attribution-{ShareAlike} License},
-	url = {https://en.wikipedia.org/w/index.php?title=Amdahl%27s_law},
-	abstract = {In computer architecture, Amdahl's law (or Amdahl's argument) is a formula which gives the theoretical speedup in latency of the execution of a task at fixed workload that can be expected of a system whose resources are improved. It is named after computer scientist Gene Amdahl, and was presented at the {AFIPS} Spring Joint Computer Conference in 1967.
-Amdahl's law is often used in parallel computing to predict the theoretical speedup when using multiple processors. For example, if a program needs 20 hours to complete using a single thread, but a one-hour portion of the program cannot be parallelized, therefore only the remaining 19 hours (p = 0.95) of execution time can be parallelized, then regardless of how many threads are devoted to a parallelized execution of this program, the minimum execution time cannot be less than one hour. Hence, the theoretical speedup is limited to at most 20 times the single thread performance,
-},
+	url = {https://en.wikipedia.org/w/index.php?title=Amdahl%27s_law&oldid=1034193438},
 	booktitle = {Wikipedia},
 	urldate = {2021-07-22},
 	date = {2021-07-18},
 	langid = {english},
+	note = {Page Version {ID}: 1034193438},
 	file = {Snapshot:/Users/baptistecdr/Zotero/storage/4KJVD4JN/index.html:text/html},
 }
 
 @inreference{noauthor_gustafsons_2021,
 	title = {Gustafson's law},
 	rights = {Creative Commons Attribution-{ShareAlike} License},
-	url = {https://en.wikipedia.org/w/index.php?title=Gustafson%27s_law},
-	abstract = {In computer architecture, Gustafson's law (or Gustafson–Barsis's law) gives the theoretical speedup in latency of the execution of a task at fixed execution time that can be expected of a system whose resources are improved. It is named after computer scientist John L. Gustafson and his colleague Edwin H. Barsis, and was presented in the article Reevaluating Amdahl's Law in 1988.},
+	url = {https://en.wikipedia.org/w/index.php?title=Gustafson%27s_law&oldid=1031307338},
 	booktitle = {Wikipedia},
 	urldate = {2021-07-22},
 	date = {2021-06-30},
 	langid = {english},
+	note = {Page Version {ID}: 1031307338},
 	file = {Snapshot:/Users/baptistecdr/Zotero/storage/FGKVKJQD/index.html:text/html},
 }
 
@@ -95,51 +89,69 @@ Amdahl's law is often used in parallel computing to predict the theoretical spee
 @inreference{noauthor_jeu_2021,
 	title = {Jeu de la vie},
 	rights = {Creative Commons Attribution-{ShareAlike} License},
-	url = {https://fr.wikipedia.org/w/index.php?title=Jeu_de_la_vie},
-	abstract = {Le jeu de la vie est un automate cellulaire imaginé par John Horton Conway en 1970 et qui est probablement le plus connu de tous les automates cellulaires. Malgré des règles très simples, le jeu de la vie est Turing-complet.
-Le jeu de la vie est un jeu de simulation au sens mathématique plutôt que ludique. Bien que n'étant pas décrit par la théorie des jeux, certains le décrivent comme un « jeu à zéro joueur ».},
+	url = {https://fr.wikipedia.org/w/index.php?title=Jeu_de_la_vie&oldid=183190635},
 	booktitle = {Wikipédia},
 	urldate = {2021-07-22},
 	date = {2021-05-23},
 	langid = {french},
+	note = {Page Version {ID}: 183190635},
 	file = {Snapshot:/Users/baptistecdr/Zotero/storage/HDKB5PPW/index.html:text/html},
 }
 
 @inreference{noauthor_automate_2021,
 	title = {Automate cellulaire},
 	rights = {Creative Commons Attribution-{ShareAlike} License},
-	url = {https://fr.wikipedia.org/w/index.php?title=Automate_cellulaire},
-	abstract = {Un automate cellulaire consiste en une grille régulière de « cellules » contenant chacune un « état » choisi parmi un ensemble fini et qui peut évoluer au cours du temps. L'état d'une cellule au temps t+1 est fonction de l'état au temps t d'un nombre fini de cellules appelé son « voisinage ». À chaque nouvelle unité de temps, les mêmes règles sont appliquées simultanément à toutes les cellules de la grille, produisant une nouvelle « génération » de cellules dépendant entièrement de la génération précédente.
-Étudiés en mathématiques et en informatique théorique, les automates cellulaires sont à la fois un modèle de système dynamique discret et un modèle de calcul. Le modèle des automates cellulaires est remarquable par l'écart entre la simplicité de sa définition et la complexité que peuvent atteindre certains comportements macroscopiques : l'évolution dans le temps de l'ensemble des cellules ne se réduit pas (simplement) à la règle locale qui définit le système. À ce titre il constitue un des modèles standards dans l'étude des systèmes complexes.},
+	url = {https://fr.wikipedia.org/w/index.php?title=Automate_cellulaire&oldid=183026782},
 	booktitle = {Wikipédia},
 	urldate = {2021-07-22},
 	date = {2021-05-18},
 	langid = {french},
+	note = {Page Version {ID}: 183026782},
 	file = {Snapshot:/Users/baptistecdr/Zotero/storage/L5L9W28B/index.html:text/html},
 }
 
 @inreference{noauthor_programmation_2021,
 	title = {Programmation fonctionnelle},
 	rights = {Creative Commons Attribution-{ShareAlike} License},
-	url = {https://fr.wikipedia.org/w/index.php?title=Programmation_fonctionnelle},
-	abstract = {La programmation fonctionnelle est un paradigme de programmation de type déclaratif qui considère le calcul en tant qu'évaluation de fonctions mathématiques.
-Comme le changement d'état et la mutation des données ne peuvent pas être représentés par des évaluations de fonctions la programmation fonctionnelle ne les admet pas, au contraire elle met en avant l'application des fonctions, contrairement au modèle de programmation impérative qui met en avant les changements d'état.
-Un langage fonctionnel est donc un langage de programmation dont la syntaxe et les caractéristiques encouragent la programmation fonctionnelle. Alors que l'origine de la programmation fonctionnelle peut être trouvée dans le lambda-calcul, le langage fonctionnel le plus ancien est Lisp, créé en 1958 par {McCarthy}. Lisp a donné naissance à des variantes telles que Scheme (1975) et Common Lisp (1984) qui, comme Lisp, ne sont pas ou peu typées. Des langages fonctionnels plus récents tels {ML} (1973), Haskell (1987), {OCaml}, Erlang, Clean et Oz, {CDuce}, Scala (2003), F\# ou {PureScript} (2013), Agda (en)  sont fortement typés.},
+	url = {https://fr.wikipedia.org/w/index.php?title=Programmation_fonctionnelle&oldid=183271341},
 	booktitle = {Wikipédia},
 	urldate = {2021-07-22},
 	date = {2021-05-26},
 	langid = {french},
+	note = {Page Version {ID}: 183271341},
 	file = {Snapshot:/Users/baptistecdr/Zotero/storage/Z4UFD79Y/index.html:text/html},
 }
 
 @inreference{noauthor_maximum_2021,
 	title = {Maximum subarray problem},
 	rights = {Creative Commons Attribution-{ShareAlike} License},
-	url = {https://en.wikipedia.org/w/index.php?title=Maximum_subarray_problem},
-	abstract = {In computer science, the maximum sum subarray problem is the task of finding a contiguous subarray with the largest sum, within a given one-dimensional array A[1...n] of numbers.  Formally, the task is to find indices},
+	url = {https://en.wikipedia.org/w/index.php?title=Maximum_subarray_problem&oldid=1030176929},
 	booktitle = {Wikipedia},
 	urldate = {2021-07-22},
 	date = {2021-06-24},
 	langid = {english},
+	note = {Page Version {ID}: 1030176929},
 	file = {Snapshot:/Users/baptistecdr/Zotero/storage/LL8NK2KY/index.html:text/html},
 }
+
+@inreference{noauthor_distributed_2021,
+	title = {Distributed computing},
+	rights = {Creative Commons Attribution-{ShareAlike} License},
+	url = {https://en.wikipedia.org/w/index.php?title=Distributed_computing&oldid=1033553148},
+	booktitle = {Wikipedia},
+	urldate = {2021-07-23},
+	date = {2021-07-14},
+	langid = {english},
+	note = {Page Version {ID}: 1033553148},
+	file = {Snapshot:/Users/baptistecdr/Zotero/storage/ZF8EB2I9/index.html:text/html},
+}
+
+@online{oracle_chapter_2010,
+	title = {Chapter 1 Covering Multithreading Basics (Multithreaded Programming Guide)},
+	url = {https://docs.oracle.com/cd/E19455-01/806-5257/6je9h0329/index.html},
+	author = {Oracle},
+	urldate = {2021-07-23},
+	date = {2010},
+	langid = {english},
+	file = {Chapter 1 Covering Multithreading Basics (Multithreaded Programming Guide):/Users/baptistecdr/Zotero/storage/ASQQ8TRR/index.html:text/html},
+}
\ No newline at end of file

src/text/03-programmation-parallele.md

-# Distributed and parallel computing
+# Distributed High-Performance Computing
 
-"Parallel computing refers to the process of breaking down larger problems into smaller, independent, often similar parts that can be executed simultaneously by multiple processors communicating via shared memory, the results of which are combined upon completion as part of an overall algorithm. The primary goal of parallel computing is to increase available computation power for faster application processing and problem-solving."
+Distributed systems are groups of networked computers that share a common goal. Distributed systems are used to increase computing power and solve a complex problem faster than with a single machine. Thus, when the problem is distributed, it is solved more quickly than sequential, concurrent, or parallel computing [@noauthor_distributed_2021].
+
+Sequential computation consists of executing a processing step by step, where each operation is triggered only when the previous operation is completed, even when the two operations are independent.
+
+Oracle's multithreading programming guide [@oracle_chapter_2010], define *concurrency* as a state where each task is executed independently with time-slicing. A performance gain is noticeable when tasks are most independent of others because they do not have to wait for the progress of another task.
+
+Finally, parallel computing exploits the computing power of a graphics card thanks to the thousands of cores it has. This allows a gain in performance compared to the previously described calculation methods because the operations are performed simultaneously on the different cores.
 
 ## Amdahl's law vs Gustafson–Barsis's law
 
 In parallel computing, two important laws give the theoretical speedup that can be expected of a system whose resources are improved, Amdahl's law and Gustafson-Barsis law.
 
+\pagebreak
+
 \cimg{figs/amdahls-law.png}{scale=0.6}{Amdahl's law}{Source: Taken from https://commons.wikimedia.org/, ref. URL02}
 
 Amdahl's law states that the program's overall speed is limited by the code that cannot be parallelized. Indeed, there will almost always be a sequential part in a code that cannot be parallelized. There is, therefore, a relationship between the ratio of parallelizable code and the overall execution speed of the program [@noauthor_amdahls_2021].

src/text/07-automate-elementaire.md

@@ -118,7 +118,7 @@ Table: Results for the parallelized-multicore version of SCA
 
 \cimg{figs/elem_result_and_speedup_cpu.png}{width=\linewidth}{Benchmarks of the SCA in parallelized-sequential/multicore}{Source: Realized by Baptiste Coudray}
 
-Sur le graphique de gauche, nous comparons le temps d'exécution moyen pour chaque tâche et pour chaque version (sequential et multicore). Sur le graphique de droite, nous comparons le speedup idéal avec le speedup de la version parallelized-sequential et multicore. 
+We compare the average computation time for each task and each version (sequential and multicore) on the left graph. On the right graph, we compare the ideal speedup with the parallelized-sequential and multicore version speedup.
 
 The more we increase the number of tasks, the more the execution time is reduced. Thus, the parallelized-sequential or multicore version speedup follows the curve of the ideal speedup.
 

src/text/ZZ-glossaire.tex

@@ -12,7 +12,6 @@
 \newacronym{POSIX}{POSIX}{Portable Operating System Interface uniX}
 \newacronym{CUDA}{CUDA}{Compute Unified Device Architecture}
 \newacronym{OpenCL}{OpenCL}{Open Computing Language}
-\newacronym{SDL2}{SDL2}{Simple Directmedia Layer 2}
 \newacronym{HES-GE}{HES-GE}{Haute École Spécialisée de GEnève}
 \newacronym{IO}{I/O}{Input/Output}
 \newacronym{MSS}{MSS}{Maximum Segment Sum}