# -*- mode: org -*- # -*- coding: utf-8 -*- #+startup: beamer #+STARTUP: overview #+STARTUP: indent #+TAGS: noexport(n) #+Title: Défis des grandes infrastructures de calcul #+Author: Arnaud Legrand #+DATE: #+EPRESENT_FRAME_LEVEL: 2 #+LaTeX_CLASS: beamer #+LaTeX_CLASS_OPTIONS: [11pt,xcolor=dvipsnames,presentation] #+OPTIONS: H:2 num:t toc:nil \n:nil @:t ::t |:t ^:nil -:t f:t *:t <:t #+LATEX_HEADER: \usedescriptionitemofwidthas{bl} #+LATEX_HEADER: \usepackage[T1]{fontenc} #+LATEX_HEADER: \usepackage[utf8]{inputenc} #+LATEX_HEADER: \usepackage[francais]{babel} #+LATEX_HEADER: \usepackage{ifthen,figlatex,amsmath,amstext,gensymb,amssymb} #+LATEX_HEADER: \usepackage{boxedminipage,xspace,multicol} #+LATEX_HEADER: %%%%%%%%% Begin of Beamer Layout %%%%%%%%%%%%% #+LATEX_HEADER: \ProcessOptionsBeamer #+LATEX_HEADER: \usecolortheme{whale} #+LATEX_HEADER: \usecolortheme[named=BrickRed]{structure} #+LATEX_HEADER: \useinnertheme{rounded} #+LATEX_HEADER: \useoutertheme{infolines} #+LATEX_HEADER: \setbeamertemplate{footline}[frame number] #+LATEX_HEADER: \setbeamertemplate{headline}[default] #+LATEX_HEADER: \setbeamertemplate{navigation symbols}{} #+LATEX_HEADER: \defbeamertemplate*{headline}{info theme}{} #+LATEX_HEADER: \defbeamertemplate*{footline}{info theme}{\leavevmode% #+LATEX_HEADER: \hbox{% #+LATEX_HEADER: \begin{beamercolorbox}[wd=.2\paperwidth,ht=2.25ex,dp=1ex,center]{author in head/foot}% #+LATEX_HEADER: \usebeamerfont{author in head/foot}\insertshortauthor #+LATEX_HEADER: \end{beamercolorbox}% #+LATEX_HEADER: \begin{beamercolorbox}[wd=.71\paperwidth,ht=2.25ex,dp=1ex,center]{title in head/foot}% #+LATEX_HEADER: \usebeamerfont{title in head/foot}\insertsectionhead #+LATEX_HEADER: \end{beamercolorbox}% #+LATEX_HEADER: \begin{beamercolorbox}[wd=.09\paperwidth,ht=2.25ex,dp=1ex,right]{section in head/foot}% #+LATEX_HEADER: \usebeamerfont{section in head/foot}\insertframenumber{}~/~\inserttotalframenumber\hspace*{2ex} #+LATEX_HEADER: \end{beamercolorbox} #+LATEX_HEADER: }\vskip0pt} #+LATEX_HEADER: \setbeamertemplate{footline}[info theme] #+LATEX_HEADER: %%%%%%%%% End of Beamer Layout %%%%%%%%%%%%% #+LATEX_HEADER: \usepackage{verbments} #+LATEX_HEADER: \usepackage{cutwin} #+LATEX_HEADER: \usepackage{xcolor} #+LATEX_HEADER: \usepackage{color} #+LATEX_HEADER: \usepackage{url} \urlstyle{sf} #+LATEX_HEADER: \let\alert=\structure % to make sure the org * * works #+LATEX_HEADER: \newsavebox{\rsbox} * Des besoins universels et toujours croissants ** Quel est le point commun entre ... ? #+BEGIN_LaTeX ~\\[-.6cm] \null\hspace{-.08\linewidth}{ \begin{overlayarea}{.1\linewidth}{7.3cm} \includegraphics[width=11\linewidth]{img/boinc_usage.pdf} \end{overlayarea} } #+END_LaTeX \small Eau potable, panneaux solaires, médicaments contre Ebola, le SIDA ou le cancer, l'évolution du climat, le para-pente, la recherche d'extra-terrestres, les pulsars, ... * Les grandes infrastructures de calcul ** Le calcul bénévole #+BEGIN_LaTeX \begin{columns} \begin{column}{.45\linewidth} \includegraphics[width=\linewidth]{img/MS2.pdf} \end{column}\hspace{-3em} \begin{column}{.55\linewidth} #+END_LaTeX /Berkeley Open Infrastructure for Network Computing/ (*BOINC*): - Environ *$238\,000$ volontaires actifs* sur plus de *$420\,800$ ordinateurs*\vspace{-.3em} #+LaTeX: \begin{flushright}{\scriptsize (mais aussi tablettes, téléphones, ...)}\end{flushright} - La puissance de calcul moyenne sur 24 heures de l'ensemble des parti\-cipants atteint $6\,722$ PetaFlops - Hétérogène, dynamique, des ordinateurs pas forcément fiables, ... #+BEGIN_LaTeX \end{column} \end{columns}\medskip #+END_LaTeX #+BEGIN_QUOTE Today the computer is just as important a tool for chemists as the test tube. Simulations are so realistic that they predict the outcome of traditional experiments #+BEGIN_LaTeX \begin{flushright} -- Comité Nobel (Chimie), 2013 \end{flushright} #+END_LaTeX #+END_QUOTE ** Les supercalculateurs #+BEGIN_LaTeX ~\\[-.7cm] \null\hspace{-.05\linewidth}{ \begin{overlayarea}{.1\linewidth}{6.5cm} \includegraphics[width=11\linewidth]{img/hpc_platforms.png} \end{overlayarea} } #+END_LaTeX - 100,000 à 1,000,000 de coeurs, des accélérateurs (GPU, Xeon Phi), un réseau d'interconnection ultra-rapide - Une course entre les pays (*Top500*) # Mais notre société aussi repose (parfois sans le savoir) sur de # gigantesques infrastructures de calcul. ** Le cloud #+BEGIN_LaTeX ~\\[-1.3cm] \null\hspace{-.05\linewidth}{ \begin{overlayarea}{.1\linewidth}{7.3cm} \includegraphics[width=11\linewidth]{img/cloud_platforms.png} \end{overlayarea} } #+END_LaTeX # /home/alegrand/Work/SimGrid/propaganda/131021_MOSIG/131021-lecture_simulation_MOSIG.pdf ** Une évolution vertigineuse Des architectures *parallèles*, *hybrides* et de *très grande taille* pour répondre aux besoins de calcul et aux contraintes énergétiques\\[-.8cm] #+BEGIN_LaTeX \null\hspace{-1em}\bgroup\small \begin{tabular}{ccc} \textbf{1996} & \textbf{2009} & \textbf{2015}\\ \includegraphics[height=3cm]{img/plat_ascired.jpg} & \includegraphics[height=3cm]{img/plat_radeon.jpg} & \includegraphics[height=3cm]{img/plat_nvidia-x1.jpg}\\ \alert{ASCI Red} & \alert{ATI Radeon} & \alert{Nvidia Tegra X1}\\ 1 Teraflop & 2.4 Teraflop & 1 Teraflop\\ 9298 Pentium~II & 1600 Stream Processors & 8-core ARM CPU\\ 1\,000 Flops/W & 1\,600\,000 Flops/W & 667\,000\,000 Flops/W \end{tabular}\egroup #+END_LaTeX \medskip *Mon téléphone est aussi puissant qu'un super-calculateur d'il y a 20 ans* \pause Mais Sequoia, c'est \textbf{6 millions de threads} s'échangeant des données...\\ #+LaTeX: \centerline{\alert{\textbf{Comment programme-t-on un tel monstre ?}}} * Un peu de programmation ** Résolution d'un système triangulaire (à la main) #+BEGIN_LaTeX $ \left\{ \begin{alignedat}{5} ~~x & + & ~~y & + & ~~z & + & ~~t & = & 6 \\ & & ~~y & - & 3z & - & t & = & 5 \\ & & & & 6z & + & t & = &-4\\ & & & & & & 4t & = &~~8 \\ \end{alignedat} \right. \qquad $\qquad #+END_LaTeX #+BEGIN_LaTeX \only<2-3>{$ \left\{ \begin{alignedat}{5} \phantom{~~~} & \phantom{+} & \phantom{~~~} & \phantom{+} & \phantom{~~~} & \phantom{+} & \phantom{~~~} & \phantom{=} \phantom{~~~} \\ % \phantom{x} & \phantom{+} & \phantom{y} & \phantom{+ } & \phantom{z } & \phantom{+} & \phantom{t} & \phantom{=} & \phantom{6} \\ \phantom{} & \phantom{ } & \phantom{y} & \phantom{- } & \phantom{3z} & \phantom{-} & \phantom{t} & \phantom{=} & \phantom{5} \\ \phantom{} & \phantom{ } & \phantom{ } & \phantom{ } & \phantom{6z} & \phantom{+} & \phantom{t} & \phantom{=} & \phantom{-4}\\ & & & & & &t & = & \only<2>{8/4}\only<3>{2} \\ %\only<2>{ & & & & & & t & = & 8/4\\} %\only<3>{ & & & & & & t & = & 2 \\} \end{alignedat} \right. $}% #+END_LaTeX #+BEGIN_LaTeX \only<4-8>{$ \left\{ \begin{alignedat}{5} \phantom{~~~} & \phantom{+} & \phantom{~~~} & \phantom{+} & \phantom{~~~} & \phantom{+} & \phantom{~~~} & \phantom{=} \phantom{~~~} \\ \phantom{} & \phantom{ } & \phantom{y} & \phantom{- } & \phantom{3z} & \phantom{-} & \phantom{t} & \phantom{=} \phantom{5} \\ \only<4>{ & & & & 6z & + & t & = -4\\} \only<5>{ & & & & 6z & + & 2 & = -4\\} \only<6>{ & & & & & &6z & = -4-2\\} \only<7>{ & & & & & & z & = -6 / 6\\} \only<8>{ & & & & & & z & = -1\\} & & & & & & t & = ~~2 \\ \end{alignedat} \right. $}% #+END_LaTeX #+BEGIN_LaTeX \only<9-13>{$ \left\{ \begin{alignedat}{5} \phantom{~~~} & \phantom{+} & \phantom{~~~} & \phantom{+} & \phantom{~~~} & \phantom{+} & \phantom{~~~} & \phantom{=} \phantom{~~~} \\ \only<9>{ & & y & - & 3z & - & t & = ~~5 \\} \only<10>{ & & y & + & (3 & - & 2) & = ~~5 \\} \only<11>{ & & y & + & 1 & & & = ~~5 \\} \only<12>{ & & & & & & y & = (5-1)/1 \\} \only<13>{ & & & & & & y & = ~~4 \\} & & & & & & z & = -1\\ & & & & & & t & = ~~2 \\ \end{alignedat} \right. $}% #+END_LaTeX #+BEGIN_LaTeX \only<14-18>{$ \left\{ \begin{alignedat}{5} \only<14>{ x & + & y & + & z & + & t & = ~~6 \\} \only<15>{ x & + & (4 & - & 1 & + & 2) & = ~~6 \\} \only<16>{ x & + & 5 & & & & & = ~~6 \\} \only<17>{ & & & & & & x & = (6-5)/1 \\} \only<18>{ & & & & & & x & = ~~1 \\} & & & & & & y & = ~~4 \\ & & & & & & z & = -1\\ \phantom{~~~} & \phantom{+} & \phantom{~~~} & \phantom{+} & \phantom{~~~} & \phantom{+} & ~~t & = ~~2 \\ \end{alignedat} \right. $} #+END_LaTeX \bigskip #+LaTeX: \uncover<18->{ Les principales étapes: - on part du bas - on somme des produits horizontalement - on divise #+LaTeX: } ** Résolution d'un système triangulaire (en python) \null\vspace{-3em} #+BEGIN_LaTeX \begin{lrbox}{\rsbox} \begin{minipage}{.4\linewidth} \textcolor{blue}{ \fbox{$ \left. \begin{alignedat}{5} ~~x & + & ~~y & + & ~~z & + & ~~t & = & 6 \\ & & ~~y & - & 3z & - & t & = & 5 \\ & & & & 6z & + & t & = &-4\\ & & & & & & 4t & = &~~8 \\ \end{alignedat} \right.\quad $}} \end{minipage} \end{lrbox} #+END_LaTeX #+BEGIN_CENTER (sans utiliser =np.linalg.solve(A,b)=, bien sûr \smiley)\vspace{-1em} #+END_CENTER \small #+begin_src python :results output :exports both import numpy as np A = np.array([[1, 1, 1, 1], [0, 1, -3, -1], [0, 0, 6, 1] , [0, 0, 0, 4]], float) b = np.array([6, 5, -4, 8], float) n = len(b) x = np.zeros(n, float) for i in reversed(range(0,n)): # en partant du bas S = 0 for j in range(i+1,n): S = S + A[i][j] * x[j] # la somme x[i] = (b[i] - S) / A[i][i] # la division print(x) #+end_src #+RESULTS: : [ 1. 4. -1. 2.] \normalsize #+BEGIN_LaTeX \begin{overlayarea}{\linewidth}{0mm} \vspace{-7cm} \begin{flushright} \scalebox{.65}{\usebox{\rsbox}} \end{flushright} \end{overlayarea} #+END_LaTeX Tel quel, ce programme est *intrinsèquement séquentiel* (à cause de =S=) ** Résolution d'un système triangulaire \small #+begin_src python :results output :exports both for i in reversed(range(0,n)): # en partant du bas S = np.dot(A[i][i+1:n],x[i+1:n]) # la somme x[i] = (b[i] - S) / A[i][i] # la division #+end_src \normalsize Cette version-ci est bien plus rapide que la précédente car: - pas d'interprétation de la boucle interne, de vérification des bornes, ...\pause - la somme est #+LaTeX: \alert<2>{\emph{vectorisable}} (MMX, SSE, \emph{GPU},...) - la somme est #+LaTeX: \alert<3>{\emph{parallélisable}} (threads, multicore) - la somme est #+LaTeX: \alert<4>{\emph{distribuable}} (réseau, MPI) #+BEGIN_LaTeX \begin{overlayarea}{\linewidth}{3cm} \begin{center} \includegraphics<2>[scale=.85]{fig/vector_processing.fig}% \includegraphics<3>[scale=.85]{fig/parallel_processing.fig}% \includegraphics<4>[scale=.85]{fig/parallel_processing2.fig} \end{center} \end{overlayarea} #+END_LaTeX ** Est-ce satisfaisant ? #+BEGIN_LaTeX \includegraphics[width=\linewidth]{fig/gantt_triang.fig} #+END_LaTeX *Non!* - Les processeurs sont largement inactifs (sauf vers à la "fin") - On communique très souvent des données toutes petites - Le moindre retard d'un processeur ralenti tout le monde Il faut tout réorganiser: - changer la *granularité* - supprimer les *synchronisations* ** Un peu de restructuration #+BEGIN_LaTeX $ \left\{ \begin{alignedat}{5} ~~x & + & ~~y & + & ~~z & + & \only<1>{~~t}\only<2>{~~\alert{\textbf{2}}} & = & 6 \\ & & ~~y & - & 3z & - & \only<1>{~~t}\only<2>{~~\alert{\textbf{2}}}& = & 5 \\ & & & & 6z & + & \only<1>{~~t}\only<2>{~~\alert{\textbf{2}}}& = &-4\\ & & & & & & 4\alert<2>{t} & = &~~8 \\ \end{alignedat} \right. \qquad % \begin{aligned} % x &= 0\\ % y &= 1\\ % z &= 0 % \end{aligned} $\qquad \begin{minipage}{.5\linewidth} Substituons les variables dans chacune des lignes (sommes) dès que possible\\\smallskip% \pause \alert{(on travaille donc "verticalement")} \end{minipage} #+END_LaTeX \small #+begin_src python :results output :exports both import numpy as np A = np.array([[1, 1, 1, 1], [0, 1, -3, -1], [0, 0, 6, 1] , [0, 0, 0, 4]], float) b = np.array([6, 5, -4, 8], float) n = len(b) x = np.zeros(n, float) S = np.zeros(n, float) for j in reversed(range(0,n)): # en partant du bas x[j] = (b[j] - S[j]) / A[j][j] # la division (D_j) for i in range(0,j): # vraie boucle parallele S[i] = S[i] + A[i][j] * x[j] # mise a jour (U_i,j) #+end_src ** ... pour obtenir des graphes de tâches Si *$I_1$* écrit *$z$* et *$I_2$* lit/écrit *$z$*, il faut faire *$I_1$* et *$I_2$* dans le *bon* #+LaTeX: ordre~{\small[Bernstein66]}\\[-.4em] #+BEGIN_LaTeX \begin{lrbox}{\rsbox} \begin{minipage}{\linewidth} #+END_LaTeX \small #+begin_src python :results output :exports both import numpy as np A = np.array([[1, 1, 1, 1], [0, 1, -3, -1], [0, 0, 6, 1] , [0, 0, 0, 4]], float) b = np.array([6, 5, -4, 8], float) n = len(b) x = np.zeros(n, float) S = np.zeros(n, float) for j in reversed(range(0,n)): # en partant du bas x[j] = (b[j] - S[j]) / A[j][j] # la division (D_j) for i in range(0,j): # vraie boucle parallele S[i] = S[i] + A[i][j] * x[j] # mise a jour (U_i,j) #+end_src #+BEGIN_LaTeX \end{minipage} \end{lrbox} #+END_LaTeX #+BEGIN_LaTeX \begin{columns} \begin{column}{.55\linewidth} Les données définissent des \alert{dépendances} entre les \alert{instructions/tâches}\\ \scalebox{.55}{\usebox{\rsbox}} \uncover<2>{ \begin{itemize} \item adaptation de la \alert{granularité} \item des versions optimisées selon les ressources (CPU/GPU/\alert{auto-tuning}) \item \alert{équilibrage de charge} dynamique \item des performances plus \alert{portables} \end{itemize}} \end{column} % \hspace{-1em} \begin{column}{.45\linewidth} \begin{overlayarea}{\linewidth}{6.5cm} \only<1>{\includegraphics<1>[height=6.5cm]{fig/triangular_solving.fig}} \only<2>{ \includegraphics<2>[height=4.5cm,width=\linewidth]{img/chol_20x20.png}\\ \includegraphics<2>[width=\linewidth,height=1cm]{img/gantt_bsp.png}\\ \includegraphics<2>[width=.4\linewidth,height=1cm]{img/gantt_runtime.png} } \end{overlayarea} \end{column} \end{columns} #+END_LaTeX * Conclusion ** \null\hspace{-.4em}Des infrastructures omni-présentes et en perpétuelle évolution\hspace{-1em} Notre société repose (parfois sans le savoir) sur de gigantesques infrastructures de calcul. \medskip Comment *concevoir/utiliser/comprendre* de telles infrastructures ? - Programmation (portabilité, performance, évolution technologique) - Tolérance aux pannes - Consommation énergétique - Partage équitable des ressources - Modélisation/analyse/évaluation/expérimentation \medskip Problèmatiques similaires dans: - *Réseaux* (sans fils, de capteurs, d'objets connectés...) - *Vélos en libre service*, co-voiturage, transport, *smart-grids*, ... * Questions :noexport: - Pour la fiabilité aux pannes de ces grands systèmes multi-composants, la redondance est-elle la solution? C'est une solution mais la duplication complète des calculs n’est pas optimale. On ne peut se permettre d'effectuer chacun des calculs en double au cas où une ressource tomberait en panne. On gâcherait la moitié des ressources et même comme ça, on n'aurait aucune garantie de succès. La bonne approche dépend des systèmes considérés. - Prenons le cas des systèmes de calcul bénévoles dont je parlais au début, et qui reposent sur des ressources typiquement peu fiables. Il existe de multiples raisons pour lesquelles les clients peuvent renvoyer des résultats incorrects. Les clients peuvent par exemple "tricher" et renvoyer volontairement des résultats incorrects afin d'augmenter leurs statistiques et ainsi apparaître comme de bons contributeurs. Mais il arrive également que des résultats incorrects proviennent de machines overclockées ou bien ayant des bibliothèques numériques défectueuses. Dans ces cas, il est possible de détecter statistiquement ces machines ou de leur envoyer des tâches tests dont le résultat est connus et ainsi d'apprendre les caractéristiques du système. On peut alors répliquer les calculs pour lesquels il y a un risque d'erreur fort - Dans le cas des supercalculateurs, les ressources sont très homogènes. Il est parfois possible, grâce à des études statistiques, de détecter les signes avant-coureurs à une panne et d'agir en conséquence mais c'est en général assez difficile et il faut parer à toute éventualité. Plutôt que de répliquer les calculs, on sauvegarde régulièrement l'état (complet ou partiel) de l'application. Ces points de reprises (checkpoints), sont les résultats intermédiaires permettant de reprendre le calcul en cas de perte des données. La représentation par graphe de tâche peut dans ce cas s'avérer très précieuse. Pour certaines applications, il est même parfois possible de reconstruire une approximation des données temporaires perdues par interpolation des données encore accessibles. Dans tous les cas, ce sont des considérations à prendre en compte au moment de la programmation de l'application. - Ces grands systèmes ont-ils aussi un disque dur ou bien une architecture de stockage différente ? Oui, il y a aussi des disques durs dans de telles infrastructures mais tout est possible. Dans les supercalculateurs, on distingue en général les noeuds de calcul classiques des noeuds de stockage qui sont un peu plus musclés et disposent de plus gros disques. Dans le cas d'applications “big data” qui nécessitent le traitement de gros volumes de données, il est indispensable de répartir ces noeuds de stockage dans la machine pour améliorer les mouvements de donnée au sein de l'infrastructure. Ce type de répartition est également utile pour offrir des possibilités de visualisation intermédiaire, suivre l’évolution des calculs et permettre l’interaction humaine afin d'orienter la suite des calculs comme affiner certains calculs pour certaines zones si besoin. On parle alors d'analyse /in situ/ et d'/application steering/. Une des grande difficulté est alors d'exécuter à la fois un gros code de simulation numérique et un code d'observation/analyse chargé de la visualisation sans que le second ne perturbe trop le premier car comme nous l'avons vu un déséquilibre de charge entre les différents processeurs qui peut être terriblement inefficace. Un autre exemple d'infrastructure de stockage un peu particulière peut être trouvé à Lyon, au centre de calcul de l'IN2P3. Ce centre de calcul est un des centre de stockage et d'analyse des données produites par le LHC (le Large Hadron Collider situé près de Genève). Outre des rangées de machines de calcul du genre de celles que je vous ai montrées, on peut y trouver une infrastructure de stoquage avec 40,000 bandes magnétiques (c'est ce qui offre les plus grandes capacités de stoquage), entièrement automatisée avec des bras robots qui viennent chercher les bandes pour mettre leur contenu à disposition. Les bandes magnétiques sont cependant peu performantes pour des accès multiples (par plusieurs utilisateurs ou programmes) et les données sont donc copiées dès qu'il y en a besoin sur des disques durs. Le stockage sur disque joue donc le rôle de cache (stockage de 2ème niveau) pour la bandothèque et se réalise sur une grappe de machines pleine de disques durs "classiques". - Existe-t-il des langages adaptés pour le HPC ? Le choix des langages se fait selon les niveaux d’intervention de la programmation et les besoins. Python est un langage de script assez facile à utiliser par scientifiques non informaticiens (biologistes, physiciens, ...) et surtout permet d'assez facilement encapsuler des bibliothèques optimisées (bindings). On l'utilise donc de plus en plus pour faire de l'assemblage de code plus complexes. C'est du code de haut niveau et il est donc difficile d'écrire du code hyper optimisé car on ne contrôle pas bien les choses. Lorsque l'on souhaite gérer plus finement les choses comme les synchronisations des threads ou la façon dont les données sont agencées en mémoire, on utilise plutôt C ou C++. FORTRAN est encore beaucoup utilisé car les matrices y sont des objets de premier ordre, ce qui permet aux compilateurs de faire des optimisations (par exemple la vectorisation) qui ne sont pas forcément possibles avec le langage C. Au point que certains travaillent sur la transformation de code python en code FORTRAN afin de le compiler plus efficacement. Dans tous les cas, selon le niveau souhaité on doit se reposer sur des bibliothèques spécifiques (CUDA ou OpenCL pour l'utilisation des GPUs, pthread ou OpenMP pour la gestion de threads sur les différents coeurs d'un CPU, généralement MPI pour la communication entre les différents noeuds). En fait, l'optimisation d'un code passe par le choix du langage et la façon de l'écrire. Mais optimiser n’est pas simple : la composition de codes optimisés n’est pas forcément efficace. Le compilateur et le système d’exploitation font leurs propres optimisations avec les informations dont ils disposent et peuvent se nuire les unes aux autres. La vérité, c'est qu'entre les optimisations faites par le processeur, le système d'exploitation, le compilateur, la machine virtuelle, l'application elle même, il est très difficile de comprendre l'impact de telle ou telle modification ou prétendue optimisation. Un compilateur comme gcc a une centaine d'options d'optimisation et si certaines peuvent être profitable à telle fonction elle peuvent être nuisibles aux performances de telle autre fonction... On se retrouve avec espace d'optimisation à explorer monstrueux et on utilise des techniques d'exploration automatique et d'apprentissage couplés à des outils de transformation des programmes. C'est ce qu'on appelle l'auto-tuning. - Est-il possible de visiter de telles infrastructures ? Bien sûr. Nous avons quelques clusters ici, mais de taille modeste car nous ne sommes pas un centre de calcul mais uniquement un centre de recherche en informatique. Les machines dont nous disposons sont donc principalement des machines expérimentales nous permettant de mieux comprendre comment fonctionne, comment modéliser et comment optimiser telle ou telle architecture. Nous ferons une petite visite tout à l'heure si vous le souhaitez. Sur le campus de l'université de Grenoble, est installé le mésocentre CIMENT (Calcul Intensif / Modélisation / Expérimentation Numérique et Technologique) qui rassemble des ressources de calcul intensif mutualisées entre les différents partenaires académiques. On y trouve une petite quinzaine de grappes totalisant 6700 coeurs plus des accélérateurs et il y a très certainement moyen de visiter les salles machines. Un grand nombre d'entreprises sont également installées dans l'agglomération grenobloise: Bull, HP, Orange, ST Microelectronics, ... Toutes disposent d'infrastructures de calcul similaires et certaines seraient probablement tout à fait prêtes à les faire visiter à des élèves. Enfin, vers Lyon, il y a également le centre de calcul de l'IN2P3, situé sur le campus de la Doua et dont je vous parlais précédemment. * :noexport: ** test C #+BEGIN_SRC c printf("hello world!\n"); #+END_SRC #+ATTR_LaTeX: :options caption={First Java program} #+begin_src R :results output :session :exports both print("Hello world"); #+end_src #+RESULTS: : [1] "Hello world" #+BEGIN_SRC xml Hello world! #+END_SRC * Emacs Setup :noexport: This document has local variables in its postembule, which should allow org-mode to work seamlessly without any setup. If you're uncomfortable using such variables, you can safely ignore them at startup. Exporting may require that you copy them in your .emacs. # Local Variables: # eval: (setq org-latex-listings 'minted) # eval: (setq org-latex-minted-options '(("bgcolor" "Moccasin") ("style" "tango") ("numbers" "left") ("numbersep" "5pt"))) # End: