Support exécutif scalable pour les architectures hybrides distribuées

National audienceIl est difficile pour le programmeur de concilier l’utilisation de toutes les solutions habituelles d’exploitation des machines hétérogènes, encore plus sur des grappes de machines potentiellement hétérogènes en elles-même, mais également entre elles. La nécessité d’une couche logicielle portable permettant de décharger cette gestion complexe des épaules du programmeur est devenue indéniable : cette couche est appelée "support d’exécution". De plus, les problèmes à traiter deviennent de plus en plus gros, et de plus en plus difficiles à gérer, même pour les supports d’exécution : il est donc nécessaire de trouver des solutions de passage à l’échelle.Le but du travail que nous allons présenter dans ce mémoire est d’améliorer la scalabilité de la surcouche de StarPU (qui est le support d’exécution développé à Inria Bordeaux Sud-Ouest dans l’équipe RUNTIME) dédiée à la gestion de l’exécution sur des grappes de machines hétérogènes, nommée StarPU-MPI. De cet objectif découle plusieurs problématiques :– La nécessité de se doter d’outils permettant d’évaluer les performances du support d’exécution, afin de pouvoir estimer les gains et/ou pertes introduits par notre travail.– La nécessité des outils permettant d’analyser les performances obtenues pour pouvoir trouver de possibles causes de pertes de performance.– L’isolation et l’apport de solutions aux problèmes de performance de StarPU-MPI mis à jour.– La validation des solutions proposées par une nouvelle évaluation des performances

Programmation des architectures hétérogènes à l’aide de tâches divisibles

