Search

Since the 60's the architectural model used by processors is the 'Von Neumann' model in which a processor fetches instructions and data to process in the same memory. The increase of the transistor density on a chip has allowed to increase its operating frequency but has produced a 'bottleneck' towards the memory which cannot provide instructions and data at the same frequency: the memory wall.Many architectural solutions have been proposed to solve this bottleneck. One of the solutions we are studying is an architecture in which computations are performed in memory, without moving data to the processor. Evaluation of this solution has shown impressive potential gains in speed and energy.To exploit this potential, a change in programming model is required, as instructions will no longer be read from memory but generated by a processor that will drive one or more memory planes.The contributions of the thesis are the specification of a transfer mechanism for complex memory access patterns to near-memory computing architectures.The thesis also presents a high-level programming model allowing the programming of a near-memory computing architecture, as well as the above-mentioned transfer mechanism.This programming model can be parameterized to compile specialized applications through static compilation, or dynamic code generation to perform run-time optimizations.The evaluation of these contributions through a simulation model shows results that demonstrate the interest of dynamic code specialization for heterogeneous architectures.; Depuis les années 60 le modèle architectural utilisé par les processeurs est le modèle ’von Neumann’ dans lequel un processeur va chercher instructions et données à traiter dans la même mémoire. L’augmentation de la densité de transistor sur une puce a permis d’augmenter sa fréquence de fonctionnement, mais a produit un ’goulot d’étranglement’ vers la mémoire qui ne peut pas fournir instructions et données à la même fréquence : le mur de la mémoire. Beaucoup de solutions architecturales ont été proposées pour résoudre ce goulot d’étranglement. Une des solutions que nous étudions est une architecture dans laquelle les calculs sont réalisés dans la mémoire, sans déplacer les données vers le processeur. L’évaluation de cette solution a montré des gains potentiels impressionnants en vitesse et en énergie. Pour exploiter ce potentiel, il faut changer de modèle de programmation, car les instructions ne seront plus lues en mémoire, mais générées par un processeur qui pilotera un ou plusieurs plans mémoire. Les contributions de la thèse sont la spécification d’un mécanisme de transfert pour les motifs d’accès mémoire complexes à destination des architectures de calcul proche-mémoire. La thèse présente également un modèle de programmation haut-niveau permettant la programmation d’une architecture de calcul proche-mémoire, ainsi que du mécanisme de transfert susmentionné. Ce modèle de programmation peut être paramétré pour compiler des applications spécialisées grâce à la compilation statique, ou la génération dynamique de code pour effectuer des optimisations lors du run-time. L’évaluation de ces contributions par le biais d’un modèle de simulation montre des résultats qui témoignent de l’intérêt de la spécialisation dynamique de code pour les architectures de calcul proche-mémoire, et par extension des nœuds de calcul hétérogènes.

The security of embedded systems containing sensitive data has become a main concern. These widely deployed devices are subject to physcial attacks, requiring protections both in hardware and software. The race for higher productivity and shorter time to market in the deployment of secure systems pushes for automatic solutions. This thesis studies the integration of software countermeasures against fault attacks in development tools, with a special focus on the compiler. The goal is to enable the automatic application, at compilation time, of a wide range of countermeasures. We propose two protection schemes against these attacks which can be automatically deployed: one scheme dedicated to loop control flow and the second dedicated to the protection of the call graph. These schemes, integrated in the LLVM compiler framework, allow to focus security application on sensitive areas of the targeted code, thus limitating the overhead. Faults that can be exploited are different from a device to another, we thus also provide an ISA-level characterization of fault effects on a superscalar processor representative of mobile phones. This work highlights the need of studying fault effects on more complex platforms, leading to the design of new protection schemes and automating their compilation-time application., La sécurité des systèmes embarqués contenant des données sensibles est un enjeu crucial. La disponibilité de ces objets en fait une cible privilégiée pour les attaques physiques, nécessitant l'ajout de protections matérielles et logicielles. La recherche de réduction des coûts de développement pousse les industriels à opter pour du déploiement automatique de protections. L'objet de la thèse consiste à étudier l'intégration de contre-mesures logicielles contre les attaques par faute dans les outils de développement, en particulier dans le compilateur, afin d'automatiser l'application de contre-mesures variées. Pour cela, nous proposons deux schémas de protection génériques et automatiquement déployables contre ces attaques : un dédié à la sécurisation des boucles et le deuxième à la sécurisation du graphe d'appel. Ces schémas spécifiques, intégrés dans un même compilateur (LLVM) permettent la sécurisation de parties sensibles et choisies du code limitant ainsi leur surcoût en performances. Les fautes exploitables variant d'un composant à l'autre, nous proposons également une caractérisation des effets des fautes au niveau du jeu d'instructions sur une plateforme intégrant un processeur superscalaire typique des téléphones mobiles. Ces travaux montrent la nécessité d'étudier les injections de faute sur des plateformes complexes, de concevoir de nouveaux schémas de protection adaptés, et de continuer à intégrer dans un même compilateur plus de schémas de sécurisation.

Many mobile devices now integrate optic sensors; smartphones, tablets, drones... are foreshadowing an impending Internet of Things (IoT). New image processing applications (filters, compression, augmented reality) are taking advantage of these sensors under strong constraints of speed and energy efficiency. Modern architectures, such as manycore processors or GPUs, offer good performance, but are hard to program.This thesis aims at checking the adequacy between the image processing domain and these modern architectures: conciliating programmability, portability and performance is still a challenge today. Typical image processing applications feature strong, inherent parallelism, which can potentially be exploited by the various levels of hardware parallelism inside current architectures. We focus here on image processing based on mathematical morphology, and validate our approach using the manycore architecture of the Kalray MPPA processor.We first prove that integrated compilation chains, composed of compilers, libraries and run-time systems, allow to take advantage of various hardware accelerators from high-level languages. We especially focus on manycore processors, through various programming models: OpenMP, data-flow language, OpenCL, and message passing. Three out of four compilation chains have been developed, and are available to applications written in domain-specific languages (DSL) embedded in C or Python. They greatly improve the portability of applications, which can now be executed on a large panel of target architectures.Then, these compilation chains have allowed us to perform comparative experiments on a set of seven image processing applications. We show that the MPPA processor is on average more energy-efficient than competing hardware accelerators, especially with the data-flow programming model. We show that compiling a DSL embedded in Python to a DSL embedded in C increases both the portability and the performance of Python-written applications.Thus, our compilation chains form a complete software environment dedicated to image processing application development. This environment is able to efficiently target several hardware architectures, among them the MPPA processor, and offers interfaces in high-level languages.; Nous assistons à une explosion du nombre d’appareils mobiles équipés de capteurs optiques : smartphones, tablettes, drones... préfigurent un Internet des objets imminent. De nouvelles applications de traitement d’images (filtres, compression, réalité augmentée) exploitent ces capteurs mais doivent répondre à des contraintes fortes de vitesse et d’efficacité énergétique. Les architectures modernes — processeurs manycore, GPUs,... — offrent un potentiel de performance, avec cependant une hausse sensible de la complexité de programmation.L’ambition de cette thèse est de vérifier l’adéquation entre le domaine du traitement d’images et ces architectures modernes : concilier programmabilité, portabilité et performance reste encore aujourd’hui un défi. Le domaine du traitement d’images présente un fort parallélisme intrinsèque, qui peut potentiellement être exploité par les différents niveaux de parallélisme offerts par les architectures actuelles. Nous nous focalisons ici sur le domaine du traitement d’images par morphologie mathématique, et validons notre approche avec l’architecture manycore du processeur MPPA de la société Kalray.Nous prouvons d’abord la faisabilité de chaînes de compilation intégrées, composées de compilateurs, bibliothèques et d’environnements d’exécution, qui à partir de langages de haut niveau tirent parti de différents accélérateurs matériels. Nous nous concentrons plus particulièrement sur les processeurs manycore, suivant les différents modèles de programmation : OpenMP ; langage flot de données ; OpenCL ; passage de messages. Trois chaînes de compilation sur quatre ont été réalisées, et sont accessibles à des applications écrites dans des langages spécifiques au domaine du traitement d’images intégrés à Python ou C. Elles améliorent grandement la portabilité de ces applications, désormais exécutables sur un plus large panel d’architectures cibles.Ces chaînes de compilation nous ont ensuite permis de réaliser des expériences comparatives sur un jeu de sept applications de traitement d’images. Nous montrons que le processeur MPPA est en moyenne plus efficace énergétiquement qu’un ensemble d’accélérateurs matériels concurrents, et ceci particulièrement avec le modèle de programmation flot de données. Nous montrons que la compilation d’un langage spécifique intégré à Python vers un langage spécifique intégré à C permet d’augmenter la portabilité et d’améliorer les performances des applications écrites en Python.Nos chaînes de compilation forment enfin un environnement logiciel complet dédié au développement d’applications de traitement d’images par morphologie mathématique, capable de cibler efficacement différentes architectures matérielles, dont le processeur MPPA, et proposant des interfaces dans des langages de haut niveau.

Compilers usually offer a good trade-off between productivity and single thread performance thanks to a wide range of available automatic optimizations. However, they are still fragile when addressing computation intensive parts of applications in the context of parallel architectures with deep memory hierarchies that are now omnipresent. The recent shift to multicore architectures for desktop and embedded systems as well as the emergence of cloud computing is raising the problem of the impact of the execution context on performance. Firstly, we present a static-dynamic compiler optimization technique that generates loop-based programs with dynamic auto-tuning capabilities with very low overhead. Our strategy introduces switchable scheduling, a family of program transformations that allows to switch between optimized versions while always processing useful computation. We present both the technique to generate self-adaptive programs based on switchable scheduling and experimental evidence of their ability to sustain high-performance in a dynamic environment.Secondly, we propose a novel approach which aims at opening the polyhedral compilation engines that are powering loop-level optimization and parallelization frameworks of several modern compilers.Building on the state-of-the-art polyhedral representation of programs, we present ways to translate comprehensible syntactic transformation sequences to and from the internal polyhedral compiler abstractions. This new way to interact with high-level optimization frameworks provides an invaluable feedback to programmers with the ability to design, replay or refine loop-level compiler optimizations.; Les compilateurs offrent un excellent compromis entre le temps de développement et les performances de l'application. Actuellement l'efficacité de leurs optimisations reste limitée lorsque les architectures cibles sont des multi-cœurs ou si les applications demandent des calculs intensifs. Il est difficile de prendre en compte les nombreuses configurations existantes et les nombreux paramètres inconnus à la compilation et donc disponibles uniquement pendant l'exécution. En se basant sur les techniques de compilation polyédrique, nous proposons deux solutions complémentaires pour contribuer au traitement de ces problèmes. Dans une première partie, nous présentons une technique automatique à la fois statique et dynamique permettant d'optimiser les boucles des programmes en utilisant les possibilités offertes par l'auto-tuning dynamique. Cette solution entièrement automatique explore de nombreuses versions et sélectionne les plus pertinentes à la compilation. Le choix de la version à exécuter se fait dynamiquement avec un faible surcoût grâce à la génération de versions interchangeables: un ensemble de transformations autorisant le passage d'une version à une autre du programme tout en faisant du calcul utile. Dans une seconde partie, nous offrons à l'utilisateur une nouvelle façon d'interagir avec le compilateur polyédrique. Afin de comprendre et de modifier les transformations faites par l'optimiseur, nous traduisons depuis la représentation polyédrique utilisée en interne n'importe quelle transformation de boucles impactant l’ordonnancement des itérations en une séquence de transformations syntaxiques équivalente. Celle-ci est compréhensible et modifiable par les programmeurs. En offrant la possibilité au développeur d'examiner, modifier, améliorer, rejouer et de construire des optimisations complexes avec ces outils de compilation semi-automatiques, nous ouvrons une boîte noire du compilateur: celle de la plateforme de compilation polyédrique.

