Analyse dynamique de programme : Mise en oeuvre automatisée d'analyseurs performants et spécifications de modèles d'exécution

• Auteur / Autrice : Erwan Jahier
• Direction : Mireille Ducassé
• Type : Thèse de doctorat
• Discipline(s) : Informatique
• Date : Soutenance en 2000
• Etablissement(s) : Rennes, INSA
• Partenaire(s) de recherche : autre partenaire : Département informatique

Mots clés

Mots clés contrôlés

Programmes

Langages de programmation -- Sémantique

Résumé

De nombreuses études montrent que la plus grande partie du coût de production d'un logiciel est générée lors de la phase de maintenance. Lors de cette phase, pour corriger des erreurs, pour optimiser des programmes, ou pour ajouter des fonctionnalités, il est essentiel de comprendre les programmes, et en particulier de comprendre leur comportement. Les analyseurs dynamiques d'exécutions tels que les profileurs, les moniteurs, ou les débogueurs, sont alors des outils indispensables. Cependant, ces outils d'analyse dynamique sont extrêmement coûteux à mettre en oeuvre : (1) d'abord, parce qu'il est généralement nécessaire de modifier le système de compilation utilisé, ce qui est fastidieux et pas toujours envisageable ; (2) en outre, les besoins en outils d'analyse de programmes varient d'un utilisateur à l'autre, en fonction de sa compétence, de son expérience du système de programmation utilisé, ainsi que de sa connaissance du code à maintenir ; (3) et enfin, parce que ces outils sont difficilement réutilisables. Il est donc souhaitable que chaque utilisateur puisse spécifier facilement les analyses dynamiques dont il a besoin. C'est pourquoi nous proposons dans cette thèse une architecture qui permet de faciliter leur mise en oeuvre. Cette architecture est basée : (1) sur une instrumentation systématique du programme qui produit une image très détaillée de l'exécution, la trace ; (2) sur un ensemble de primitives qui permettent d'analyser cette trace efficacement. Les analyseurs résultants ont des performances du même ordre de grandeur que leurs équivalents implémentés <<à la main>> par modification du système de compilation. Ils peuvent être mis en oeuvre par des utilisateurs sans connaissance particulière du système de compilation, qu'ils n'ont pas à modifier. Cette architecture leur permet d'implémenter les outils qui leur conviennent, adaptés à leur niveau de compréhension du code qu'ils sont chargés de maintenir. De plus, la structure modulaire de l'architecture proposée devrait permettre de faciliter la réutilisation de ces analyseurs pour d'autres systèmes. Notre propos est illustré dans le cadre du langage de programmation logique et fonctionnelle Mercury. Cependant, les concepts utilisés sont indépendants du paradigme de programmation. La trace sur laquelle nous basons la mise en oeuvre de nos analyseurs se doit de refléter le plus fidèlement possible la sémantique opérationnelle du langage. C'est pourquoi nous proposons également dans cette thèse un cadre de modélisation des traces d'exécutions basé sur une sémantique opérationnelle du langage à analyser. Cette spécification formelle de la trace nous permet de valider expérimentalement les traceurs et de prouver leur correction. Cette étude a été menée dans le cadre du langage de programmation logique Prolog.

Several studies show that most of the software production cost is spent during the maintenance phase. During that phase, to locate bugs, to optimize programs, or to add new functionalities, it is essential to understand programs, and in particular to understand their runtime behavior. Dynamic analysis tools such as debuggers, profilers, or monitors, are very useful in that respect. However, such tools are expensive to implement because: (1) it generally requires to modify the compiling system, which is tedious and not always possible; (2) the needs in dynamic analysis tools vary from one user to another, depending on its competence, on its experience of the programming system, and on its knowledge of the code to maintain; (3) such tools are generally difficult to reuse. It is therefore desirable that each user is able to specify easily the dynamic analyses he needs. Hence, we propose an architecture that eases dynamic analysis tools implementation. This architecture is based on: (1) a systematic instrumentation of the program which gives a detailed image of the execution, the trace; (2) a set of trace processing primitives that lets one analyse the trace efficiently. The resulting analysers have performance of the same order of magnitude that their equivalent implemented ``by hand'' by modifying the compiling system. They can be implemented by programmers without any knowledge of the compiling system. This architecture let them implement the tools they need, adapted to their level of comprehension of the code they are in charge to maintain. Furthermore, the modular structure of the proposed architecture should ease the analysers reuse. This work has been held within the context of the logical and functional programming language Mercury. However, the concepts we used do not depend on the programming paradigm. The trace on which we base the implementation of our dynamic analysis tools should reflect as much as possible the runtime behavior of programs. Therefore, we also propose a framework to specify execution traces. This framework is based on an operational semantics of the language to analyse. Such formal specifications of the trace let us experimentally validate tracers, and prove their correctness. This work have been held within the context of the logical programming language Prolog.