<  Back to the Polytechnique Montréal portal

ACRE: un générateur automatique d'aspect pour tester des logiciels écrits en C++

Etienne Duclos

Masters thesis (2012)

[img]
Preview
Download (444kB)
Cite this document: Duclos, E. (2012). ACRE: un générateur automatique d'aspect pour tester des logiciels écrits en C++ (Masters thesis, École Polytechnique de Montréal). Retrieved from https://publications.polymtl.ca/914/
Show abstract Hide abstract

Abstract

RÉSUMÉ La qualité d'un logiciel est une notion très importante de nos jours. Un des moyens de s'assurer de la bonne qualité d'un logiciel est de le tester afin d'en détecter, et de corriger, le plus grand nombre de bogues possible. L'approche proposée dans ce mémoire de maîtrise consiste à utiliser la programmation orientée aspect (AOP, pour Aspect Oriented Programming) afin de tester des programmes ecrit en C++. Elle consiste de plus en la création d'un langage dédie (DSL, pour Domain Specific Language) et d'un logiciel capable de le lire, ACRE (Automatic aspeCt cREator). Ces deux outils permettent la génération automatique d'aspects écrits en AspectC++, aspects permettant d'effectuer des tests de mémoire, d'invariants ou d’interférence dans des programmes écrits en C++. La programmation orientée aspect est un paradigme basé sur le principe de la séparation des préoccupations, qui veut que chaque module d'un programme s'occupe uniquement d'une préoccupation et ne s'implique pas dans les autres. L'AOP a déjà été utilisée afin de tester des logiciels, mais uniquement pour des programmes écrits en Java et pour des programmes embarques écrits en C++. De plus très peu de solutions ont été proposées afin d'automatiser la création des aspects et leur utilisation. Lorsque de telles solutions ont été proposées, elles l’étaient uniquement pour des programmes écrits en Java. Notre approche permet donc la génération automatique d'aspects pour des programmes écrits en C++. Ceci est fait grâce au DSL non-intrusif (dans le sens qu'il ne modifie pas le comportement du code source) introduit sous forme de commentaires dans le code source du programme à tester. L’écriture des lignes de DSL au plus près du code à tester est par ailleurs la seule modification requise à effectuer dans le code source du programme. Les aspects générés sont écrits dans des fichiers séparés et sont ensuite tisses au moment de la compilation avec le code source du programme. Notre approche permet ainsi aux développeurs de pouvoir tester un programme sans avoir à en modifier le comportement. Une première étude de cas pour notre approche est son application afin de tester NOMAD, logiciel d'optimisation de fonctions de type boite noire, utilisé tant en recherche qu'en industrie. Nous avons donc généré automatiquement des aspects permettant la découverte de bogues dans NOMAD. Un test de mémoire nous a permis de détecter une fuite mémoire importante, rapportée par un relevé de bogues d'un utilisateur, grâce à un aspect généré automatiquement. Une deuxième étude de cas nous a permis de rassurer l’équipe de développement de NOMAD. Nous avons en effet pu vérifier la validité d'un point mathématique crucial de l'algorithme implémenté. Ce test d'invariant a été là encore effectué grâce à un aspect généré automatiquement et sans modifier le comportement du code source de NOMAD. Une troisième étude de cas concerne la détection de bogues de type interférence dans des programmes parallèles Un bogue de type interférence se produit lorsque qu'au moins deux fils d’exécution d'un programme tentent d’écrire en même temps dans une même variable. Ce type de bogue fait partie des bogues affectant les programmes parallèles les plus difficiles à détecter et peu de logiciels actuels permettent de les découvrir à coup sûr. Notre approche permet l'obtention, grâce à des aspects, des temps d’accès en lecture et en écriture d'attributs du programme, ces temps étant ensuite utilisés par une approche mathématique qui aide les logiciels actuels dans leur détection de ce type de bogue. Il y a cependant des limites à l'utilisation de notre approche, notamment dues à des limitations inhérentes à AspectC++, limitations dont nous discutons.----------ABSTRACT In the modern era, software quality is very important. In order to have high software quality, we can test it to find and remove the maximum number of bugs. Our approach uses Aspect-Oriented Programming (AOP) to test software written in C++. We propose a Domain Specific Language (DSL) and ACRE, an Automatic aspeCt cREator that can read our DSL. From these two tools we can automatically generate aspects written in AspectC++ to perform memory, invariant and interference testing for software written in C++. Aspect-Oriented Programming is a paradigm based on the concept of separation of concerns. In this concept, each module deals with one and only one concern, and does not deal with the concerns of other modules. AOP has already been used in testing, but only for software written in Java or embedded software written in C++. Few of these approaches allow an automatic generation of aspects, and to date, it was only to test software written in Java. Our approach allows automatic aspect generation for software written in C++ thanks to our non-intrusive DSL (in the sense that it does not change the behavior or the source code). Our DSL is inserted in the source code of the tested software as comments and this is the only modification made in the source code. Generated aspects are then written to dedicated files and woven within the source code at compile time. Our approach allows developers to test software without having to modify its behavior. Our first case study is to apply our approach with the intent of testing NOMAD, a black box optimization software used both in research and industry. Using automatically generated aspects, we are able to do memory testing in NOMAD and locate an important memory leak mentioned in a bug report. Our second case study is to do invariant testing in NOMAD. We are able, still using a generated aspect, to verify a crucial mathematical point of the implemented algorithm without modifying the behavior of the source code of NOMAD. The third case study concerns interference testing in multi-threaded programs. An interference bug occurs when at least two threads try to write to the same shared variable at the same time. This kind of bug is one of the most difficult to detect and no software is able to them with 100% accuracy. Our approach is used to get both read and write access times for the attribute of the tested software using aspects. These times are then used in a mathematical approach that helps the actual software find interference bug patterns. However there are some limitations to our approach, due to inherent limitations of AspectC++. These limitations are discussed in this thesis.

Open Access document in PolyPublie
Department: Département de génie informatique et génie logiciel
Dissertation/thesis director: Yann-Gaël Guéhéneuc and Sébastien Le Digabel
Date Deposited: 14 Nov 2012 14:49
Last Modified: 27 Jun 2019 16:49
PolyPublie URL: https://publications.polymtl.ca/914/

Statistics

Total downloads

Downloads per month in the last year

Origin of downloads

Repository Staff Only