Concurrent Scheduling of High-Level Parallel Programs on Multi-GPU Systems

Les supercalculateurs modernes ne sont plus de simples versions plus rapides des machines d'il y a quelques décennies ; ce sont de vastes collections de milliers de processeurs spécialisés travaillant de concert. Pour tirer le meilleur parti de ces systèmes massifs, les scientifiques s'appuient sur des logiciels capables de décider automatiquement quelle partie d'un calcul va à quel processeur et comment les données circulent entre eux. C'est une tâche difficile car le logiciel doit gérer la mémoire et la communication sans ralentir le travail effectif. Si le système passe trop de temps à déterminer où placer les données ou comment maintenir leur cohérence, les puissants processeurs restent inactifs, gaspillant ainsi de l'énergie et du temps. Le défi est de prendre ces décisions assez rapidement pour que l'ordinateur ne s'arrête jamais pour réfléchir, maintenant le flux de travail aussi fluide que l'écoulement de l'eau dans une rivière.

Des chercheurs de l'Université d'Innsbruck ont développé une nouvelle façon de gérer ce problème d'ordonnancement pour les systèmes équipés de nombreuses unités de traitement graphique, ou GPU. Ces puces sont conçues pour gérer d'énormes quantités de travail parallèle, mais coordonner des centaines d'entre elles nécessite un gestionnaire sophistiqué. L'équipe a introduit une méthode appelée ordonnancement par graphe d'instructions, qui agit comme une carte détaillée et de bas niveau de chaque opération que l'ordinateur doit effectuer. Au lieu de prendre des décisions au fur et à mesure que chaque étape est nécessaire, le système construit un plan complet qui inclut l'allocation de la mémoire, les transferts de données et les calculs réels. Ce plan est généré pendant que l'ordinateur travaille déjà sur des tâches précédentes, permettant ainsi à l'ordonnanceur de regarder vers l'avenir et de préparer les étapes suivantes sans interrompre le flux actuel.

Le cœur de cette approche est un changement dans la manière dont le logiciel perçoit le travail. Auparavant, le système générait une liste de tâches de haut niveau, puis déterminait les détails spécifiques, comme la copie de la mémoire, uniquement au moment de l'exécution. Cela entraînait souvent des retards car le système devait s'arrêter et analyser les dépendances en plein milieu d'un calcul. La nouvelle méthode décompose chaque tâche en ses plus petites composantes, comme l'allocation d'un bloc de mémoire spécifique ou l'envoi d'un petit morceau de donnée à un processeur voisin. En organisant ces étapes minuscules en un seul graphe interconnecté, le système peut voir exactement quelles étapes peuvent se produire simultanément. Cela permet à l'ordinateur de superposer la communication et le calcul, ce qui signifie que les données peuvent circuler entre les processeurs pendant que les puces effectuent les calculs, plutôt que d'attendre qu'une tâche soit terminée avant de commencer l'autre.

Pour tester cette idée, les chercheurs ont intégré leur système dans un cadre logiciel appelé Celerity, conçu pour exécuter des simulations complexes sur des clusters de GPU. Ils ont fait fonctionner trois applications scientifiques différentes pour voir comment le nouvel ordonnanceur se comportait par rapport à la version standard. Une application simulait l'attraction gravitationnelle entre des milliards de particules, une autre modélait la façon dont le son rebondit dans une pièce, et la troisième suivait le mouvement des ondes à travers un milieu. Dans chaque cas, ils ont mesuré la vitesse à laquelle le programme s'exécutait en ajoutant davantage de GPU, une métrique connue sous le nom de mise à l'échelle forte (strong scaling). Les résultats ont montré que la nouvelle approche surpassait systématiquement le système de base, surtout lorsque le nombre de processeurs augmentait. Sur un système de 128 GPU, le nouvel ordonnanceur a permis à l'application de simulation de pièce de s'exécuter plus de deux fois plus vite que l'ancienne méthode, tandis que la simulation de particules a également bénéficié d'un gain de vitesse significatif.

Une innovation clé de ce travail est une technique appelée "lookahead" de l'ordonnanceur (scheduler lookahead), qui résout un problème spécifique lié à l'utilisation de la mémoire. Dans de nombreuses simulations, la quantité de données dont un programme a besoin peut changer d'une étape à l'autre. Sans un moyen de prédire ces changements, le logiciel pourrait allouer un petit bloc de mémoire, pour s'apercevoir un instant plus tard qu'il est trop petit, ce qui l'obligerait à allouer un bloc plus grand et à y copier toutes les données. Ce processus de redimensionnement est lent et peut faire perdre un temps précieux. Le nouveau système regarde les tâches à venir pour voir si les besoins en mémoire augmentent. S'il détecte un schéma où la taille des données va croître, il attend d'allouer la mémoire jusqu'à ce qu'il connaisse la taille finale nécessaire, évitant ainsi totalement l'étape coûteuse de redimensionnement. Cela est particulièrement efficace pour les applications où les données croissent régulièrement, permettant au système d'allouer la quantité de mémoire correcte en une seule fois.

Les chercheurs ont également construit une architecture système qui sépare le travail de planification du travail d'exécution. Ils ont créé un thread dédié, ou une ligne d'exécution séparée, qui est responsable uniquement de la construction de ces graphes d'instructions détaillés. Pendant ce temps, d'autres threads gèrent l'exécution réelle des instructions sur les GPU. Cette séparation garantit que le processus de planification des étapes suivantes ne gêne pas les étapes en cours d'exécution. Les deux processus fonctionnent côte à côte, communiquant via une file d'attente rationalisée qui transmet les instructions du planificateur à l'exécuteur. Cette conception minimise le temps d'attente du système, garantissant que les GPU restent occupés par un travail utile plutôt que de rester inactifs pendant que le logiciel décide de la marche à suivre.

Les expériences ont été menées sur le supercalculateur Leonardo en Italie, une machine dotée de milliers de processeurs et de connexions à haute vitesse. L'équipe a utilisé des codes scientifiques réels pour s'assurer que leurs conclusions seraient valables dans des scénarios pratiques. Ils ont constaté que, bien que la nouvelle méthode ne modifie pas les limites fondamentales de la quantité de données pouvant être stockées ou de la taille des problèmes pouvant être traités, elle améliorait considérablement l'efficacité de la distribution de ce travail. Les améliorations étaient les plus notables dans les applications où les modèles d'accès aux données étaient complexes ou changeants, car le système pouvait mieux masquer le temps passé sur la communication et la gestion de la mémoire. Pour les applications avec des étapes de calcul très courtes, le nouvel ordonnanceur a réduit la surcharge de manière à maintenir une mise à l'échelle efficace, même avec un grand nombre de processeurs.

Ce travail démontre que la manière dont le logiciel gère la logistique interne d'un supercalculateur est tout aussi importante que la puissance brute du matériel lui-même. En déplaçant la lourde tâche de l'ordonnancement hors du chemin critique et en l'intégrant dans un processus parallèle, les chercheurs ont montré qu'il est possible de maintenir ces machines massives à leur efficacité maximale. L'approche par graphe d'instructions offre un moyen de visualiser et de gérer le réseau complexe de dépendances qui existe dans les programmes parallèles modernes, transformant ce qui était autrefois un goulot d'étranglement en un pipeline fluide. À mesure que les supercalculateurs augmentent en taille et en complexité, des techniques comme celle-ci seront essentielles pour garantir que les scientifiques tirent le meilleur parti de leurs investissements, leur permettant de résoudre des problèmes qui étaient auparavant trop vastes ou trop lents à traiter.