X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/these_charles_emile.git/blobdiff_plain/0af348b9f9fa2f0bc44be5f4a129e869fbb7e5d4..c9389c5838efd5d6872ab508eaa000e3a769ed18:/These_RCE.tex

diff --git a/These_RCE.tex b/These_RCE.tex
index 2e58d63..ae7e4d8 100644
--- a/These_RCE.tex
+++ b/These_RCE.tex
@@ -67,6 +67,12 @@
 %\usepackage{subcaption}
 \usepackage{graphicx}
 
+\usepackage{algpseudocode}
+\algnewcommand\algorithmicinput{\textbf{Input:}}
+\algnewcommand\Input{\item[\algorithmicinput]}
+\algnewcommand\algorithmicoutput{\textbf{Output:}}
+\algnewcommand\Output{\item[\algorithmicoutput]}
+
 \usepackage{multirow}
  
 %%--------------------
@@ -445,7 +451,120 @@ si un mÃ©canisme de reprise sur panne est mis en place.
 \section{MÃ©thodes de rÃ©solution parallÃ¨les du problÃ¨me de Poisson et de
 l'algorithme two-stage multisplitting de Krylov}
 
+Afin de valider les rÃ©sultats de simulation d'applications distribuÃ©es parallÃ¨les effectuÃ©e dans le cadre de nos travaux, diffÃ©rents algorithmes, largement utilisÃ©s dans diffÃ©rents domaines scientifiques, Ã©crits en MPI/C ont Ã©tÃ© utilisÃ©s. Ils font partie de la classe des mÃ©thodes de rÃ©solution numÃ©rique itÃ©rative qui, en opposition aux mÃ©thodes directes et par approches successives,calcule par approximation la solution du problÃ¨me posÃ© avec une erreur connue d'avance aprÃ¨s l'initialisation d'une valeur initiale. Les mÃ©thodes itÃ©ratives permettent la rÃ©solution des systÃ¨mes linÃ©aires mais aussi non linÃ©aires. Elles se prÃªtent Ã  une parallÃ¨lisation plus aisÃ©e et supportent mieux le passage Ã  l'echelle [4]. 
+Les sections suivantes vont dÃ©crire les algorithmes considÃ©rÃ©s Ã  savoir la mÃ©thode de rÃ©solution de Jacobi et l'algorithme de Krylov avec deux variantes : le classique GMRES en mode native et la version "two-stage" d'une part et la variante multi-dÃ©composition(multisplitting) d'autre part.
+
 \subsection{Algorithme de Jacobi}
+L'algorithme de Jacobi est une des plus simples mÃ©thodes de rÃ©solutions d'un systÃ¨me d'Ã©quations linÃ©aires [3,4].
+
+Soit le systÃ¨me d'Ã©quations linÃ©aires suivant : 
+
+\begin{equation}
+\label{eq:2}
+Ax = b   
+\end{equation}
+oÃ¹ : 	
+
+\begin{tabbing}
+\hspace{2cm}\=\kill
+  \> A est une matrice carrÃ©e rÃ©elle creuse inversible de taille n, \\ 
+  \> x le vecteur inconnu de taille n, \\ 
+  \> et b un vecteur constant.\\
+\end{tabbing}
+
+Ainsi, \eqref{eq:2} peut s'Ã©crire : 
+
+\begin{equation*}
+  \left(\begin{array}{ccc}
+      a_{1,1} & \cdots & a_{1,n} \\
+      \vdots & \ddots & \vdots\\
+      a_{n,1} & \cdots & a_{n,n}
+    \end{array} \right)
+  \times
+  \left(\begin{array}{c}
+      x_1 \\
+      \vdots\\
+      x_n
+    \end{array} \right)
+	=
+  \left(\begin{array}{c}
+      b_1 \\
+      \vdots\\
+      b_n
+    \end{array} \right)
+\end{equation*}
+ 
+Notons : \\ 
+D la matrice carrÃ©e de taille n formÃ©e par la diagonale de A. On suppose qu'aucun Ã©lÃ©ment $a_{i,i}$ n'est Ã©gal Ã  0. \\
+L (resp. U) la matrice carrÃ©e de taille n formÃ©e par les Ã©lÃ©ments du bas (resp. haut) de A.\\
+On a donc : 
+
+\begin{equation*}
+D=\left( \begin{array}{ccc}
+a_{1,1} & \cdots & 0 \\
+\vdots & \ddots & \vdots \\
+0 & \cdots & a_{n,n}
+\end{array}\right) 
+\space
+, \hspace{0,1cm}L=\left( \begin{array}{ccc}
+0 & \cdots & 0 \\
+\vdots & \ddots & \vdots \\
+a_{n,1} & \cdots & 0
+\end{array}\right)
+\space
+et \hspace{0,2cm}U=\left( \begin{array}{ccc}
+0 & \cdots & a_{1,n} \\
+\vdots & \ddots & \vdots \\
+0 & \cdots & 0
+\end{array}\right)
+\end{equation*}
+
+Comme A = D + (L + U) et si $D^{-1}$ est l'inverse de la matrice diagonale D, on peut Ã©crire :
+
+\begin{equation*}
+Ax = b  \Leftrightarrow  ( D + L + U )x = b  
+\end{equation*}
+
+\begin{equation*}
+\Leftrightarrow  Dx = -(L+U)x + b
+\end{equation*}
+
+\begin{equation}
+\label{eq:3}
+\Leftrightarrow ( x = D^{-1} \times [-(L+U)] x + D^{-1} b)
+\end{equation}
+Cette derniÃ¨re Ã©galitÃ© est l'equation $du  point  fixe$. L'algorithme itÃ©ratif de Jacobi Figure~\ref{algo:01} (version sÃ©quentielle) et ses variantes dÃ©coule de cette Ã©quation [4]. Si $x^{(k)}$ est la valeur approchÃ©e du vecteur inconnu Ã  l'itÃ©ration $k$, on a d'aprÃ¨s \eqref{eq:3} avec un $x^{0}$ initial donnÃ© : 
+
+\begin{equation}
+x^{(k+1)} = D^{-1} \times [-(L+U)] x^{(k)} + D^{-1} b  
+\end{equation}
+
+\begin{figure}[!t]
+\begin{algorithmic}[1]
+\Input $A_{ij}$ (Matrice d'entrÃ©e), $b_{i}$ (Vecteur du membre droit), $n$ (Taille des vecteurs) et des matrices, $xOld_{i}$ (vecteur solution Ã  l'itÃ©ration prÃ©cÃ©dente)
+\Output $x_{i}$ (Vecteur solution)\medskip
+
+\State Charger $A_{ij}$, $b_{i}$, $n$, 
+\State Assigner la valeur initiale $x^0$ 
+\State \textbf{repeat} {jusqu'Ã  l'obtention de la condition de convergence} \textbf{do}
+\For {$i=0,1,2,\ldots (n-1)$} 
+\State $x_i \leftarrow 0$
+\For {$j=0,1,2,\ldots (n-1) \hspace{0.1cm} et \hspace{0.1cm} j \neq i$}
+\State $x_{i} \leftarrow x_{i} + A_{ij} \times xOld_{j}$
+\EndFor
+\For {$i=0,1,2,\ldots (n-1)$}
+\State $xOld_{i} \leftarrow ( b_{i} - x_{i} ) \quad {/} \quad A_{ii}$
+\EndFor
+\EndFor
+\State \textbf{end repeat}
+
+\Statex
+\end{algorithmic}
+\caption{Algorithme itÃ©ratif de Jacobi}
+\label{algo:01}
+\end{figure}
+
+La condition de convergence est dÃ©terminÃ©e au dÃ©but du traitement. La mÃ©thode permet de passer Ã  large Ã©chelle en distribuant l'exÃ©cutuion de l'algorithme sur un environnement de grille de calcul. 
 
 \subsection{MÃ©thode de rÃ©solution GMRES}
 
@@ -569,9 +688,42 @@ Contrairement Ã  une communication point Ã  point, une communication dite collec
 La synchronisation des processus peut Ãªtre obtenue avec la routine MPI\_Barrier qui, une fois lancÃ©e par un processus, bloque ce dernier jusqu'Ã  ce que tous les processus de son groupe atteigne cette barriÃ¨re comme un point de rendez-vous.
 
 \subsection{Simulateur SIMGRID - SMPI}      
-SimGrid est utilisÃ© pour la simulation et l'Ã©tude du comportement d'applications parallÃ¨les dans un contexte d'un environnement complexe, hÃ©tÃ©rogÃ¨ne, distribuÃ© et dynamique. Il est conÃ§u sur une simulation basÃ©e sur les Ã©venements ("event driven") Ã  un niveau d'abstraction et de fonctionnalitÃ©s rÃ©pondant aux applications et aux infrastructures [26].
+SimGrid est utilisÃ© pour la simulation et l'Ã©tude du comportement d'applications parallÃ¨les dans un contexte d'un environnement complexe, hÃ©tÃ©rogÃ¨ne, distribuÃ© et dynamique. Comme son nom l'indique, dÃ©veloppÃ© par la communautÃ© des utilisateurs de grille de calcul, il est utilisÃ© aussi largement sur dans les domaines des applications pair-Ã -pair,du calcul Ã  haute performance et du cloud computing [5,9]. Le choix de Simgrid comme outil de simulation dans le cadre de ces travaux a Ã©tÃ© motivÃ© par son efficacitÃ© pour la simulation d'applications parallÃ¨les Ã  large Ã©chelle. En effet, Simgrid rassemble au mieux les caractÃ©ristiques requises pour un simulateur dans un environnement de grille de calcul telles que la robustesse, la scalabilitÃ© et la justesse des rÃ©sultats accompagnÃ©es d'un temps de rÃ©ponse correct et d'une tolÃ©rance aux pannes de l'exÃ©cution [34].
+
+Simgrid est conÃ§u sur une simulation basÃ©e sur les Ã©venements ("event driven")[26, 35] Ã  un niveau d'abstraction et de fonctionnalitÃ©s rÃ©pondant aux applications et aux infrastructures. Cinq composants d'abstraction constitue le fonctionnement de Simgrid : 
+
+\begin{itemize}
+
+\item[$\bullet$]Un "agent" est une entitÃ© qui assure l'ordonnancement de l'application et exÃ©cute le code sur une "location";
 
-\section{Motivations}
+\item[$\bullet$]Une "location" est une hÃ´te de l'environnement de simulation sur laquelle l'agent s'exÃ©cute. Outre les donnÃ©es propres Ã  la location, des boÃ®tes aux lettres sont conÃ§ues pour permettre les Ã©changes de donnÃ©es avec d'autres agents;
+
+\item[$\bullet$]Une "tÃ¢che" est une activitÃ© de l'application simulÃ©e. Elle se dÃ©cline sous forme d'un calcul (temps de calcul nÃ©cessaire) ou d'un transfert de donnÃ©es (volume de donnÃ©es Ã  Ã©changer;
+
+\item[$\bullet$]Un "chemin" dÃ©crit la liaison entre les locations. Il est utilisÃ© par les agents lors d'un transfert de donnÃ©es Ã  calculer le temps de transfert en tenant compte du routage Ã  appliquer pour une telle liaison.
+
+\item[$\bullet$]La communication entre agents se fait Ã  travers un "channel". Cette abstraction modÃ©lise la communication Ã  travers un port entre des agents dans les locations.
+
+\end{itemize}
+
+Simgrid offre pour l'utilisateur plusieurs types d'interfaces de programmation [5,9]: MSG qui simule les "processes sÃ©quentiels conccurents", SimDAG qui est utilisÃ© pour simuler des tÃ¢ches parallÃ¨les modÃ©lisÃ©es en graphe acyclique direct et SMPI qui simule et exÃ©cute les applications Ã©crites en MPI sans ou avec des modifications mineures. Outre le langage C natif, Simgrid accepte des applications Ã©crites en C++, Java, Lua ou encore Ruby.
+  
+De point de vue pratique, la figure \figref{simgrid1} prÃ©sente la structure et les Ã©lÃ©ments de la plateforme de simulation Simgrid. Elle est composÃ©e des trois parties diffÃ©rentes suivantes : 
+
+\begin{itemize}
+
+\item[$\bullet$] Le scÃ©nario de la simulation qui constitue les "modÃ¨les de ressources" du systÃ¨me. Evidemment, il comprend le code de l'application Ã  exÃ©cuter dans le simulateur avec ses diffÃ©rents paramÃ¨tres d'entrÃ©e mais aussi son modÃ¨le de dÃ©ploiement. Un autre composant important de ce scÃ©nario aussi est le fichier, gÃ©nÃ©ralement au format XML, modÃ©lisant les dÃ©tails de la topologie et l'architecture de l'environnement d'exÃ©cution. Il dÃ©termine par exemple pour le cas d'une grille de calcul, le nombre et les caractÃ©ristiques des clusters contribuant Ã  cet environnement. Pour chaque cluster, les spÃ©cifications des serveurs (nombre de cores ou de processeurs, puissance en Flops, taux de disponibilitÃ©, ...)sont dÃ©finies ainsi que les propriÃ©tÃ©s des rÃ©seaux de liaison entre ces diffÃ©rents composants de la grille (topologie du rÃ©seau, dÃ©bit et latence, table de routage, ...).
+
+\item[$\bullet$] Le simulateur proprement dit.
+
+\item[$\bullet$] Les fichiers de sortie comprenant les rÃ©sultats de la simulation de l'application ainsi que d'autres fichiers de monitoring de l'exÃ©cution comme un fichier de logging et de statistiques. Simgrid peut gÃ©nÃ©rer aussi des donnÃ©es pouvant Ãªtre utilisÃ©es pour reprÃ©senter visuellement le dÃ©roulement et la trace de la simulation dans le temps.
+     
+\end{itemize}
+
+\mfigure[h]{width=8cm, height=8cm}{"Simgrid - In a nutshell"} {SIMGRID : Les Ã©lÃ©ments de la plateforme de simulation} {simgrid1}
+
+Les applications sous-tendant les expÃ©rimentations effectuÃ©es dans le cadre de ces travaux ont Ã©tÃ© ecrites en C et utilise les librairies MPI. Simgrid dispose de l'interface SMPI (Simulated MPI) qui peut exÃ©cuter un code MPI parallÃ¨les sans aucune ou Ã  la limite trÃ¨s peu de modifications. A titre d'exemple, les variables globales doivent Ãªtre transfÃ©rÃ©es dans un contexte local dans l'application SMPI. Simgrid/SMPI assure l'implÃ©mentation de plus de 80\% des routines de la librairie MPI 2.0. Le code est exÃ©cutÃ© rÃ©ellement dans le simulateur dans l'environnement virtuel spÃ©cifiÃ© sauf que les communications sont interceptÃ©es et le temps de transfert calculÃ© en tenant compte du partage des ressources existantes (par exemple le partage de la bande passante entre processus concurrents sur les rÃ©seaux de liaison).La scalabilitÃ© de Simgrid peut Ãªtre obtenu par appel Ã  des routines SMPI qui utilisent des structures de donnÃ©es partagÃ©es entre les processus parallÃ¨les rÃ©duisant ainsi la quantitÃ© de mÃ©moire utilisÃ©e et permettant une montÃ©e en charge non nÃ©gligeable. Toutefois, dans ce cas, comme tous les processus utilisent la mÃªme structure de donnÃ©es, la vÃ©racitÃ© des rÃ©sultats obtenus n'est pas importante.
+ 
 
 \section{Conclusion partielle}
 
@@ -1337,13 +1489,17 @@ Plusieurs outils d'analyse de la performance parallÃ¨le utilisant une ou des com
 
 
 \subsection{Quelques outils d'analyse de performance}
+Quelques outils d'analyse de performance sont passÃ©s en revue dans cette section. Ils mettent en exergue les diffÃ©rentes approches pour aborder ce problÃ¨me crucial de performance pour les applications parallÃ¨les et distribuÃ©es.
+
+\begin{itemize}
 
-	- IPM
+\item [$\bullet$] IPM
 
-TAU a Ã©tÃ© conÃ§u Ã  l'UniversitÃ© d'Oregon comme un outil open source d'Ã©valuation de performance [24]. Il intÃ¨gre le profiling et le tracing constituant une platerme complÃ¨te couvrant les trois Ã©tapes de l'analyse d'une applicatio parallÃ¨le. L'instrumentation du code peut Ãªtre effectuÃ©e d'une faÃ§on complÃ¨tement automatique avec un package fourni ("PDT - Program Database Toolkit - for routines")collectant toutes les informations sur les rÃ©gions et hotspots du code, l'utilisation mÃ©moire, les boucles, les entrÃ©es/sorties,...Selon le paramÃ¨trage de lancement, TAU peut collecter des informations les plus fines telles que le temps passÃ© Ã  chaque instruction dans une boucle ou le temps passÃ© dans les communications Ã  une Ã©tape du programme particuliÃ¨rement dans les instructions collectives MPI par exemple. Toutes ces donnÃ©es peuvent par la suite Ãªtre visualisÃ©es sous forme graphique (Paraprof 3D browser) pour une analyse fine afin d'optimiser la performance.
+\item [$\bullet$] TAU a Ã©tÃ© conÃ§u Ã  l'UniversitÃ© d'Oregon comme un outil open source d'Ã©valuation de performance [24]. Il intÃ¨gre le profiling et le tracing constituant une platerme complÃ¨te couvrant les trois Ã©tapes de l'analyse d'une applicatio parallÃ¨le. L'instrumentation du code peut Ãªtre effectuÃ©e d'une faÃ§on complÃ¨tement automatique avec un package fourni ("PDT - Program Database Toolkit - for routines")collectant toutes les informations sur les rÃ©gions et hotspots du code, l'utilisation mÃ©moire, les boucles, les entrÃ©es/sorties,...Selon le paramÃ¨trage de lancement, TAU peut collecter des informations les plus fines telles que le temps passÃ© Ã  chaque instruction dans une boucle ou le temps passÃ© dans les communications Ã  une Ã©tape du programme particuliÃ¨rement dans les instructions collectives MPI par exemple. Toutes ces donnÃ©es peuvent par la suite Ãªtre visualisÃ©es sous forme graphique (Paraprof 3D browser) pour une analyse fine afin d'optimiser la performance.
 
-	- SCALASCA
+\item [$\bullet$] SCALA ou SCAlabity Analyzer est orientÃ© particulÃ¨rement dans l'analyse de la performance des applications sur sa scalabilitÃ© lors de la montÃ©e en charge. Outre la prÃ©diction de la performance, SCALA utilise les fonctionnalitÃ©s avancÃ©es actuelles pour la mise au point (debugging) de la dite performance et d'une Ã©ventuelle restructuration du code parallÃ¨le d'une part mais aussi d'estimer l'impact des variations sur l'environnement matÃ©riel d'exÃ©cution.
 
+\end{itemize}
 
 \section{MÃ©thodes de prÃ©diction de la performance des applications parallÃ¨les}
 
@@ -1351,6 +1507,23 @@ TAU a Ã©tÃ© conÃ§u Ã  l'UniversitÃ© d'Oregon comme un outil open source d'Ã©valu
 
 \section{Conclusion partielle}
 
+
+\chapter{Motivations}
+
+MalgrÃ© les grandes avancÃ©es dues aux performances des nouveaux processeurs, mÃ©moires mais aussi des rÃ©seaux de communication, le milieu acadÃ©mique comme le domaine industriel sont toujours confrontÃ©s Ã  des dÃ©fis et challenges de plus en plus ambitieux. Ce fait est surtout accentuÃ© par des besoins de plus en plus variÃ©s et importants de calcul scientifique nÃ©cessitant de plus en plus de moyens mais aussi de mÃ©thodes plus efficientes et performantes. Ces besoins requiÃ¨rent le traitement de donnÃ©es de plus en plus volumineuses mais aussi l'Ã©criture d'algorithmes donnant des rÃ©sultats probants dans un laps de temps correct. Le dÃ©fi actuel serait donc l'exploitation de la puissance de calcul des matÃ©riels actuels dans un environnement de calcul optimisÃ© pour traiter un volume de donnÃ©es de plus en plus important. \\
+Dans le cadre de nos travaux, l'objectif final est d'aider les utilisateurs finals (scientifiques, chercheurs, industriels, Ã©tudiants, ...) en calcul Ã  haute performance Ã  rentabiliser au maximum l'accÃ¨s aux infrastructures de calcul physiques existantes, Ã©tant donnÃ© le cÃ´ut et la difficultÃ© (mÃªme des fois l'impossibilitÃ©) d'accÃ¨s Ã  ces derniÃ¨res. En effet, la demande d'utilisation de ces infrastructures dÃ©passe largement l'offre Ã©tablie, entraÃ®nant des longues listes d'attente avant de pouvoir y accÃ©der pour une durÃ©e trÃ¨s limitÃ©es. \\
+Pour atteindre ces objectifs, nous proposons d'utiliser des outils de simulation pour exÃ©cuter les applications pour Ã©tudier leurs comportements Ã  large Ã©chelle mais aussi pour pouvoir dÃ©terminer les conditions optimales pour obtenir des rÃ©sultats optimaux. Le simulateur permet d'Ã©tudier le comportement des algorithmes sous diffÃ©rentes conditions et sur des plateformes variÃ©es et paramÃ©trables. Plusieurs modes d'exÃ©cution peuvent Ãªtre essayÃ©s lors de l'expÃ©rimentation. De plus, la flexibilitÃ© de l'outil permet l'estimation de la performance des algorithmes lors du passage Ã  l'Ã©chelle.\\
+Les questionnements suivants rÃ©sument les motivations des travaux consignÃ©s dans cette thÃ¨se.
+\begin{itemize}
+\item [$\bullet$] a. Quelles solutions pratiques peut-on apporter pour rÃ©duire le coÃ»t de lâexÃ©cution dâapplications parallÃ¨les et distribuÃ©es dans un environnement de grille de calcul durant tout son cycle de vie de dÃ©veloppement ?
+\item [$\bullet$] b. Quel est le comportement de lâalgorithme distribuÃ© Ã  large Ã©chelle dans cette architecture de grille de clusters en particulier lors de son exÃ©cution en mode asynchrone ? 
+\item [$\bullet$] c. Dans ce contexte, quels sont les facteurs importants identifiÃ©s permettant dâavoir un gain de temps dâexÃ©cution en mode asynchrone comparativement au mode synchrone ? A quel niveau peut-on estimer le gain obtenu en comparant l'exÃ©cution en mode asynchrone par rapport au mode classique synchrone.
+\item [$\bullet$] d. Quel est le taux d'erreur de validation obtenue en comparant les rÃ©sultats du lancement de l'application entre une exÃ©cution simulÃ©e et une execution sur un environnement rÃ©Ã©l Ã©quivalent.
+\end{itemize} 
+
+La partie suivante va exposer la mÃ©thodologie adoptÃ©e et les travaux de contributions pour apporter des rÃ©ponses Ã  ces questions. 
+
+
 \part{PARTIE II - Travaux de contributions, rÃ©sultats et perspectives}
 
 \chapter{Comparaison par simulation Ã  large Ã©chelle de la performance de deux algorithmes itÃ©ratifs parallÃ¨les en mode asynchrone}
@@ -1431,6 +1604,13 @@ TAU a Ã©tÃ© conÃ§u Ã  l'UniversitÃ© d'Oregon comme un outil open source d'Ã©valu
 
 \part*{BIBLIOGRAPHIE ET REFERENCES}
 
+
+{[}3{]} J. M. Bahi, S. Contassot-Vivier, R. Couturier - Parallel Iterative Algorithms: from Sequential to Grid Computing - \textit{CRC PRESS - Boca Raton London New York Washington, D.C.}
+
+{[}4{]} R. Couturier - RÃ©solution de systÃ¨mes linÃ©aires Ã  trÃ¨s large Ã©chelle : mÃ©thodes classiques versus mÃ©thodes Ã  large Ã©chelle - \textit{2014 - FEMTO-ST, UniversitÃ© de Franche-ComtÃ©}
+
+{[}5{]} C. E. Ramamonjisoa, L. Z. Khodjav, D. Laiymani, A. Giersch and R. Couturier. - Grid-enabled simulation of large-scale linear iterative solvers - \textit{2014 Femto-ST Institute - DISC Department - UniversitÃ© de Franche-ComtÃ©, IUT de Belfort-MontbÃ©liard}
+
 {[}6{]} J.M. Bahi, S. Contassot-Vivier, R. Couturier. Interest of the asynchronism in parallel iterative algorithms on meta-clusters. \textit{LIFC - UniversitÃ© de Belford-MontbÃ©liard}.
 
 {[}7{]} T.P. Collignon and M.B. van Gijzen. Fast iterative solution of large sparse linear systems on geographically separated clusters. \textit{The International Journal of High Performance Computing Applications} 25(4) 440\textendash 450.
@@ -1492,6 +1672,14 @@ of Sparse Random Matrices". \textit{UC Berkeley, INRIA Paris Rocquencourt, Tel-A
 {[}32{]} MPICH : www.mpich.org
 
 {[}33{]} OpenMPI : www.openmpi.org
+
+{[}34{]} M. Quinson et Al. - Experimenting HPC Systems with Simulation - \textit{Nancy University, France, Caen, HPCS/IWCMC 2010.}
+
+{[}35{]} A. Legrand, L. Marchal, H. Casanova - Scheduling Distributed Applications: the SimGrid Simulation Framework - \textit{Laboratoire de lâInformatique du ParallÃ¨lisme - Ecole Normale SupÃ©rieure de Lyon, Dept. of Computer Science and Engineering San Diego Supercomputer Center - University of California at San Diego}
+
+{[}36{]} Xian-He Sun, T. Fahringer, M. Pantano - SCALA: A perfformance system for scalable computing - \textit{Department Of Computer Science, Illinois Institute of Technology Chicago, Institute for software technology and parallel systems, University of Vienna Liechtenstein - The International Journal of High Performance Computing Applications,Volume 16, No. 4, Autumn 2002,}
+
+
 %%--------------------
 %% List of figures and tables
  