There is a long standing separation between the fields of compiler construction and real-time scheduling. While both fields have the same objective - the construction of correct implementations – the separation was historically justified by significant differences in the models and methods that were used. Nevertheless, with the ongoing complexification of applications and of the hardware of the execution platforms, the objects and problems studied in these two fields are now largely overlapping. In this thesis, we focus on the automatic code generation for embedded control systems with complex constraints, including hard real-time requirements. To this purpose, we advocate the need for a reconciled research effort between the communities of compilation and real-time systems. By adapting a technique usually used in compilers (software pipelining) to the system-level problem of multiprocessor scheduling of hard real-time applications, we shed light on the difficulties of this unified research effort, but also show how it can lead to real advances. Indeed we explain how adapting techniques for the optimization of new objectives, in a different context, allows us to develop more easily systems of better quality than what was done until now. In this adaptation process, we propose to use synchronous formalisms and languages as a common formal ground. These can be naturally seen as extensions of classical models coming from both real-time scheduling (dependent task graphs) and compilation (single static assignment and data dependency graphs), but also provide powerful techniques for manipulating complex control structures. We implemented our results in the LoPhT compiler.; Une séparation existe de longue date entre les domaines de la compilation et de l'ordonnancement temps-réel. Si ces deux domaines ont le même objectif - la construction d'implantations correctes - la séparation se justifie historiquement par des différences significatives entre les modèles et les méthodes utilisés. Cependant, avec la complexification des applications et du materiel qui les exécute, les problèmes étudiés dans ces deux domaines se confondent désormais largement. Dans cette thèse, nous nous concentrons sur la génération automatique de code pour des systèmes de contrôle embarqué incluant des contraintes complexes (notamment temps-réel). A ces fins, nous défendons l'idée qu'il est profitable de fournir un effort commun de recherche entre ces deux communautés. En adaptant une technique de compilation au problème d'ordonnancement temps réel d'applications sur des architectures multiprocessurs, nous montrons à la fois les difficultés inhérentes à cet effort commun, mais aussi les possibles avancées qu'il porte. En effet, nous montrons que l'adaptation de techniques d'optimisation à de nouveaux objectifs, dans un contexte différent facilite le développement de systèmes de meilleure qualité. Nous proposons d'utiliser les formalismes et langages synchrones comme base formelle commune dans ce travail d'adaptation. Ceux-cis étendent naturellement les modèles classiques utilisés pour l'ordonnancement temps réel (graphes de tâches dépendentes) et la compilation (SSA et graphes de dépendence de données), et fournissent également des techniques efficaces pour la manipulation de structures de contrôle complexes. Nous avons implanté nos résultats dans le compilateur LoPhT.

