Précédent : Logiciels Remonter : Avant-projet COMPOSE, Conception de programmes Suivant : Actions industrielles
Précédent : Logiciels Remonter : Avant-projet COMPOSE,
Conception de programmes Suivant : Actions
industrielles
Mots-clés : évaluation partielle, spécialisation,
outils, analyses de programmes
Résumé : L'étude des aspects fondamentaux du processus de la spécialisation de programmes nous conduit à formaliser certaines de ses phases, telles que des analyses et des transformations de programmes, afin notamment de garantir leur correction. Ce travail nous permet un développement rigoureux de techniques de mise en oeuvre du processus d'adaptation de programmes. Pour compléter notre approche de conception de logiciels adaptatifs, nous développons des outils permettant de spécialiser un logiciel générique en fonction d'un certain contexte d'utilisation. Enfin, pour valider notre approche, il est essentiel d'utiliser nos outils pour traiter des applications industrielles. Ceci nous amène à développer des outils pour des langages de programmation utilisés dans l'industrie tel que C et Java.
Depuis la fin des années soixante-dix, la communauté des langages impératifs a étudié des langages intermédiaires où les opérations impératives sont représentées fonctionnellement dans le but de faciliter le processus d'analyse et de compilation des programmes. Ces représentations intermédiaires, telle que Static Single Assignment, sont largement utilisées par des compilateurs optimisants avancés. Cependant, bien que les opérations impératives des langages étudiés soient traitées fonctionnellement, le cadre de travail est toujours impératif.
Nous avons développé un ensemble de transformations sur la
représentation fonctionnelle des programmes impératifs permettant
de les analyser avec autant de précision qu'une approche
impérative [10]. Cette
approche a été appliquée à un sous-ensemble du langage C
(incluant les pointeurs et les structures de données). La
représentation fonctionnelle des programmes C a été analysée et
transformée pour évaluer l'impact de notre approche. Ce travail a
été effectué dans le cadre de l'évaluation partielle en utilisant
Schism (voir module ![[*]](../icons/cross_ref_motif.gif){kind=icon}
).
Les résultats de cette étude ont montré que l'analyse et la
transformation d'un programme impératif sont comparables en
précision et en qualité au même programme dont la représentation
est fonctionnelle. Cette comparaison s'est effectuée à l'aide de
Tempo (voir module ) pour les
programmes impératifs.
La difficulté principale de cette approche réside dans la taille des programmes transformés qui découle de l'explicitation de la sémantique des aspects impératifs du langage C. Cette taille importante rend les analyses coûteuses en temps et en espace.
La spécialisation d'applications réelles complexes requiert des caractéristiques d'analyse prenant en compte les motifs de programmes communs au domaine considéré. Afin de spécialiser efficacement des programmes système, nous avons développé des analyses possédant des caractéristiques originales telles que la sensibilité à l'utilisation, la sensibilité au contexte, et la sensibilité au retour [15,14,9].
Ces analyses ont été intégrées au sein de Tempo (voir
module ). Elle sont utilisées à la
fois pour la spécialisation à la compilation et aussi pour la
spécialisation à l'exécution. Elles ont été validées en
appliquant Tempo avec succès sur un code système
commercial : l'implémentation de l'appel de procédure à
distance développé par SUN en 1984 (voir le
module ).
De manière générale, la spécialisation repose sur le découpage en deux parties d'un calcul répété dont une partie du contexte d'entrée reste invariante pour toutes les itérations. Une phase préliminaire, qui n'est exécutée qu'une seule fois, effectue les calculs qui ne dépendent que des invariants. Une phase ultérieure effectue les calculs restants de manière répétée en exploitant les résultats de la phase préliminaire.
Dans la spécialisation de programmes, le résultat de la phase préliminaire est le code même de la phase ultérieure, qui incorpore la connaissance des invariants. Il existe une alternative, appelée spécialisation de données, qui consiste à encoder les résultats de la phase préliminaire dans une structure de données (un cache) qui est exploitée par la phase ultérieure. C'est une notion « orthogonale » à celle de spécialisation à la compilation ou à l'exécution.
La spécialisation de données offre un compromis espace/temps très intéressant par rapport à la spécialisation de programmes. En effet, elle génère des programmes compacts (en particulier dans le cas de dépliages de boucles). De plus, la phase préliminaire de spécialisation est très rapide. En revanche, la spécialisation de données est un peu moins performante que la spécialisation de programmes.
Nous avons ébauché les éléments d'un spécialiseur de données et réalisé un premier prototype d'implémentation. Nous étudions actuellement l'intégration des deux modes de spécialisation (programmes et données) au sein de Tempo.
L'utilisation directe d'un moteur de spécialisation comme Tempo nécessite la compréhension des concepts de base de l'évaluation partielle et d'analyses telle que l'analyse de temps de liaison. Afin de simplifier l'utilisation d'un spécialiseur, nous avons introduit une approche déclarative à la spécialisation dans le contexte de la programmation orientée objet [23].
Plus précisément, le programmeur déclare quelles méthodes doivent être spécialisées et pour quels contextes. À partir de ces déclarations, un compilateur détermine comment les versions spécialisées sont produites et gérées. Le résultat de la compilation est une version instrumentée du programme source, capable d'activer la spécialisation lorsque nécessaire, et de gérer les versions spécialisées d'une manière transparente.
Dans notre approche, l'unité de déclaration est la classe de spécialisation. Elle enrichit l'information concernant une classe existante. Le rapport entre les classes normales et les classes de spécialisation est défini par une forme d'héritage reposant sur les classes de prédicats introduites par C. Chambers [Cha93]. Parmi les bénéfices de cette approche, on peut noter : (i) que la déclaration n'est pas intrusive et (ii) qu'il est possible d'exprimer une spécialisation de type incrémental [6] par héritage de classes de spécialisation.
Une implémentation d'un compilateur des classes de
spécialisation a été réalisée pour le langage Java (voir module
). Nous travaillons
actuellement à l'intégration de ce compilateur avec Harissa (voir
module ) et
Tempo (voir module ). L'approche
consiste à traduire en C les fichiers Java produits par le
compilateur de classes de spécialisation. Ces fichiers sont
ensuite spécialisés par Tempo. Nous avons appliqué cette approche
à une application de filtrage d'images. Sur un filtre à effet de
flou (blurring), nous avons obtenu un gain d'un facteur
5 en vitesse entre la version générique et la version
spécialisée.
Participants : Charles Consel , Scott Thibault , Renaud
Marlet
Mots-clés : génie logiciel,
langage dédié, interprèteur, machine abstraite
Langage dédié: langage qui permet d'exprimer des
variations à l'intérieur d'un domaine ou d'une famille
d'applications.
Résumé : Nous proposons un cadre général pour le développement de générateur d'applications reposant sur la notion de langages dédiés. Dans ce cadre, l'évaluation partielle nous permet d'obtenir des implémentations efficaces. Plus généralement, l'évaluation partielle permet d'optimiser l'implémentation de nombreuses architectures logicielles.
Les générateurs d'applications sont une approche très prometteuse pour la réutilisation logicielle. En particulier, ils apportent des gains de productivité supérieurs aux méthodes basées sur la réutilisation de composants logiciels et permettent d'appliquer des méthodes formelles. Cependant, malgré ses avantages, l'industrie du logiciel hésite à adopter cette approche du fait de l'absence d'outils d'aide à la construction de générateurs d'applications. Nous avons proposé un cadre général pour le développement de tels générateurs [21] reposant sur une approche à deux niveaux. Le premier niveau consiste à identifier les objets et opérations fondamentales du domaine d'applications, de manière à former une machine abstraite. Le second niveau consiste en la conception d'un langage dédié, qui permet d'exprimer des variations à l'intérieur d'une famille d'applications. Un programme dans ce langage dédié est implémenté via un interpréteur à l'aide des opérations de la machine abstraite définie au premier niveau. Cette structure en couche est très flexible, mais pose a priori des problèmes de performance. Grâce à l'utilisation systématique de l'évaluation partielle, il est possible de supprimer le surcoût de l'interprétation.
Ce schéma général de conception et d'implémentation
d'environnements pour les langages dédiés a été validé sur GAL,
un exemple complet de langage dédié pour l'écriture de pilotes de
cartes graphiques (voir module ). Ce langage nous a
permis de mettre en évidence les avantages que l'on attribue
généralement aux langages dédiés : productivité accrue,
programmation de haut niveau grâce à une plus grande abstraction,
vérifications formelles facilitées.
Pour de nombreuses approches de génie logiciel, comme celle des langages dédiés, l'évaluation partielle s'avère être un outil tout à fait général pour traiter le compromis flexibilité/efficacité qui existe dans ce domaine [13]. Après recherche de la source de l'inefficacité au sein de plusieurs architectures logicielles, nous avons observé que celle-ci était en partie due à l'intégration des données et du contrôle lors de l'assemblage des divers composants d'un système. La raison tient à ce que la flexibilité n'apparaît pas uniquement au stade de la conception, mais se matérialise également dans l'implémentation. Nous proposons d'utiliser la spécialisation comme moyen systématique pour améliorer la performance et, dans certains cas, réduire la taille des programmes. Nous avons étudié pour cela plusieurs implémentations représentatives de mécanismes flexibles employés dans diverses architectures logicielles : diffusion sélective, recherche de motifs, interpréteurs, couches logicielles, bibliothèques génériques. Nous avons montré comment une application systématique de l'évaluation partielle conduisait à l'optimisation de ces mécanismes [16].
Mots-clés : optimisation de systèmes d'exploitation,
systèmes distribués, RPC
Micro-noyau: noyau de système minimal qui offre
uniquement les notions d'espace d'adressage, de fil de contrôle
et d'objet mémoire. Dans un système reposant sur un micro-noyau,
la plupart des fonctions complexes (gestion réseau, système de
fichiers, processus utilisateur Unix/NT) sont exportées hors du
micro-noyau et sont implémentées par des processus spéciaux
appelés serveurs.
Communication inter-processus (IPC): mécanisme
permettant à différents processus de s'échanger de l'information.
L'IPC est un des principaux goulots d'étranglement d'un système
reposant sur un micro-noyau, puisque l'éclatement des
fonctionnalités du système entre les serveurs multiplie le nombre
des communications par rapport à un système monolithique
traditionnel.
Appel de procédure à distance (RPC): mécanisme
de communication dans les systèmes distribués qui permet à un
processus d'appeler une procédure résidant sur une machine
éventuellement différente de la sienne.
Résumé : Les systèmes d'exploitation et de télécommunication sont particulièrement représentatifs du conflit entre performance et flexibilité. À ce titre, ils représentent un domaine d'application privilégié de nos techniques de spécialisation. Plusieurs expérimentations systèmes ont été effectuées ou sont en cours de réalisation : la spécialisation de l'appel de procédure à distance, l'optimisation de la communication inter-processus au sein du micro-noyau Chorus et la spécialisation d'une application de télécommunication.
L'appel de procédure à distance (RPC) est l'un des paradigmes sur lesquels reposent les systèmes distribués. De ce fait, l'optimisation du RPC a fait l'objet de nombreuses études. Nous nous sommes plus particulièrement attachés à l'optimisation de la mise en oeuvre de l'appel de procédure à distance développé par Sun en 1984. L'architecture du RPC implémenté par Sun est constituée de multiples micro-protocoles modulaires. Toutefois, chaque utilisation du RPC repose sur une instance bien précise de ces protocoles, ce qui en fait un très bon candidat pour la spécialisation. Nous obtenons un gain de performance allant jusqu'à 1,3 sur un appel complet (réseau inclus). Sur l'encodage des données au sein du talon, le facteur d'optimisation va jusqu'à 3,7 [19,18,24]. Les retombées de cette étude sont multiples : (i) la mise en évidence de nouveaux besoins d'analyses, (ii) la validation de Tempo sur du code existant, non-écrit spécifiquement pour notre système, (iii) l'illustration du potentiel d'optimisation d'un outil tel que Tempo sur des programmes reposant sur une architecture logicielle du type de celle du RPC de Sun.
Dans le cadre d'un projet CNET (voir module ), nous étudions
l'optimisation de la communication inter-processus (IPC) au sein
du micro-noyau Chorus. Il est à noter que Chorus a déjà été
largement optimisé au moyen de techniques manuelles. En
conséquence, les opportunités de spécialisation restantes
relèvent soit d'invariants valides lors de l'exécution, soit
d'invariants valides à la compilation mais inexploitables sans
outil automatique. Nos premières mesures montrent un gain de 25%
sur un IPC local optimisé par spécialisation à la
compilation.
Enfin, dans le cadre d'une collaboration avec Alcatel (voir
module ), nous avons démarré
l'optimisation d'une application de télécommunication de taille
réelle.
Précédent : Logiciels Remonter : Avant-projet COMPOSE,
Conception de programmes Suivant : Actions
industrielles