Les mécanismes de détection et de recouvrement d'erreur doivent être soigneusement sélectionnés pour les applications embarquées automobiles, principalement à cause de ressources limitées et de contraintes économiques. Cependant, des exigences de sûreté importantes, aggravées par la complexité croissante du logiciel, motive l'industrie automobile à chercher des solutions techniques pour améliorer la robustesse à l'exécution. Le défi est de concevoir une solution de tolérance aux fautes portable, flexible, à forte contraintes économique, en examinant différemment les techniques classiques de redondance et de diversification. Le principe directeur est de contrôler rigoureusement quelle information et quand elle est essentielle à récupérer; quelle instrumentation est nécessaire pour réaliser de la tolérance aux fautes et où il faut la placer dans le programme. La thèse propose une approche pour développer un logiciel de défense, tel un composant externe configurable, reposant sur l'observabilité et la contrôlabilité de mécanismes fournis par un standard d'architecture logicielle automobile émergent AUTOSAR. / Due to limited resources and stringent economical constraints in the automotive industry, error detection and recovery mechanisms of embedded systems are carefully selected. However, critical safety requirements and increasing software complexity motivate car makers to look for technical solutions to improve online software robustness. The challenge is to design a portable, customizable, and lowcost solution for fault tolerance by using differently classical techniques, such as redundancy and diversification. The main principle is to control rigorously which information and when it is necessary to get it; which instrumentation is necessary to perform fault tolerance and where to add this instrumentation in the source code. An approach to develop a defense software is proposed. The defense software is designed as an external customizable component, relying on control and observability mechanisms provided by an emergent standard for automotive software architecture AUTOSAR.

Dans cette recherche, on a conçu et validé un nouveau noeud sans fil qui sera intégré dans un système automatique de contrôle des structures de génie civil. Le prototype est conçu à partir des dernières technologies dans le domaine des systèmes embarqués. Le prototype utilise la technologie développée pour les réseaux sans fil personnels WPAN (Wireless Personal Area Network) pour la transmission de données vers la centrale locale d'interrogation des données. Les capacités de calcul que le prototype possède nous permettent d'implémenter et d'exécuter plusieurs algorithmes de contrôle de l'état des structures. La transformée de Fourier rapide est utilisée comme algorithme illustratif dans le noeud sans fil. L'objectif de cette recherche est de mettre en place un réseau de capteurs sans fil qui supporte le calcul collaboratif en temps réel des dominées mesurées, pour l'identification des dommages potentiels dans la structure.

La complexité et l'hétérogènité des MPSoC sont accentuées par l'émergence de nouvelles applications multimédia. Pour ce genre d'architectures MPSoC, les environnements de programmation classiques ne sont pas adaptés. Cette thèse propose un flot de conception du logiciel pour MPSoC. Le flot commence par un modèle de haut niveau de l'application et de l'architecture en Simulink. La génération et la validation du logiciel sont effectuées graduellement en partant de ce premier modèle, correspondant à différents niveaux d'abstraction. Des plateformes spécifiques de développement sont employées pour permettre le débogage des différents composants logiciels. Le flot proposé a été appliqué pour la génération et validation du logiciel pour plusieurs architectures MPSoC, qui contiennent plusieurs processeurs interconnectés par un bus ou un réseau sur puce, et exécutent des applications, comme l'encodeur H.264, le décodeur M-JPEG et le décodeur MP3.

Concernant la partie logicielle des systèmes embarqués, on constate le besoin d'un modèle de la structuration du logiciel qui facilite le processus de développement, la capacité de faire évoluer le comportement du système lors de son exécution, afin de s'adapter aux changements de son environnement, et la prise en compte des limitations des ressources physiques des plates-formes d'exécution. L'utilisation de composants logiciels est une approche de conception qui, via l'abstraction des détails techniques, facilite la gestion de la complexité du logiciel. La question que nous nous posons est: comment les composants doivent être développés de façon à satisfaire les exigences liées aux fortes contraintes physiques et au besoin d'évolution du logiciel ? Pour y répondre, nous introduisons a notion de réification de composant. Une réification est une collection de données et de comportements qui encapsulent des aspects du composant à un moment précis de son cycle de vie. Nous proposons ensuite des techniques d'optimisation pour la génération du code "glue" qui assure l'interopérabilité des composants, afin de satisfaire les contraintes liées aux ressources limitées. Elles rendent possible la définition de niveaux d'optimisation pour chaque instance des entités du modèle à composants, ce qui nous permet de régler la performance du logiciel en fonction de ses besoins (extra) fonctionnels. Ensuite, nous définissons quatre profils d'évolution en fonction des caractéristiques d'évolution de chaque entité du modèle, et nous mettons en place des infrastructures d'évolution adaptées aux besoins d'évolution du système, couplées avec les exigences de performance du logiciel.