Graphic cards (GPUs), initially used for graphic processing, have a highly parallel architecture. Innovations in both architecture and programming languages opened the new domain of GPGPU where GPUs are used as accelerators for general purpose HPC applications. Our main objective is to facilitate the use of these new architectures for high-performance computing needs; our research follows two main directions. The first direction concerns an automatic code transformation from a high level code into an equivalent low level one, capable of running on accelerators. To this end we implemented a code transformer that can handle parallel ''for'' loops (single or nested) of an OpenMP code and convert it into an equivalent CUDA code, which is in a human readable form that allows for further optimizations. Moreover, the future of HPC lies in distributed architectures based on hybrid nodes. Specific programming schemes have to be used in order to allow users to benefit from such multiGPU nodes. We conducted a comparative study which revealed that using OpenMP threads is the most adequate way to control multiple graphic cards as well as manage communications efficiently within a multiGPU node.; Les processeurs graphiques (GPU), originellement dédiés à l'accélération de traitements graphiques, ont une structure hautement parallèle. Les innovations matérielles et de langage de programmation ont permis d'ouvrir le domaine du GPGPU, où les cartes graphiques sont utilisées comme des accélérateurs de calcul pour des applications HPC généralistes. L'objectif de nos travaux est de faciliter l'utilisation de ces nouvelles architectures pour les besoins du calcul haute performance ; ils suivent deux objectifs complémentaires. Le premier axe de nos recherches concerne la transformation automatique de code, permettant de partir d'un code de haut niveau pour le transformer en un code de bas niveau, équivalent, pouvant être exécuté sur des accélérateurs. Dans ce but nous avons implémenté un transformateur de code capable de prendre en charge les boucles " pour " parallèles d'un code OpenMP (simples ou imbriquées) et de le transformer en un code CUDA équivalent, qui soit suffisamment lisible pour permettre de le retravailler par des optimisations ultérieures. Par ailleurs, le futur des architectures HPC réside dans les architectures distribuées basées sur des noeuds dotés d'accélérateurs. Pour permettre aux utilisateurs d'exploiter les noeuds multiGPU, il est nécessaire de mettre en place des schémas d'exécution appropriés. Nous avons mené une étude comparative et mis en évidence que les threads OpenMP permettent de gérer de manière efficace plusieurs cartes graphiques et les communications au sein d'un noeud de calcul multiGPU.

Graphic cards (GPUs), initially used for graphic processing, have a highly parallel architecture. Innovations in both architecture and programming languages opened the new domain of GPGPU where GPUs are used as accelerators for general purpose HPC applications. Our main objective is to facilitate the use of these new architectures for high-performance computing needs; our research follows two main directions. The first direction concerns an automatic code transformation from a high level code into an equivalent low level one, capable of running on accelerators. To this end we implemented a code transformer that can handle parallel ''for'' loops (single or nested) of an OpenMP code and convert it into an equivalent CUDA code, which is in a human readable form that allows for further optimizations. Moreover, the future of HPC lies in distributed architectures based on hybrid nodes. Specific programming schemes have to be used in order to allow users to benefit from such multiGPU nodes. We conducted a comparative study which revealed that using OpenMP threads is the most adequate way to control multiple graphic cards as well as manage communications efficiently within a multiGPU node., Les processeurs graphiques (GPU), originellement dédiés à l'accélération de traitements graphiques, ont une structure hautement parallèle. Les innovations matérielles et de langage de programmation ont permis d'ouvrir le domaine du GPGPU, où les cartes graphiques sont utilisées comme des accélérateurs de calcul pour des applications HPC généralistes. L'objectif de nos travaux est de faciliter l'utilisation de ces nouvelles architectures pour les besoins du calcul haute performance ; ils suivent deux objectifs complémentaires. Le premier axe de nos recherches concerne la transformation automatique de code, permettant de partir d'un code de haut niveau pour le transformer en un code de bas niveau, équivalent, pouvant être exécuté sur des accélérateurs. Dans ce but nous avons implémenté un transformateur de code capable de prendre en charge les boucles " pour " parallèles d'un code OpenMP (simples ou imbriquées) et de le transformer en un code CUDA équivalent, qui soit suffisamment lisible pour permettre de le retravailler par des optimisations ultérieures. Par ailleurs, le futur des architectures HPC réside dans les architectures distribuées basées sur des noeuds dotés d'accélérateurs. Pour permettre aux utilisateurs d'exploiter les noeuds multiGPU, il est nécessaire de mettre en place des schémas d'exécution appropriés. Nous avons mené une étude comparative et mis en évidence que les threads OpenMP permettent de gérer de manière efficace plusieurs cartes graphiques et les communications au sein d'un noeud de calcul multiGPU.