National audienceL'un des aspects les plus difficiles, lors du découpage d’une application en graphe de tâches, est de choisir la granularité de ce découpage, qui va typiquement de pair avec la taille des blocs utilisés pour partitionner les données du problème. Les granularités trop petites ne permettent pas d’exploiter efficacement les accélérateurs de type GPU, qui ont besoin de mettre en œuvre un parallélisme massif pour "tourner à plein régime". À l'inverse, les processeurs traditionnels exhibent souvent des performances optimales à des granularités beaucoup plus fines. Le choix du découpage est donc non seulement difficile, mais il a en outre une influence sur la quantité de parallélisme disponible dans le système : trop de petites tâches risque d’inonder le système en introduisant un surcoût inutile, alors que peu de grosses tâches risque d’aboutir à un déficit de parallélisme. Fixer un découpage manuellement demande donc de nombreux tâtonnements avant de trouver le bon compromis.L’objectif de ce travail de recherche est d’introduire dans StarPU la notion de tâches divisibles, c’est-à-dire de tâches que le support d’exécution pourra décider (ou non) de redécouper en plusieurs sous-tâches `a l’exécution, en fonction de différents critères tels que la quantité de parallélisme que l’on souhaite générer, l'opportunité d’exploiter certains types d’unités de calcul à un moment donné, etc. Une grande partie du travail consistera à étudier comment gérer efficacement une partition non uniforme des données (pour autoriser la coexistence de sous-données de différentes granularités) ainsi qu’une gestion des dépendances entre tâches s’adaptant à des raffinements locaux du graphe de tâches

Modulariser les ordonnanceurs de tâches : une approche structurelle

International audiencePour pouvoir exploiter pleinement les architectures contemporaines, une abstraction de la machine appelée support d'exécution se charge de faciliter le travail du programmeur. Les implémentations actuelles des heuristiques d'ordonnancement avancées peuvent présenter des difficultés de passage à l'échelle. À l'inverse, les heuristiques qui passent à l'échelle sont généralement plutôt simples. Nous proposons un modèle d'ordonnanceurs modulaire qui facilite l'exploration de solutions d'ordonnancement. Nous montrons que les performances de notre modèle d'ordonnanceurs sont équivalentes à celles de l'état de l'art tout en offrant des perspectives de passage à l'échelle

Static Local Concurrency Errors Detection in MPI-RMA Programs

International audienceCommunications are a critical part of HPC simulations, and one of the main focuses of application developers when scaling on supercomputers. While classical message passing (also called two-sided communications) is the dominant communication paradigm, one-sided communications are often praised to be efficient to overlap communications with computations, but challenging to program. Their usage is then generally abstracted through languages and memory abstractions to ease programming (e.g. PGAS). Therefore, little work has been done to help programmers use intermediate runtime layers, such as MPI-RMA, that is often reserved to expert programmers. Indeed, programming with MPI-RMA presents several challenges that require handling the asynchronous nature of one-sided communications to ensure the proper semantics of the program while ensuring its memory consistency. To help programmers detect memory errors such as race conditions as early as possible, this paper proposes a new static analysis of MPI-RMA codes that shows to the programmer the errors that can be detected at compile time. The detection is based on a novel local concurrency errors detection algorithm that tracks accesses through BFS searches on the Control Flow Graphs of a program. We show on several tests and an MPI-RMA variant of the GUPS benchmark that the static analysis allows to detect such errors on user codes. The error codes are integrated in the MPI Bugs Initiative opensource test suite

Overview of Distributed Linear Algebra on Hybrid Nodes over the StarPU Runtime

International audienceRuntime systems usually abstract a single node, like Plasma/Quark, Flame/SuperMatrix, Morse/StarPU,Dplasma/Parsec ... When going into harnessing cluster of nodes, how should they communicate? By using explicit MPI user calls ? By using a specific paradigm (Dplasma) ? Or can we keep the same paradigm and almost the same code, and leave the runtime system handle data transfers? We show how such a system has been sucessfully implemented on top of the StarPU runtime

Achieving High Performance on Supercomputers with a Sequential Task-based Programming Model

International audienceThe emergence of accelerators as standard computing resources on supercomputers and the subsequent architectural complexity increase revived the need for high-level parallel programming paradigms. Sequential task-based programming model has been shown to efficiently meet this challenge on a single multicore node possibly enhanced with accelerators, which motivated its support in the OpenMP 4.0 standard. In this paper, we show that this paradigm can also be employed to achieve high performance on modern supercomputers composed of multiple such nodes, with extremely limited changes in the user code. To prove this claim, we have extended the StarPU runtime system with an advanced inter-node data management layer that supports this model by posting communications automatically. We illustrate our discussion with the task-based tile Cholesky algorithm that we implemented on top of this new runtime system layer. We show that it enables very high productivity while achieving a performance competitive with both the pure Message Passing Interface (MPI)-based ScaLAPACK Cholesky reference implementation and the DPLASMA Cholesky code, which implements another (non-sequential) task-based programming paradigm

Passage à l'echelle d'un support d'exécution à base de tâches pour l'algèbre linéaire dense

The ever-increasing supercomputer architectural complexity emphasizes the need for high-level parallel programming paradigms to design efficient, scalable and portable scientific applications. Among such paradigms, the task-based programming model abstracts away much of the architecture complexity by representing an application as a Directed Acyclic Graph (DAG) of tasks. Among them, the Sequential-Task-Flow (STF) model decouples the task submission step, sequential, from the parallel task execution step. While this model allows for further optimizations on the DAG of tasks at submission time, there is a key concern about the performance hindrance of sequential task submission when scaling. This thesis’ work focuses on studying the scalability of the STF-based StarPU runtime system (developed at Inria Bordeaux in the STORM team) for large scale 3D simulations of the CEA which uses dense linear algebra solvers. To that end, we collaborated with the HiePACS team of Inria Bordeaux on the Chameleon software, which is a collection of linear algebra solvers on top of task-based runtime systems, to produce an efficient and scalable dense linear algebra solver on top of StarPU up to 3,000 cores and 288 GPUs of CEA-DAM’s TERA-100 cluster.La complexification des architectures matérielles pousse vers l’utilisation de paradigmes de programmation de haut niveau pour concevoir des applications scientifiques efficaces, portables et qui passent à l’échelle. Parmi ces paradigmes, la programmation par tâches permet d’abstraire la complexité des machines en représentant les applications comme des graphes de tâches orientés acycliques (DAG). En particulier, le modèle de programmation par tâches soumises séquentiellement (STF) permet de découpler la phase de soumission des tâches, séquentielle, de la phase d’exécution parallèle des tâches. Même si ce modèle permet des optimisations supplémentaires sur le graphe de tâches au moment de la soumission, il y a une préoccupation majeure sur la limite que la soumission séquentielle des tâches peut imposer aux performances de l’application lors du passage à l’échelle. Cette thèse se concentre sur l’étude du passage à l’échelle du support d’exécution StarPU (développé à Inria Bordeaux dans l’équipe STORM), qui implémente le modèle STF, dans le but d’optimiser les performances d’un solveur d’algèbre linéaire dense utilisé par le CEA pour faire de grandes simulations 3D. Nous avons collaboré avec l’équipe HiePACS d’Inria Bordeaux sur le logiciel Chameleon, qui est une collection de solveurs d’algèbre linéaire portés sur supports d’exécution à base de tâches, afin de produire un solveur d’algèbre linéaire dense sur StarPU efficace et qui passe à l’échelle jusqu’à 3 000 coeurs de calcul et 288 accélérateurs de type GPU du supercalculateur TERA-100 du CEA-DAM

Scalability of a task-based runtime system for dense linear algebra applications

La complexification des architectures matérielles pousse vers l’utilisation de paradigmes de programmation de haut niveau pour concevoir des applications scientifiques efficaces, portables et qui passent à l’échelle. Parmi ces paradigmes, la programmation par tâches permet d’abstraire la complexité des machines en représentant les applications comme des graphes de tâches orientés acycliques (DAG). En particulier, le modèle de programmation par tâches soumises séquentiellement (STF) permet de découpler la phase de soumission des tâches, séquentielle, de la phase d’exécution parallèle des tâches. Même si ce modèle permet des optimisations supplémentaires sur le graphe de tâches au moment de la soumission, il y a une préoccupation majeure sur la limite que la soumission séquentielle des tâches peut imposer aux performances de l’application lors du passage à l’échelle. Cette thèse se concentre sur l’étude du passage à l’échelle du support d’exécution StarPU (développé à Inria Bordeaux dans l’équipe STORM), qui implémente le modèle STF, dans le but d’optimiser les performances d’un solveur d’algèbre linéaire dense utilisé par le CEA pour faire de grandes simulations 3D. Nous avons collaboré avec l’équipe HiePACS d’Inria Bordeaux sur le logiciel Chameleon, qui est une collection de solveurs d’algèbre linéaire portés sur supports d’exécution à base de tâches, afin de produire un solveur d’algèbre linéaire dense sur StarPU efficace et qui passe à l’échelle jusqu’à 3 000 coeurs de calcul et 288 accélérateurs de type GPU du supercalculateur TERA-100 du CEA-DAM.The ever-increasing supercomputer architectural complexity emphasizes the need for high-level parallel programming paradigms to design efficient, scalable and portable scientific applications. Among such paradigms, the task-based programming model abstracts away much of the architecture complexity by representing an application as a Directed Acyclic Graph (DAG) of tasks. Among them, the Sequential-Task-Flow (STF) model decouples the task submission step, sequential, from the parallel task execution step. While this model allows for further optimizations on the DAG of tasks at submission time, there is a key concern about the performance hindrance of sequential task submission when scaling. This thesis’ work focuses on studying the scalability of the STF-based StarPU runtime system (developed at Inria Bordeaux in the STORM team) for large scale 3D simulations of the CEA which uses dense linear algebra solvers. To that end, we collaborated with the HiePACS team of Inria Bordeaux on the Chameleon software, which is a collection of linear algebra solvers on top of task-based runtime systems, to produce an efficient and scalable dense linear algebra solver on top of StarPU up to 3,000 cores and 288 GPUs of CEA-DAM’s TERA-100 cluster