Au cours des dernières décennies, les supercalculateurs sont devenus de plus en plus complexes, avec un nombre croissant de nœuds, de GPU, de CPU et de niveaux dans la hiérarchie de la mémoire, ce qui a conduit à des plateformes toujours plus puissantes qui, en 2026, dépasseront les deux quintillions d’opérations en virgule flottante par seconde. Exploiter pleinement ces plateformes représente un véritable défi. Afin d’éviter d’avoir à réécrire une application à chaque changement de matériel sous-jacent, des systèmes d’exécution ont été développés. Ceux-ci fournissent une abstraction de la machine, permettant aux utilisateurs de se concentrer principalement sur le développement d’applications, tandis que les détails de bas niveau tels que la gestion de la mémoire, l’initialisation des pilotes et les communications sont gérés automatiquement. Parmi les systèmes d’exécution existants, nombreux sont ceux qui s’appuient désormais sur la programmation par tâches, dans laquelle une application est divisée en petites unités de travail, appelées tâches. Ces tâches peuvent dépendre les unes des autres, formant ainsi un graphe acyclique orienté (DAG) que le système d'exécution peut exploiter. En particulier, le modèle de programmation « Sequential Task Flow » (STF) facilite l'expression de tels DAG en construisant automatiquement des dépendances à partir des accès aux données. Cependant, le STF, et plus généralement les modèles de programmation basés sur les tâches, sont confrontés à un défi majeur : le choix de la taille des tâches, appelé « granularité ». En effet, ces modèles exigent que la granularité soit choisie au moment de la soumission des tâches afin de garantir une exécution cohérente. De plus, les processeurs (CPU) et les processeurs graphiques (GPU) nécessitent des granularités de tâches différentes pour être utilisés efficacement, ce qui signifie qu’une granularité choisie de manière statique peut parfois limiter les performances. Pour remédier à ce problème, les systèmes d’exécution modernes tels qu’OpenMP, PaRSEC, OmpSs, StarPU et IRIS étendent le modèle de tâches en introduisant des tâches récursives. Au moment de l’exécution, les tâches récursives peuvent soit être exécutées comme des tâches classiques, soit soumettre un sous-DAG de tâches. Cela permet à l'exécution finale d'utiliser une granularité éventuellement plus fine que celle sélectionnée lors de la soumission initiale, améliorant ainsi le dynamisme des systèmes d'exécution. Cependant, la plupart des systèmes d'exécution prenant en charge les tâches récursives laissent à l'utilisateur le soin de choisir la granularité finale, ce qui réduit la portabilité des applications. En effet, chaque changement de génération matérielle peut nécessiter un ajustement de la granularité des tâches. Cette thèse aborde cette question en proposant plusieurs stratégies permettant de déterminer dynamiquement la granularité des tâches à l’aide du modèle de tâches récursives. Nous proposons différentes stratégies pour améliorer l’utilisation des plateformes tant homogènes qu’hétérogènes. Nous identifions également les adaptations nécessaires au sein des systèmes d’exécution pour permettre une sélection dynamique et automatique de la granularité des tâches à l’aide des tâches récursives. De plus, nous étudions comment le modèle de tâches récursives peut contribuer à résoudre les problèmes découlant de l’utilisation du modèle STF dans un contexte de mémoire distribuée. Tout au long de cette thèse, nous utilisons le modèle de tâches récursives fourni par le système d’exécution StarPU, et évaluons les performances de nos stratégies à l’aide de la bibliothèque d’algèbre linéaire dense Chameleon sur différentes plateformes.