In light of the increase of development cost, power consumption and silicon area for new single-core architecture optimisations, the new way for performance improvements leads to multicore architectures, with parallel programming and specialised coprocessors. They give the best trade-off between high computing performance and required resources. In order to efficiently address this new kind of architecture, applications have to be split into tasks, also called codelets, which will be mapped onto the different computing units of the host system. Code partitioning is complex and the solution space to explore is wide. It becomes necessary to develop automatic and efficient tools to generate codelets from sequential application. The purpose of this thesis is to propose such a code-partitioning process. The Astex approach is based on speculation ; the codelet detection and construction phases use speculative data from execution profiles of the application. Speculation allows the compiler to handle a number of optimisations which would have been impossible or unavailable without speculative data. The way to collect the speculative data, how to handle them during the execution, and how to use them are new challenges for the compiler framework. My second contribution deals with the data transfer optimisation between the processor and the coprocessor by using speculation. The case study focuses on GPGPU, i.e. the usage of graphics processor for general-purpose computing.; Devant les difficultés croissantes liées au coût en développement, en consommation, en surface de silicium, nécessaires aux nouvelles optimisations des architectures monocœur, on assiste au retour en force du parallélisme et des coprocesseurs spécialisés dans les architectures. Cette technique apporte le meilleur compromis entre puissance de calcul élevée et utilisations des ressources. Afin d'exploiter efficacement toutes ces architectures, il faut partitionner le code en tâches, appelées codelet, avant de les distribuer aux différentes unités de calcul. Ce partionnement est complexe et l'espace des solutions est vaste. Il est donc nécessaire de développer des outils d'automatisation efficaces pour le partitionnement du code séquentiel. Les travaux présentés dans cette thèse portent sur l'élaboration d'un tel processus de partitionnement. L'approche d'Astex est basée sur la spéculation, en effet les codelets sont construits à partir des profils d'exécution de l'application. La spéculation permet un grand nombre d'optimisations inexistantes ou impossibles statiquement. L'élaboration, la gestion dynamique et l'usage que l'on peut faire de la spéculation sont un vaste sujet d'étude. La deuxième contribution de cette thèse porte sur l'usage de la spéculation dans l'optimisation des communications entre processeur et coprocesseur et traite en particulier du cas du GPGPU, i.e. l'utilisation d'un processeur graphique comme coprocesseur de calcul intensif.

Internet servers are software with specific features. Indeed, they answer request of wide and distant clients, support the customer evolution and be robust because they never stop. The concurrency models allow to interleave the statements of wide customers. No general agreement frees on a better model. To abstract himself from the concurrency model, I propose a development model of Internet servers. Model checkers allow to increase the software safety. But, it is necessary to provide a simple model of software to check it. I propose to use my development model of servers in order to genrate ther server automatically and its formal model. Finally as the request parsing depends on the concurrency model, I propose to use Tatoo, a parser generator. Tatoo abstracts himself from this dependency and automates the development of parsing; Les serveurs Internet sont des logiciels particuliers. Ils doivent répondre aux demandes d'un grand nombre de clients distants, supporter leur évolution et être robustes car ils ne s'arrêtent jamais. Les modèles de concurrence permettent d'entrelacer les traitements d'un grand nombre de clients. Aucun consensus ne se dégage sur un meilleur modèle. Pour s'abstraire du modèle de concurrence, je propose un modèle de développement de serveurs Internet. Les outils de vérification formelle permettent d'accroître la sûreté des logiciels mais il est nécessaire de leur fournir un modèle simple du logiciel. Le modèle de développement que je propose est utilisé pour générer le serveur et son modèle formel. Le décodage d'une requête cliente dépend du modèle de concurrence. Je propose d'utiliser un générateur d'analyseur syntaxique qui s'abstrait de ce problème et automatise le développement du décodage

