Cette page contient les informations concernant la soutenance de ma thèse, intitulée Programmation sûre, expressive et efficace de circuits FPGA.
La soutenance aura lieu lundi 25 novembre 2024 à 14 heures en salle 55-65 211, à l'UFR d'Ingénierie, sur le campus Pierre et Marie Curie de Sorbonne Université (4 place Jussieu 75005, Paris).
La soutenance sera retransmise par visioconférence suivant ce lien (susceptible de changer) : https://galene.irill.org/group/irill/these-loic (choisir un nom d'utilisateur, le mot de passe peut rester vide)
Les FPGA (Field-Programmable Gate Arrays) sont des circuits numériques reconfigurables : leur comportement est personnalisable par synthèse logique de spécifications au niveau transfert de registres (niveau RT), dans des langages de description de matériel comme VHDL ou Verilog. Les FPGA sont bien adaptés pour réaliser des systèmes réactifs, directement sous forme de circuits synchrones interagissant avec l’environnement extérieur via des broches d’entrées/sorties – le synthétiseur logique garantissant que les contraintes temporelles du système sont respectées compte tenu de la fréquence d’horloge du FPGA cible. Les FPGA sont par ailleurs utilisés pour implanter des accélérateurs matériels. Cependant, les descriptions au niveau RT de systèmes transformationnels (ou "calculs") – ayant des latences de plusieurs cycles d’horloge – sont difficiles à mettre au point, maintenir et optimiser manuellement. La synthèse haut niveau (High-Level Synthesis, HLS) constitue alors une solution pour exprimer plus simplement les calculs, dans un langage de programmation compilé au niveau RT. L’avantage de cette approche est de cacher aux programmeuses et programmeurs les détails d’implantation, en laissant au compilateur le soin d’ordonnancer les calculs au cours du temps. Cela conduit toutefois à une perte de contrôle sur le comportement temporel et donc la sûreté et l’efficacité des circuits engendrés. À l’heure où les systèmes embarqués, notamment à base de FPGA, doivent exécuter toujours plus de calculs, tout en interagissant avec leur environnement, cette thèse propose un modèle de programmation pour combiner description de matériel (orientée flot de données) et calcul parallèle généraliste (orienté flot de contrôle) suivant une approche synchrone. Cela donne lieu à la conception et l’implantation d’Eclat, un langage de programmation fonctionnel-impératif, parallèle et synchrone, compilé en VHDL. Eclat est suffisamment précis pour décrire des circuits synchrones au niveau RT. Il permet de programmer simplement des accélérateurs matériels, avec une sémantique temporelle claire et prédictible par laquelle exploiter des compromis temps-espace. Tout programme Eclat est réactif, avec un mécanisme pour plonger les calculs dans les programmes et ainsi mélanger calcul et interaction. Eclat offre aussi de la mémoire partagée (réalisée sous forme de blocs RAM), conciliant concurrence et déterminisme. Il sert à développer des abstractions de programmation telles que des squelettes algorithmiques et des implantations de machines virtuelles pour des langages de haut niveau. Cela répond, à différents niveaux, au besoin d’intégrer des algorithmes généralistes à l’intérieur des applications embarquées réactives à base de FPGA.
FPGAs (Field-Programmable Gate Arrays) are reconfigurable digital circuits: their behavior can be customized by logic synthesis of specification at the so-called register transfer level (RT level), in hardware description languages such as VHDL or Verilog. FPGAs are well suited to implement reactive systems, directly as synchronous circuits interacting with the external environment via I/O pins – the logic synthesizer ensuring that timing constraints are met, given the FPGA clock frequency. FPGAs are also used to implement hardware accelerators ; however, RT-level descriptions of transformational systems (or “computations”) – with latencies of several clock cycles – are difficult to debug, maintain and manually optimize. High-Level Synthesis (HLS) offers a simpler way of expressing computations, using a programming language compiled at the RT level. The advantage of this approach is to keep the implementation details hidden from the programmer, leaving the compiler responsible for scheduling computations over time. However, this leads to a loss of control over temporal behavior and therefore safety and efficiency for the circuits generated. As embedded systems, especially those based on FPGAs, need to perform more and more computations, while interacting with their environment, this thesis proposes a programming model to combine hardware description (data-flow oriented) and general-purpose parallel computation (control-flow oriented) using a synchronous approach. This programming model forms the basis for the design and implementation of Eclat, a functional-imperative, parallel and synchronous programming language, compiled to VHDL. Eclat is sufficiently precise to describe synchronous circuits at the RT level. It facilitates the programming of hardware accelerators, with a clear and predictable temporal semantics by which to exploit time-space trade-offs. Any Eclat program is reactive, with a mechanism for embedding computations within programs and thereby mix computation and interaction. Eclat also offers shared memory (in the form of RAM blocks), with deterministic concurrency. It is used to develop programming abstractions such as algorithmic skeletons and virtual machine implementations for high-level languages. This addresses, at various levels, the need to run general-purpose algorithms within FPGA-based reactive embedded applications.