Dans cette étude, nous nous intéressons aux outils de génération de logiciel embarqué ciblant des plateformes multi-tuiles hétérogènes. Dans ces plateformes, un système sur puce multiprocesseurs hétérogène (ou tuile) est répliqué et connecté par des réseaux externes à la tuile, extensibles et commutés par paquets. Ces outils se basent sur une représentation abstraite de l'architecture, de l'application et du déploiement des éléments applicatifs sur les éléments de l'architecture. Programmer de zéro ces architectures complexes n'est pas concevable, cependant nous ne pouvons nous contenter des environnements de programmation embarqués classiques en raison de l'hétérogénéité de la tuile de base, qui embarque des RISCs, des DSPs et une infrastructure interne à la tuile non uniforme et complexe. L'un des enjeux dans ce contexte est de masquer cette complexité au programmeur de l'application pour qu'il puisse se concentrer sur l'écriture de son programme sans se soucier dans un premier temps de son déploiement sur la plateforme cible. L'une des difficultés des systèmes multi-tuiles est le nombre de chemins de communication que ceux-ci proposent, c'est pourquoi nous nous concentrons dans ce manuscrit sur la gestion (transparente pour le programmeur) des communications dans notre flot. Nous définissons donc les informations minimales à inclure dans le modèle d'entrée du flot pour arriver à synthétiser les communications de l'application. Grâce à ces informations, nous arrivons à puiser les composants logiciels de communication adéquats, qui se présentent sous la forme de pilotes d'un système d'exploitation. Cette sélection n'est pas suffisante, il faut ensuite spécialiser ces composants pour chaque canal de communication de l'application afin d'arriver à un résultat correct. En raison du nombre d'unités de calcul de la plateforme ciblée et du nombre de canaux des applications considérées, une automatisation totale du flot est requise, nous abordons donc les difficultés que cela représente en raison du processus de compilation croisé mis en jeu par le flot, et la solution que nous avons retenue pour arriver à un flot fonctionnel. Trois applications (dont une appartenant au monde du calcul de haute performance), écrites par des programmeurs ne maîtrisant pas la plateforme multi-tuiles choisie, ont été soumises à notre flot, qui a généré de manière correcte plusieurs déploiements de ces applications.

Les mécanismes de détection et de recouvrement d'erreur doivent être soigneusement sélectionnés pour les applications embarquées automobiles, principalement à cause de ressources limitées et de contraintes économiques. Cependant, des exigences de sûreté importantes, aggravées par la complexité croissante du logiciel, motive l'industrie automobile à chercher des solutions techniques pour améliorer la robustesse à l'exécution. Le défi est de concevoir une solution de tolérance aux fautes portable, flexible, à forte contraintes économique, en examinant différemment les techniques classiques de redondance et de diversification. Le principe directeur est de contrôler rigoureusement quelle information et quand elle est essentielle à récupérer; quelle instrumentation est nécessaire pour réaliser de la tolérance aux fautes et où il faut la placer dans le programme. La thèse propose une approche pour développer un logiciel de défense, tel un composant externe configurable, reposant sur l'observabilité et la contrôlabilité de mécanismes fournis par un standard d'architecture logicielle automobile émergent AUTOSAR.

L’un des objectifs de la microélectronique est de concevoir et fabriquer des SoCs de petites tailles, à moindre coût et visant des marchés tel que l’internet des objets. À matériel fixe sur lequel l’on ne dispose d’aucune marge de manœuvre, l’un des challenges pour un développeur de logiciels embarqués est d’écrire son programme de manière à ce qu’à l’exécution, le logiciel développé puisse utiliser au mieux les capacités de ces SoCs. Cependant, ces programmes n’utilisent pas toujours correctement les capacités de traitement disponibles sur le SoC. L’estimation et l’optimisation de la performance du logiciel devient donc une activité cruciale. A l’exécution, ces programmes sont très souvent victimes de l’apparition de cycles de gel de processeur dus à l’absence de données en mémoire cache. Il existe plusieurs approches permettant d’éviter ces cycles de gel de processeur. Par l’exemple l’utilisation des options de compilation adéquates pour la génération du meilleur code exécutable possible. Cependant les compilateurs n’ont qu’une idée abstraite (sous forme de formules analytiques) de l’architecture du matériel sur lequel le logiciel s’exécutera. Une alternative est l’utilisation des processeurs « Out–Of–Order ». Mais ces processeurs sont très couteux en terme de coût de fabrication car nécessites une surface de silicium importante pour l’implantation de ces mécanismes. Dans cette thèse, nous proposons une méthode itérative basée sur les plateformes virtuelles précises au niveau du cycle qui permet d’identifier les instructions du programme à optimiser responsables à l’exécution, de l’apparition des cycles de gel de processeur dus à l’absence de données dans le cache L1. L’objectif est de fournir au développeur des indices sur les emplacements du code source de son programme en langage de haut niveau (C/C++ typiquement) qui sont responsables de ces gels. Pour chacune de ces instructions, nous fournissons leur contribution au rallongement du temps d’exécution totale du programme. Finalement nous estimons le gain potentiel maximal qu’il est possible d’obtenir si tous les cycles de gel identifiés sont évités en insérant manuellement dans le code source du programme à optimiser, des instructions de pré–chargement de données dirigé par le logiciel. / One of microelectronics purposes is to design and manufacture small-sized, low-cost SoCs targeting markets such as the Internet of Things. With fixed hardware on which there is no possible flexibility, one of the challenges for an embedded software developer is to write his program so that, at runtime, the software developed can make the best use of these SoC capabilities. However, these programs do not always properly use the available SoC processing capabilities. Software performance estimation and optimization is then a crucial activity. At runtime, these programs are very often victims of processor data stall cycles. There are several approaches to avoiding these processor data stall cycles. For example, using the appropriate compilation options to generate the best executable code. However, the compilers have only an abstract knowledge (as analytical formulas) of the hardware architecture on which the software will be executed. Another way of solving this issue is to use Out-Of- Order processors. But these processors are very expensive in terms of manufacturing cost because they require a large silicon surface for the implementation of the Out-Of-Order mechanism. In this thesis, we propose an iterative methodology based on cycle accurate virtual platforms, which helps identifying precisely instructions of the program which are responsible of the generation of processor data stall cycles. The goal is to provide the developer with clues on the source code lignes of his program’s in high level language (C/C++ typically) which are responsible of these stalls. For each instructions, we provide their contribution to lengthening of the total program execution time. Finally, we estimate the maximum potential gain that can be achieved if all identified stall cycles are avoided by manually inserting software preloading instructions into the source code of the program to optimize.