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

On the use of hierarchical task for heterogeneous architectures

• Auteur / Autrice : Gwenolé Lucas
• Direction : Abdou Guermouche, Raymond Namyst
• Type : Thèse de doctorat
• Discipline(s) : Informatique
• Date : Soutenance le 10/10/2023
• Etablissement(s) : Bordeaux
• Ecole(s) doctorale(s) : École doctorale Mathématiques et informatique (Talence, Gironde ; 1991-....)
• Partenaire(s) de recherche : Laboratoire : Laboratoire bordelais de recherche en informatique
• Jury : Président / Présidente : Alfredo Buttari
• Jury : Examinateurs / Examinatrices : Thomas Hérault, Vincenç Beltran, Isabelle Terrasse
• Jury : Rapporteur / Rapporteuse : Alfredo Buttari, Siegfried Benkner

Mots clés

Mots clés contrôlés

Algèbre linéaire

Programmation (informatique)

Calcul intensif (informatique)

Mots clés libres

Calcul Haute-Performance

Supports d’exécution

Programmation à base de tâches

Modèles de programmation

Calcul hétérogène

Algèbre linéaire dense

High-performance computing

Runtime systems

Task-based programming

Programming models

Heterogeneous computing

Dense linear algebra

Résumé

Au cours des dernières décennies, les plateformes de calcul haute performance ont connu une croissance exponentielle de leur puissance de calcul au détriment d’une complexité toujours plus grande. Programmer ces plateformes pour tirer pleinement parti de leur puissance de calcul est un défi de taille. Le programmeur doit prendre en compte les différents types d’unités de calcul, la hiérarchie de la mémoire, les transferts de données au sein d’un noeud ou à travers un réseau, etc. Les supports d’exécution à base de tâches ont gagné en popularité grâce à leur capacité à exprimer des applications performantes et portables sur ces architectures hétérogènes complexes. Ce paradigme s’appuie sur divers modèles de programmation pour représenter les applications sous la forme de graphes de tâches. Plus particulièrement, le modèle de soumission séquentielle de tâche (Sequential Task Flow, STF) fournit une interface simple pour écrire des applications performantes, mais ne produit malheureusement que des graphes de tâches statiques. Ce manque de dynamisme est préjudiciable aux exécutions destinées à des systèmes hétérogènes, où la granularité des tâches peut avoir besoin d’être ajustée selon les types d’unités de calcul disponibles à un moment donné. La nature séquentielle du modèle STF crée également un surcoût à la soumission qui peut limiter le passage à l’échelle de certaines applications présentant énormément de parallélisme. Cette thèse propose de répondre à ces problèmes en étendant le modèle de StarPU pour y inclure des tâches hiérarchiques, capables d’insérer des sous-graphes au cours de leur exécution. Les graphes de tâches gagnent ainsi en dynamisme, ce qui permet d’ajuster la granularité des tâches à l’exécution pour correspondre au mieux aux unités de calcul ciblées. Par ailleurs, les tâches hiérarchiques peuvent être utilisées pour paralléliser le processus de soumission et en réduire le surcoût. En effet, il est possible de traiter des tâches hiérarchiques indépendantes en parallèle. Notre modèle est complété par un gestionnaire de données capable d’adapter dynamiquement la disposition des données sans intervention du programmeur. Il contribue également à l’exactitude du graphe de tâche, car l’insertion de sous-graphes à l’exécution contourne les règles du STF. Nous parvenons à ce résultat grâce aux tâches de synchronisation qui ajustent la disposition des données autour des tâches hiérarchiques. Nous avons implémenté ce modèle et l’avons appliqué à la bibliothèque d’algèbre linéaire dense Chameleon. La coexistence de plusieurs granularités de tâches a permis d’améliorer les performances sur des architectures hétérogènes. Cela valide notre modèle et fournit une évaluation des avantages de l’utilisation de tâches hiérarchiques dans StarPU.

In the last decades, the computing power of high-performance platforms has grown exponentially at the expense of increased complexity. Programming such platforms to take full advantage of their computing power is challenging. The programmer must take into account different types of computing units, memory hierarchy, data transfers within a node or across a network, etc. Task-based runtime systems have become popular because of their ability to express efficient and portable applications on these complex heterogeneous architectures. This paradigm relies on various programming models to represent applications as task graphs. In particular, the Sequential Task Flow (STF) model provides a simple interface for writing efficient applications, but unfortunately only supports static task graphs. The lack of dynamism is detrimental for execution on heterogeneous systems, where task granularity may need to be adjusted to optimally match the different types of computing units available at any given time. The sequential nature of the STF model also creates a submission overhead that limits scalability for embarrassingly parallel applications. In this thesis, we address these issues by extending the STF model in the StarPU runtime system with hierarchical tasks, which can insert subgraphs at runtime. This allows for more dynamic task graphs, making it possible to adjust task granularity at runtime to best match the targeted computing units. In addition, the submission overhead can be reduced by using large-grain hierarchical tasks to parallelize the submission process. Indeed, independent hierarchical tasks can be processed in parallel on different workers. Our hierarchical task model is combined with an advanced data manager to dynamically switch between different data layouts without programmer input. The data manager also contributes to the correctness of the task graph, since the insertion of subgraphs at runtime bypasses the usual rules of the STF model. This is achieved through the synchronization tasks that adapt the data layout around hierarchical tasks. We implemented this model and applied it in the context of dense linear algebra using the Chameleon library. The coexistence of multiple task granularities thanks to hierarchical tasks resulted in good performance improvements on heterogeneous architectures. This allowed us to validate our model and evaluate the potential benefits of hierarchical tasks in StarPU.