The increasing complexity of processors has led to the development of a large number of code transformations to adapt computations to the hardware architecture. The major difficulty faced by a compiler is to determine the sequence of transformations that will provide the best performance. This sequence depends on the application and the processor considered. The deep interaction between the various code transformations does not allow to find a static solution.We propose an iterative approach to compilation to solve this problem: each optimization module can revisit the decisions made by another module. These modules can communicate information about the properties of the code they have produced. This approach requires a complete redesign of the structure of current compilers.The realization was only made possible thanks to the software infrastructures that we developed: Salto and SEA. Thanks to these environments, we were able to quickly develop prototypes of compilation strategies.We also show that analysis and optimization should not be limited to the local behavior of a code fragment. On the contrary, the global behavior of the application must be considered, especially for embedded systems.; La complexité croissante des processeurs a conduit au développement d'un grand nombre de transformations de code pour adapter l'organisation des calculs à l'architecture matérielle. La difficulté majeure à laquelle est confronté un compilateur consiste à déterminer la séquence de transformations qui va fournir la meilleure performance. Cette séquence dépend de l'application et du processeur considérés. L'interaction profonde entre les diverses transformations de code ne permet pas de trouver une solution statique.Nous proposons une approche itérative de la compilation pour résoudre ce problème : chaque module d'optimisation peut remettre en cause les décisions prises par un autre module. Ces modules peuvent se communiquer des informations sur les propriétés du code qu'ils ont produit. Cette approche nécessite une refonte complète de la structure des compilateurs actuels.La réalisation n'a été rendue possible que grâce aux infrastructures logicielles que nous avons développées : Salto et SEA. Grâce à ces environnements nous avons pu développer rapidement des prototypes de stratégies de compilation.Nous montrons aussi que l'analyse et l'optimisation ne doivent pas se contenter d'un comportement local à un fragment de code. Au contraire, le comportement global de l'application doit être considéré, en particulier pour les systèmes enfouis.

Article dans une revue de vulgarisation.; Faisant suite à celui publié dans le numéro 2 de Programmez!, cet article détaille certains aspects du langage Eiffel de son compilateur GNU Eiffel, nommé SmallEiffel. Le puissant mécanisme d'assertions et leur utilisation dans le cadre de la programmation par contrat sont considérés, ainsi que les capacités que possède SmallEiffel dans ce domaine.

Cette thèse présente les mécanismes mis en œuvre pour compiler efficacement un langage fonctionnel non strict en un code combinatoire directement exécutable sur mars, un réducteur parallèle de graphes à mémoire partagée réalisé à l'ONERA-CERT. Nous décrivons d'abord brièvement les principes de fonctionnement de MaRS (langage fonctionnel, réduction parallèle de graphe, jeu de combinateurs indexes, architecture générale), ainsi que le point de départ de notre travail, un algorithme itératif permettant l'abstraction de toutes les variables en une seule passe. Nous montrons ensuite comment quelques modifications judicieusement apportées à cet algorithme d'abstraction améliorent de façon notable et même fondamentale la qualité du code généré. On diminue ainsi l'expansion dynamique et la taille du code; de plus, une gestion appropriée des différents modes d'évaluation permet une exploitation pertinente du parallélisme potentiel du programme, ainsi qu'une utilisation optimale des différentes ressources de la machine. Les mesures effectuées sur un simulateur de la machine mettent bien en évidence l'apport des optimisations proposées, et ce, que ce soit en évaluation séquentielle ou en évaluation parallèle. Enfin, nous bâtissons un environnement logiciel permettant de gérer de façon incrémentielle les diverses dépendances existant entre les codes des différentes fonctions d'un programme. Les principes élaborés pour résoudre ce problème assez spécifique s'avèrent d'un intérêt beaucoup plus général. This thesis shows how to compile efficiently a non strict functional language into combinatory code to be reduced by MaRS, a memory-shared graph reduction multiprocessor designed at ONERA-CERT. We first describe the main characteristics of MaRS (functional language, parallel graph reduction, infinite - but finitely generated - set of combinators, overall architecture) and the one-sweep abstraction algorithm which forms the basis of our work. We then introduce some modifications that greatly improve the quality of the generated code. Shorter object code and smaller dynamic expansion are obtained, and an appropriate use of sequential and parallel call-by-value strategies allows useful parallelism and optimal use of the machine to be achieved. A large number of experiments were performed that show the effectiveness of these optimizations. We finally present principles of a software system that efficiently keeps coherence between interdependant properties. This saves many recompilations while modifying a program incrementally. In fact, such a tool can be used in a more widespread context.

