Integrating devices in FPGA using an end-to-end hardware/software co-designedmessage-based approach

Le rythme de développement du matériel informatique augmente en vitesse et en complexité.C'est par exemple le cas des systèmes multiprocesseurs sur puce, systèmes optimisés pour une application spécifique ou des classes d'applications.Même si ces systèmes sont réutilisables, ils doivent intégrer des composants spécifiques (IPs) pour avoir être efficaces en énergie et en prix.Ces systèmes évoluent rapidement, un grand nombre de versions de plates-formes sont conçues par an, intégrant elles-mêmes un grand nombre d'IPs.La conception de matériel efficace restant un défi, le grand nombre d'IPs à intégrer dans un grand nombre de plates-formes différentes exacerbe la difficulté d'intégrer du matériel et du logiciel.Ce processus d'intégration concerne jusqu'à une centaine d'IP, chacune ayant des dizaines à des centaines de registres, chacun étant un champ de bits potentiel à prendre en compte par les pilotes logiciels.Faire fonctionner un système matériel/logiciel dans ces conditions représente une énorme quantité de travail et de débogage, ce qui fait que la grande majorité des bogues provient des pilotes.Le problème est encore pire dans le contexte des FPGA, car la reconfigurabilité fait que le nombre de versions d'IP est énorme.L'adoption des FPGA se développe avec l'amélioration des outils, mais pour contribuer à la faire progresser dans tous les domaines, des systèmes embarqués à l'informatique en nuage, le processus d'intégration doit être grandement amélioré.Cette thèse aborde ce problème spécifique en proposant une approche simple et efficace, qui ne nécessite pas de technologie nouvelle ou coûteuse, et peut être adoptée progressivement sans avoir à rejeter les solutions existantes.Les principes de base de notre solution s'inspirent de l'USB : 1) un conduit de messages cachant la frontière matériel/logiciel basée sur les registres et les interruptions, 2) la définition de classes de périphériques permettant d'avoir un pilote capable de piloter plusieurs périphériques en suivant un protocole de messages génériques.La proposition définit un conduit ouvert et abstrait pour l'envoi et la réception de messages à travers la frontière matériel/logiciel.Ce conduit de messages est conçu conjointement en utilisant des concepts que chacun connaît bien.Côté matériel, il fournit aux IPs une interface simple basée sur des interfaces de type flux transportant les messages.Il leur fournit également un protocole de message générique permettant un cycle de vie simple.Côté logiciel, il fournit une API basée sur les messages, facile à comprendre pour les développeurs.Cette API dissimule des détails matériels tels que les interruptions ou les registres derrière des canaux de communication dans lesquels les messages sont échangés.Nous avons conçu notre solution pour les petits systèmes embarqués par la mise en place d'un conduit de messages entre le matériel et le logiciel.Ce prototype montre que notre solution convient aux petits systèmes avec des IPs à faible latence et à faible débit, sans que la taille des implantations matérielles et logicielles n'augmente beaucoup.Nous avons ensuite intégré la solution dans le noyau Linux, démontrant ainsi sa faisabilité pour les systèmes plus importants.Les expérimentations montrent que notre solution peut s'adapter à des IPs haute performance à des coûts négligeables.Elles montrent également qu'elle s'intégre dans le noyau à côté des solutions existantes.Dans le contexte de l'informatique en nuage, notre solution offre de grands avantages pour aider à améliorer la prise en charge matérielle des systèmes d'exploitation invités.Nous montrons que l'utilisation de messages est une bonne solution pour prendre en charge et partager largement des IPs.Elle s'intègre également bien dans les hyperviseurs, en particulier Xen qui possède toutes les fonctionnalités dont nos solutions ont besoin et suit des concepts compatibles pour simplifier les pilotes dans les systèmes d'exploitation invités.Hardware development pace is increasing both in speed and complexity.This is for instance the case for Multiprocessor System-on-a-chip, a class of systems optimized towards specific application or specific classes of applications.Even though these systems tend to be reusable, they need to embed specific hardware Intellectual Properties (IPs) to achieve the right power and price budgets.Those systems evolving very quickly, a large number of platform versions are released over short periods of time, embedding themselves a large number of IPs.Efficient hardware design being still a real challenge, the huge number of IPs to integrate in a large number of different platforms exacerbates the already difficult hardware/software integration challenge.This integration process deals with a dozen to a hundred of IPs, each one having dozens to hundreds of hardware registers, each of them being a potential bitfield with many functions to take into account by software drivers.Having a hardware/software system working in those conditions is a huge amount of work and debug, making no surprise that the vast majority of bugs comes from drivers.The problem is even worse in the context of FPGAs.Their reconfigurability makes the number of systems and IP versions growing even faster.The FPGA adoption is growing well with the improvement of tools and process automation but to help pushing it further in all domains, from embedded systems to cloud computing, the integration process needs a major leap in efficiency.This thesis addresses that specific problem by proposing a simple and effective approach.The approach does not require expensive or new technologies, it can be adopted incrementally without having to throw existing solutions out.It only requires to follow an end-to-end design that can be followed using existing tools and technologies.The core principles of our solution is inspired from the successful story of USB: 1) A message conduit hiding the register and interrupt based hardware/software frontier, 2) Defining device classes allowing to have one driver able to drive multiple devices by following a generic message protocol.The proposal defines an open and abstract conduit for sending and receiving messages across the hardware/software frontier.This message conduit is co-designed across both sides of the frontier using existing concepts that each one is familiar with.Hardware side, it provides to devices a simple interface based on streaming interfaces in which messages are traveling.It also provides to devices a generic message protocol giving them a simple and yet very useful lifecycle to follow.Software side, it provides a simple message-based API, easy to understand for software developers.This API hides hardware details such as interrupts or hardware registers behind communication channels in which messages are exchanged with devices.This first designed our solution for small embedded systems, addressing the integration challenge by implementing a message conduit across the hardware and the software.The prototype we built demonstrates that our solution fits for small systems with low latency and low throughput devices without growing much the size of both hardware and software implementations.We then integrated the solution in the Linux kernel, demonstrating the feasibility of our solution for bigger systems.Our experiments show that our solution can fit for high-performance devices with negligible overheads.It also shows that it can be well integrated within the kernel beside existing integration solutions.In the context of cloud computing, our solution offers great benefits to help improving hardware support for guest operating systems.We shown that using messages is a good solutions to support and share devices amount.It also fits well in hypervisors, in particular Xen which has all the features our solutions requires and follow compatible concepts to simplify drivers in guest operating systems