Vérification des noyaux GPU dans le contexte de la programmation à base de tâches (application à StarPU/Kokkos)

Verifying GPU kernels in the context of task-based programming (application to StarPU/Kokkos)

• Auteur / Autrice : Léo Fremery
• Direction : Samuel Thibault, Emmanuelle Saillard
• Type : Projet de thèse
• Discipline(s) : Informatique
• Date : Inscription en doctorat le 30/09/2026
• Etablissement(s) : Bordeaux
• Ecole(s) doctorale(s) : École doctorale de mathématiques et informatique
• Partenaire(s) de recherche : Laboratoire : LaBRI - Laboratoire Bordelais de Recherche en Informatique
• Partenaire(s) de recherche : Equipe de recherche : Supports et Algorithmes pour les applications numériques hautes performances (SATANAS)

Mots clés

Mots clés libres

Programmation à base de tâches

Programmation GPU

Optimisation

Vérification

Compilation

Task-based programming

Optimisation

Vérification

GPU programming

Compilation

Résumé

L'utilisation croissante des accélérateurs de calcul GPU se confirme à travers le classement TOP500, qui recense les supercalculateurs les plus puissants au monde. Dans ce contexte, écrire des programmes corrects et efficaces pour les GPU constitue un enjeu critique. La programmation parallèle est connue pour être particulièrement difficile, avec des symptômes complexes à identifier tels que des résultats non déterministes ou des corruptions de données silencieuses. Dans le cas de la programmation pour GPU, cette difficulté est très largement amplifiée, les débordements de tampons étant très largement non capturés par l'environnement d'exécution. Les potentielles pertes de performance sont également démultipliées par l'architecture particulière de ces plateformes. Ces obstacles sont ainsi extrêmement complexes à identifier à grande échelle. Les méthodes actuelles de vérification des noyaux GPU se divisent principalement en deux approches: les approches statiques et les approches dynamiques. Les approches statiques [NGB26, CKPT25, CLLZ23, LLS+12] sont capables de détecter les erreurs quelque soit le jeu d'entrée mais sont basées sur de la vérification formelle et souffrent souvent d'un sur-coût d'analyse majeur, de faux positifs, ou nécessitent des annotations manuelles lourdes de la part du développeur ou de la développeuse. Les approches dynamiques s [OLG25, JBG24, EPP+17, AGR+18, PGD18, KGB20, WOZ+20, KB21] sont précises mais sur le jeu de données utilisé et ne garantissent pas l'absence totale d'erreur. Elles augmentent également le temps d'exécution. Une approche récente [CZD+26] utilise des LLMs pour générer automatiquement des annotations destinées à un outil de vérification formelle basé sur un solveur SMT, afin de prouver l'absence d'accès concurrent dans les noyaux CUDA. Cette approche souffre des mêmes inconvénients que les approches statiques. De plus, une grande partie de l'état de l'art se focalise quasi exclusivement sur la détection des accès mémoire concurrents. Si ces erreurs sont majeures, d'autres anomalies sont négligées: synchronisations de intra-wraps, incohérences de dimensions de matrices, accès incorrects à des données. Une des raisons pour les limitations des approches actuelles est un manque d'information sur les données manipulées, et notamment leurs tailles et leurs formes, à moins d'imposer l'ajout de lourdes annotations de code. Le code hôte de soumission de kernels pourrait fournir cette information, mais la plupart des outils existant ne l'exploite pas, en partie car elle reste difficile à l'y obtenir. Par ailleurs, sur la décennie passée, la programmation à base de tâches est progressivement devenu un paradigme de plus en plus utilisé par les codes HPC, dans des classes d'applications diverses. Dans ce cadre, l'expression des tailles et formes des données fait partie du modèle de programmation en lui-même. Ainsi, lors de l'exécution d'une tâche, ces informations sont disponibles de manière fiable au moment de la soumission d'un kernel au GPU. Il devient alors possible de vérifier les paramètres de cette soumission, et d'apporter cette information à la vérification du code du kernel, qui n'a plus besoin de reposer sur des heuristiques imprécises.

The growing use of GPU accelerators is confirmed by the TOP500 ranking, which lists the most powerful supercomputers in the world. In this context, writing correct and efficient GPU programs is a critical challenge. Parallel programming is known to be particularly difficult, with complex symptoms that are hard to identify, such as non-deterministic results or silent data corruption. In the case of GPU programming, this difficulty is greatly amplified, since buffer overflows are largely not captured by the runtime environment. Potential performance losses are also multiplied due to the specific architecture of these platforms. As a result, these issues are extremely complex to detect at scale. Current methods for verifying GPU kernels are mainly divided into two approaches: static and dynamic. Static approaches [NGB26, CKPT25, CLLZ23, LLS+12] are capable of detecting errors regardless of the input dataset, but they rely on formal verification and often suffer from significant analysis overhead, false positives, or require heavy manual annotations from the developer. Dynamic approaches s [OLG25, JBG24, EPP+17, AGR+18, PGD18, KGB20, WOZ+20, KB21] are precise but only for the dataset used and do not guarantee the complete absence of errors. They also increase execution time. A recent approach [CZD+26] uses LLMs to automatically generate annotations for a formal verification tool based on an SMT solver, in order to prove the absence of concurrent accesses in CUDA kernels. This approach suffers from the same drawbacks as static approaches. Moreover, a large part of the state of the art focuses almost exclusively on detecting concurrent memory accesses. While these errors are critical, other anomalies are overlooked: intra-warp synchronization issues, inconsistencies in matrix dimensions, and incorrect data accesses. One of the reasons for the limitations of current approaches is the lack of information about the data being manipulated, particularly their sizes and shapes, unless heavy code annotations are imposed. The host code that submits kernels could provide this information, but most existing tools do not exploit it, partly because it remains difficult to extract. Besides, over the past decade, task-based programming has gradually become an increasingly used paradigm in HPC codes across various application domains. In such framework, expressing the sizes and shapes of data is part of the programming model itself. Thus, when a task is executed, this information is reliably available at the moment a kernel is submitted to the GPU. It then becomes possible to verify the parameters of this submission and to incorporate this information into the verification of the kernel code, which no longer needs to rely on imprecise heuristics.