Universités : Université scientifique et médicale de Grenoble et Institut national polytechnique de Grenoble; Cette thèse présente des contributions dans les domaines de l'architecture des ordinateurs réalisés sous la forme d'un Circuit Intégré. Un assembleur de silicium, appelé LUBRICK, permet de décrire, dans un langage de programmation, la constitution d'un assemblage hiérarchisé de cellules pour réaliser la description complète des masques d'un Circuit Intégré. La compilation du silicium, discipline qui consiste à déduire les masques d'un circuit en partant d'une description fonctionnelle, est ici abordée sous un angle pratique, avec la présentation d'un compilateur prototype d'une forme de partie contrôle et des présentations de modèles topologiques de parties opératives et de parties contrôle qui servent de cible au compilateur

La phase de dessin des circuits intégrés est aujourd'hui le goulot d'étranglement entre la demande et la production. On présente le générateur automatique d'architectures pour circuits intégrés de filtrage numérique. La description d'un algorithme de filtrage assortie d'une contrainte «temps réel» est fournie au générateur. L'architecture optimisée en un temps requis est fournie sous la forme d'une partie opérative et d'un graphe d'états donnant le séquencement à appliquer

Le compilateur de parties opératives Apollon qui est présenté dans cette thèse, génère automatiquement le dessin des masques de parties opératives de circuits VLSI de type microprocesseur à partir d'une description comportementale de niveau transfert de registres constituée d'un ensemble non ordonné d'instructions opératives. Une instruction opérative est formée d'un ensemble d'actions opératives dont le format est prédéfini (transferts - opérations unaires ou binaires et entrées-sorties) devant se dérouler en parallèle en au plus deux cycles opératifs. Un cycle opératif comprend 4 phases qui correspondent aux 4 phases d'exécution d'un transfert entre 2 registres. Apollon est basé sur un modèle dérivé de la partie opérative du MC68000. Ce modèle fournit à la fois: un modèle architectural: la partie opérative est formée d'un ensemble de sous parties opératives alignées à deux bus qui traversent tous les éléments d'une sous partie opérative; un modèle temporel: une opération prend 2 cycles, un transfert un seul; un modèle électrique: les bus sont complémentés et à précharge; un modèle topologique: le plan de masse est basé sur la structure en tranches appelée communément bis slice. Le compilateur génère d'abord l'architecture de la partie opérative, puis les spécification des masques à partir de cette architecture. Pour générer l'architecture de la partie opérative en un temps raisonnable, le compilateur doit recourir à des heuristiques. Pour générer le dessin des masques, le compilateur utilise l'assembleur de silicium Lubrick qui permet d'assembler et de connecter automatiquement les cellules de base des éléments fonctionnels de la partie opérative. Les spécifications des masques sont générées à partir des spécifications des cellules prédéfinies d'une bibliothèque NMOS.

Le travail présenté dans cette thèse porte sur le domaine de l'aide à la construction du plan de masse de circuits VLSI. Cette construction est basée sur une évaluation topologique prédictive et une approche hiérarchisée. FLOPE est un éditeur interactif permettant la construction d'un plan masse de manière structurée. Il est essentiellement destiné à communiquer avec des évaluateurs existants ou à venir. Son rôle dans la conception hiérarchique est notamment: d'anticiper les problèmes de composition grâce è l'évaluation prévisionnelle de surface, de forme et d'interconnexions lors de l'étape de décomposition; d'absorber souplement les modifications topologiques grâce à un mécanisme de propagation. FLOPE a été implanté en langage CEYX-Le-Lisp

Discussion des termes clés des langages de description; nécessité d'une sémantique matérielle. Le langage IRENE sert à la description comportemental et structurelle des circuits intégrés VLSI. Principes du simulateur fonctionnel du langage IRENE, des outils de synthèse KARENE et MACSIM et d'une interface avec le compilateur de silicium SYCO. KASRENE assure l'intégration des langages IRENE et KARL. Solution basée sur une organisation centrée objet de la base de données d'un système de conception assistée de VLSI