Ateliers et tutoriels
Dans le cadre de ComPAS 2013 (Conférence d’informatique en Parallélisme, Architecture et Système), des ateliers et tutoriels, d’une demi-journée ou d’une journée, seront organisés le 15 janvier 2013 conjointement à la conférence. L’objectif de ces manifestations est de promouvoir les discussions autour de sujets de recherche ciblés ou émergents.
La liste définitive des ateliers et tutoriels proposés pour cette édition 2013 est donnée ci-dessous.
Les inscriptions sont closes (!).
Les participants aux tutoriels sont donc invités à s’inscrire !
Planning final
| Arrivée de Grenoble: vers 8h50 | |||||
|---|---|---|---|---|---|
| Emplacement | Ensimag, A001 | INRIA Amphi | INRIA A104 | Ensimag, A008 | Ensimag, A009 |
| Matin: 9h00-12h30 | Grid’5000 | Prog. Hétérogène | XScalableMP | SLA pour le Cloud Computing | Automatique pour l’Informatique Autonomique (AAIA’13) |
| Repas: 12h30-14h00 | |||||
| Après-midi: 14h00-18h00 | SimGRID | Prog. Hétérogène | HWLOC | SLA pour le Cloud Computing | Automatique pour l’Informatique Autonomique (AAIA’13) |
| Retour sur Grenoble: 18h30 | |||||
Le plan local d’organisation des salles
Afficher Ateliers ComPAS2013 sur une carte plus grande
Tutoriel: Intoduction à XcalableMP, extensions C/Fortran pour le calcul distribué
Intervenant: Swann Perarnau, Mitsuhisa Sato RIKEN AICS, Kobe, Japon
Date: 15 janvier 2013
Durée: 1/2 journée
Horaire: voir tableau ci-dessus
Les systèmes pour le calcul haute performance sont le plus souvent com- posés d’une collection de machines possédant leur propre mémoire (privée) reliés entre elles par un réseau de qualité. Bien que MPI soit de-facto le standard pour programmer de tels systèmes distribués, son utilisation à très grande échelle s’avère souvent complexe. Les principales difficultés rencon- trés sont la distribution des données sur les différents nœuds de calculs et une répartition efficace du travail entre tous les processeurs.
Un certain nombre de langages de programmation ont vu le jour avec pour objectif de simplifier l’expression par le programmeur de la distribution des données. Ces langages sont regroupé sous le qualificatif de PGAS pour Partitioned Global Address Space. On peut citer comme exemples Chapel et HPF. Malheureusement ces langages sont peu utilisés de nos jours car ils nécessitent de larges modifications des applications existantes quand il ne s’agit pas d’une réécriture complète.
XcalableMP est un langage actuellement developpé pour l’utilisation du K Computer à Kobé au Japon. Il s’agit d’un jeu d’extensions pour C et Fortran permettant au programmeur d’utiliser les fonctionnalités des PGAS mais avec la simplicité d’un langage comme OpenMP : le programmeur ex- prime la distribution des données à l’aide de directives simples, qui seront ensuite interprétées par un compilateur spécialisé. Ces directives permettent une modification plus aisée des programmes existants. à ce titre, XMP est comparable à des langages plus récents comme UPC.
Cette demi-journée sera découpé en deux phases. Dans un premier temps, une présentation générale des PGAS et de XcalableMP permettra aux par- ticipant de mieux comprendre le fonctionnement de ces langages pour le parallélisme.
Une session pratique viendra compléter cette présentation, avec l’utili- sation de XcalableMP pour l’écriture de programmes parallèles classiques, avec la possibilité de les exécuter ensuite sur Grid5000 et (peut être) sur le K Computer.
Il est recommandé aux participants de se présenter avec un ordinateur portable sous Linux pour une prise en main « en local » du langage. Un compte Grid5000 sera nécessaire pour utiliser la plateforme, mais des machines seront réservées à ce tutoriel et une image système fournie aux participant pour déployer XMP plus aisément.
Tutoriel: programmation des architectures hétérogènes
Organisateurs: Nathalie Furmento, Ludovic Courtés, projet RUNTIME Bordeaux ; Vincent Danjean et Pierre Neyron projet MOAIS Grenoble
Date: 15 janvier 2013
Durée: 1 journée
Horaire: voir tableau ci-dessus
Les GPGPUs sont de plus en plus utilisés pour paralléliser massivement des codes de calcul. Même si, sur des problèmes précis, on arrive à obtenir de très bonnes performances, il reste difficile de programmer efficacement de façon transparente ces nouveaux supports d’exécution parallèle.
Ce tutoriel, organisé sur une journée, présentera d’abord l’architecture et les bases théoriques permettant d’obtenir de bonnes performances sur les GPGPU. Puis, deux environnements de programmation (StarPU et XKaapi) pour utiliser ce matériel de manière efficace et relativement transparente seront présentés plus en détail.
Le tutorial commencera par une présentation succincte des architectures matérielles ciblées (GPU) et leurs environnements de programmation dédiés (Cuda/OpenCL). La connaissance préalable de ces outils est vivement conseillée pour suivre ce tutorial.
Puis, le tutorial introduira des notions plus théoriques. Programmer des applications parallèles revient à sélectionner quelles tâches doivent être allouées aux GPUs et à déterminer l’ordre
d’exécution. Nous rappellerons les fondements utiles de la théorie de l’ordonnancement pour concevoir et analyser des politiques et nous détaillerons les différentes solutions envisageables pour ordonnancer sur des supports mixtes. Enfin, nous présenterons quelques solutions
existantes développées sur les environnements StarPU et XKaapi.
Le reste du tutorial, plus pratique, sera l’occasion de découvrir et de prendre en main les environnements StarPU et XKaapi. Ces environnements sont là pour prendre en charge et simplifier des parties purement techniques (chargement de noyaux, transferts de
données) mais surtout pour faire de l’ordonnancement de tâches entre CPU et GPU. Ainsi, l’application peut espérer un placement de ses tâches relativement performant quelque soit le nombre de GPU et CPU à sa disposition. L’ordonnancement sera réalisé en prenant en charge de
manière transparente les mouvements et la cohérence de données entre la mémoire des différentes unités de calcul.
StarPU et XKaapi utilisent tous les deux des tâches avec dépendances. Pour chaque tâche, une ou plusieurs implémentations CPU et/ou GPU peuvent être définies. Ces environnements sont proches mais se distinguent par les caractéristiques de leur ordonnanceur et par leur
interface de programmation.
StarPU obtient la description du graphe de tâche de l’application en utilisant les directives fournies par l’extension GCC, ou directement l’API bas-niveau C. Il est également possible d’exécuter le graphe de tâches de manière distribuée sur différents noeuds de calcul en définissant une distribution des données. Ce tutorial présentera plus en détail les directives de programmation fournies par l’extension GCC, ainsi que l’intégration du modèle de tâches de StarPU avec MPI.
XKaapi obtient la description du graphe de tâche de l’application de manière dynamique grâce à des directives de compilation ou à l’utilisation d’une API C/C++/Fortran. Pour illustrer le vol de
taches à grain fin et le placement sur les processeurs de calcul (CPU/GPU) réalisé par XKaapi, nous utiliserons dans ce tutoriel l’interface C++ pour l’implémentation d’algorithmes d’algèbre
linéaire.
Atelier: gestion des SLA pour le Cloud Computing
Organisateurs: Thomas Ledoux, Ascola (EMN/INRIA, LINA), Ecole des Mines de Nantes, Sara Bouchenak, INRIA Sardes, Université de Grenoble
Date: 15 janvier 2013
Durée: 1 journée
Horaire: voir tableau ci-dessus
Le Cloud Computing est un modèle qui permet l’accès à la demande et à distance à un ensemble de ressources de calcul configurables. Ce modèle tend à fournir des services logiciels et matériels à l’utilisateur tout en minimisant l’effort en termes d’installation, de configuration et de maintenance de ces services, à la fois pour l’utilisateur et pour le fournisseur de cloud.
Cependant, la gestion ad-hoc de la qualité de service et du contrat de niveau de service (Service Level Agreement – SLA) dans le cloud soulève des problèmes de performance, de disponibilité, de consommation énergétique et de coûts économiques du cloud. Nous pensons qu’un des éléments différenciateurs entre les offres de clouds sera la qualité du service fournie et le SLA proposé par le cloud.
L’objectif de cet atelier est de rassembler les acteurs académiques et industriels du domaine pour faire un point sur l’état de l’art et les technologies actuelles, échanger sur les verrous scientifiques et industriels à lever, et présenter les récentes contributions.
L’atelier sera organisé sur une journée autour de présentations invitées et d’une table ronde.
Plus de détails sur la page dédiée à l’atelier.
Atelier: Automatique pour l’informatique autonomique
Organisateur: Eric Rutten, LIG / INRIA Grenoble – Rhône-Alpes
Date: 15 janvier 2013
Durée: 1 journée
Horaire: voir tableau ci-dessus
Les systèmes informatiques reconfigurables, aussi appelés adaptatifs, ou calcul autonomique, sont une approche récente motivée par l’automatisation de la gestion p.ex. de ressources, de la qualité de service, la tolérance aux fautes. On les retrouve dans les systèmes embarqués comme dans les data-centers, et à divers niveaux : architectures matérielles, systèmes d’exploitation, génie logiciel, applications et services. C’est un sujet émergeant et pour l’instant très dispersé dans diverses communautés en informatique, avec des interactions en automatique, pour concevoir la boucle de décision et optimisation de l’adaptation.
URL de l’atelier: http://proton.inrialpes.fr/~rutten/peps-api/peps-compas13.html
Ce thème est celui de l’action PEPS « Automatique pour l’informatique autonomique« . Ce projet veut s’attaquer à la structuration et unification scientifique du sujet, en procédant à une synthèse des travaux de différentes origines, et construisant un cadre méthodologique global, qui puisse fonder l’échange et la factorisation des résultats.
Tutoriel: Introduction à Grid’5000
Organisateurs: Lucas Nussbaum, équipe AlGorille, Université de Nancy
Date: 15 janvier 2013
Durée: 1/2 journée
Horaire: voir tableau ci-dessus
GRID’5000 est une plate-forme expérimentale pour l’étude des systèmes
distribués et parallèles à grande échelle. Il permet aussi l’étude des clusters
qui constituent l’instrument. Pour mettre au point de tels systèmes, il faut
être capable d’observer et de comprendre des phénomènes complexes au sein de
ces systèmes informatiques ; étudier, concevoir, tester et valider des
logiciels qui mettent en œuvre de nouveaux concepts; GRID’5000 réunit donc les
capacités de calcul de 8000 processeurs répartis sur dix sites : Bordeaux,
Grenoble, Lille, Luxembourg, Lyon, Nancy, Reims, Rennes, Sophia-Antipolis et
Toulouse. Tous sont reliés par un réseau à très haut débit mis à disposition
par RENATER. L’originalité de GRID’5000, c’est la possibilité de reconfigurer
la pile de logiciels du système d’exploitation jusqu’à l’application. Ainsi,
avec GRID’5000 l’utilisateur prend le contrôle complet de la machine, ou d’une
partie de celle-ci, et il est possible de réaliser les expériences de manière
reproductible, élément essentiel pour les analyser et les comprendre. Loin du
système de production, ou du simple calculateur, GRID’5000 est un outil de
recherche à part entière. Il est à l’informaticien ce que le télescope est à
l’astronome. La plate-forme est accessible à n’importe quel chercheur en France
mais aussi plus largement dans le cadre d’une collaboration scientifique avec
un des sites impliqués, à des chercheurs du monde entier.
Tutoriel: Introduction à SimGrid
Organisateur: Arnaud Legrand, équipe MESCAL, Université de Grenoble, Martin Quinson, équipe AlGorille, Université de Nancy, Frédéric Suter, équipe Avalon, CCIN2P3/ENS-Lyon
Date: 15 janvier 2013
Durée: 1/2 journée
Horaire: voir tableau ci-dessus
Description prochainement disponible
SimGrid est un ensemble d’outils open source spécifiquement conçus pour fournir les fonctionnalités de base pour l’étude par simulation d’applications distribuées dans des environnements hétérogène. L’objectif de ce projet est de faciliter la recherche sur les systèmes parallèles et distribués à large échelle tels que les grilles, les systèmes pair à pair, les plates-formes de calcul hautes performances ou les cloud. Son champ d’utilisation couvre l’évaluation d’heuristiques d’ordonnancement ou de protocoles, le dimensionnement de plates-formes, le prototypage d’applications voire le développement et la calibration d’applications réelles.
Grâce à une organisation modulaire et à une implémentation optimisée depuis plus de dix ans, SimGrid permet de concevoir des simulateurs plusieurs ordres de grandeur plus rapide que des simulateurs ad hoc tout en reposant sur des modèles de plates-formes dont la validité a été expérimentalement évaluée et démontrée. Ces modèles permettent par exemple de rendre compte de la hiérarchie des réseaux, de la localité des communications, de la dynamicité des performances, de la contention, ainsi que de caractéristiques propres aux protocoles comme TCP tout en étant extrêmement rapides.
Le projet SimGrid ne se limite pas à la mise à disposition d’un
noyau de simulation et d’exécution efficace. SimGrid vient également avec tout un écosystème d’applications permettant la visualisation et l’analyse des simulations, la génération de traces, de plates-formes, … et qui sont le résultat de l’activité de la communauté d’utilisateurs et de la mise en commun de leurs compétences.
Dans ce tutoriel, nous expliquerons comment utiliser SimGrid et un certain nombre d’outils annexes à travers des exemples pratiques afin d’illustrer leurs potentiels.
Tutoriel: Comprendre et maitriser les affinités matérielles avec hwloc
Organisateur: Brice Goglin, projet RUNTIME, Bordeaux
Date: 15 janvier 2013
Durée: 1/2 journée
Horaire: voir tableau ci-dessus
L’augmentation du nombre de coeurs dans les processeurs rend les serveurs de calcul de plus en plus complexes, avec de multiples niveaux de hiérarchies mémoire et des distances variables entre les différents composants matériels. Ce tutoriel expliquera pourquoi l’exploitation efficace de la puissance de calcul impose de comprendre la topologie matérielle et de la combiner à la connaissance des affinités logicielles. Nous présenterons le logiciel Hardware Locality (hwloc) qui est conçu pour simplifier la vie des développeurs en représentant la topologie des ordinateurs de manière abstraite et portable.
Nous présenterons d’abord les différents niveaux de hiérarchies existants (processeurs, coeurs, caches partagés, NUMA, I/O, …) avant d’expliquer pourquoi les applications sont difficilement portables d’une machine à l’autre. On donnera ensuite des exemples où l’affinité est importante en HPC (placement MPI selon le schéma de communication, placement de threads OpenMP selon les sections parallèles, et adaptation des communications selon les affinités des périphériques). On présentera ensuite le logiciel hwloc, comment il permet de représenter la topologie et de modifier/vérifier le placement des tâches de calculs. On entrera enfin dans l’interface de programmation d’hwloc pour détailler comment consulter les informations de topologie matérielle depuis un programme, et comment placer des threads ou processus.
