Comprendre et Guider la Gestion des Ressources de Calcul dans un Contexte Multi-Modèles de Programmation

Avec l’avènement des processeurs multi-coeur et many-coeur comme bloc de base des supercalculateurs, beaucoup d’applications évoluent. Au lieu de n’utiliser qu’un seul modèle de programmation parallèle à mémoire distribuée (comme MPI), elles se doivent d’ajouter des modèles à mémoire partagée (comme OpenMp). Ces deux types de modèles se retrouvent en cohabitation au sein de l’application. Cela conduit à une meilleure exploitation des communications en mémoire partagée, tout en réduisant l’empreinte mémoire globale des applications. Cependant, cette évolution a un large impact sur la pile logicielle car les développeurs mélangent généralement plusieurs modèles de programmation pour passer à l’échelle sur un grand nombre de nœuds de calcul. Un effet de bord de cette approche de la programmation est l’empilement de modèles (‘runtime stacking’) : mélanger plusieurs modèles implique que plusieurs bibliothèques fonctionnent en même temps. Gérer plusieurs bibliothèques peut mener à un grand nombre de fils d’exécution utilisant les ressources sous-jacentes de manière non optimale.Nous présentons tout d’abord une étude du mélange de modèles de programmation. Elle introduit des configurations et catégories qui décrivent comment le mélange peut apparaitre dans les applications. Nous explorons les configurations spatiales et temporelles de mélange en nous concentrant sur le placement des fils d’exécution, provenant de plusieurs bibliothèques, sur les ressources matérielles. Nous construisons cette taxonomie en nous basant sur l’analyse de l’état de l’art des modèles de programmation et de leurs mélanges.Nous proposons ensuite des algorithmes pour détecter les mauvaises utilisations des ressources de calcul lors de l’exécution d’une application mélangeant plusieurs modèles de programmation. Nous avons implémenté ces algorithmes dans un outil dynamique appelé ‘Overseer’. Cet outil surveille l’application, et produit un rapport présentant l’utilisation des ressources tout au long de l’exécution. Le but de cette analyse est de mettre en lumière la sur- ou sous-utilisation des ressources de calcul.Enfin, nous proposons un second outil appelé ‘Overmind’, dont le but est de surveiller et de gérer le placement des fils d’exécution à la volée. La topologie des ressources des calculs ainsi que le comportement de l’application sont pris en compte pour utiliser au mieux toutes les ressources à disposition. En capturant une vue globale de l’utilisation des ressources, l’Overmind adapte le placement des fils d’exécution, et vise à prendre la meilleure décision pour améliorer l’utilisation des ressources de calcul de chaque nœud du supercalculateur.Nous démontrons la pertinence de notre approche et montrons qu’avec son faible surcout, notre implémentation est capable d’améliorer les performances d’applications, même si celles-ci utilisaient les ressources de calcul de manière non optimale à l’origine.With the advent of multicore and manycore processors as building blocks of HPC supercomputers, many applications shift from relying solely on a distributed programming model (e.g., MPI) to mixing distributed and shared memory models (e.g., MPI+OpenMP). This leads to a better exploitation of shared-memory communications and reduces the overall memory footprint. However, this evolution has a large impact on the software stack as applications’ developers do typically mix several programming models to scale over a large number of multicore nodes while coping with their hierarchical depth. One side effect of this programming approach is runtime stacking: mixing multiple models involve various runtime libraries to be alive at the same time. Dealing with different runtime systems may lead to a large number of execution flows that may not efficiently exploit the underlying resources.We first present a study of runtime stacking. It introduces stacking configurations and categories to describe how stacking can appear in applications. We explore runtime-stacking configurations (spatial and temporal) focusing on thread/process placement on hardware resources from different runtime libraries. We build this taxonomy based on the analysis of state-of-the-art runtime stacking and programming models.We then propose algorithms to detect the misuse of compute resources when running a hybrid parallel application. We have implemented these algorithms inside a dynamic tool, called the Overseer. This tool monitors applications, and outputs resource usage to the user with respect to the application timeline, focusing on overloading and underloading of compute resources.Finally, we propose a second external tool called Overmind, that monitors the thread/process management and (re)maps them to the underlying cores taking into account the hardware topology and the application behavior. By capturing a global view of resource usage the Overmind adapts the process/thread placement, and aims at taking the best decision to enhance the use of each compute node inside a supercomputer. We demonstrate the relevance of our approach and show that our low-overhead implementation is able to achieve good performance even when running with configurations that would have ended up with bad resource usage