Gestion de cycle de vie des objets par aspects pour C +++

Les langages tels Java, Simula, Eiffel, Modula III sont des langages orientés objet qui ont gagné leur popularité grâce à la sûreté du traitement des exceptions et à la politique de sécurité qu'ils utilisent, notamment pour la gestion mémoire. En effet, Meyer a placé la gestion automatique de la mémoire en troisième position dans les "sept commandements" de la programmation orientée objet. L'entité utilisée pour assurer la gestion automatique de la mémoire est appelée Garbage Collector ou ramasse-miettes. Certains langages comme C, C++, Ada, Pascal et bien d'autres utilisent une libération explicite de la mémoire. L'avantage majeur de cette libération par rapport au Garbbage Collector est sans doute l'emploi des pointeurs, outil très important permettant un accès direct à certaines zones mémoires et une utilisation plus optimale de l'espace mémoire. Le C++ est l'un des langages de programmation les plus utilisés actuellement. Il est à la fois facile à utiliser et très efficace. Les caractéristiques du C++ en font un langage idéal pour certains types de projets. Il est incontournable dans la réalisation des grands programmes. Les optimisations des compilateurs actuels en font également un langage de prédilection pour ceux qui recherchent les performances. Puisqu'il est une extension de l'ANSI-C, C++ utilise une gestion explicite de la mémoire avec les delete, new, free et malloc. Pour Ellis et Stroustrup, la gestion de mémoire explicite via le Garbbage Collector n'est pas une composante du langage C++. Nous proposons dans notre travail de recherche un outil assurant une gestion implicite de la mémoire basé sur la programmation aspect, notamment avec l'extension AspectC++ qui est un préprocesseur pour un compilateur C++ usuel. L'idée est d'implémenter via AspectC++ des compteurs de références pour les objets nouvellement créés. Il s'agit d'attribuer un compteur de références à un objet, d'incrémenter ce compteur chaque fois qu'un autre objet crée une référence vers le premier objet et de décrémenter ce compteur chaque fois qu'une référence est supprimée. L'objet sera détruit dès que son compteur associé sera à zéro

Contraintes sur des flux appliquées a la vérification de programmes audio

National audienceLa programmation par contraintes s'attaque en gé-néraì a desprobì emes statiques, sans notion de temps. Cependant, les méthodes de réduction de domaines pourraient par exemplê etre utiles dans desprobì emes portant sur des flux. C'est le cas de la vérification de programmes temps-réel, avec des variables dont les valeurs peuvent changer a chaque pas de temps. Dans cet article, nous nous intéressons a la vérification de domaines de variables (flux) dans le cadre d'un langage de diagrammes de blocs. Nous proposons une méthode de réduction de domaines de ces flux, pour encadrer finement les valeurs prises au cours du temps. En particulier, nous proposons un nouvel algorithme pour calculer un point fixe dans le cas des boucles temporelles. Nous présentons ensuite une application au langage FAUST, un langage fonctionnel temps réel pour le traitement audio et nous testons notre approche sur différents programmes FAUST standards. Abstract Constraint programming usually deals with static problems. However, domain reduction method could be useful in stream-based problems. This is the case in formal verification of real time programs for which variables can be assigned different values at every single time. In this paper, we focus on domain checking of stream variables in the context of block diagram languages. We propose a reduction algorithm for streams in order to tightly reduce their domains all over the time. Particularly , we propose a new technique to compute fix points of temporal loops. Finally, we apply our method to the FAUST language, which is a real time language for processing and generating audio streams. We also test some standards FAUST programs

Automates et programmation par contraintes pour la planification de personnel

As soon as a structure is organized, the ability to put the right people at the right time is critical to satisfy the need of a department, a school or a company. We define personnel scheduling problems as the process of building, in an optimized manner, the personnel schedules. The aims of this thesis are to propose a mean to express those problems in a simple and automatic way, avoiding the user to interact with the technical aspects of the resolution. For that matter, we propose to mix the modeling power of automata with the efficiency and modularity of constraint programming for complex problem solving. Thus, we use the expressiveness of the finite multi-valued automata to model complex scheduling rules. Then, to make use of those built automata, we introduce a new filtering algorithm for multi-valued finite automata based on Lagrangian relaxation : multicost-regular. We also introduce a soft version of this constraint that has the ability to penalize violated rules defined by the automaton : soft-multicost-regular. The constraint model is automatically built. It is solved using the constraint library CHOCO and the whole modeling-solving process has been tested on realistic instances from ASAP and NRP10 libraries. The solution search is finally improved using specialized regret-based heuristics using the structure of multicost-regular and soft-multicost-regular.Dès lors qu'une structure est organisée, la capacité de placer les bonnes personnes au bon moment devient cruciale pour satisfaire les besoins d'un service, d'une école ou d'une entreprise. On définit les problèmes de planification de personnel comme le procédé consistant à construire de manière optimisée les emplois du temps de travail du personnel. La motivation de cette thèse est de proposer un moyen d'exprimer ces problèmes de manière simple et automatique, sans avoir à intervenir ensuite dans le processus de résolution. Pour cela, nous proposons de rassembler le pouvoir de modélisation des automates avec la capacité de la programmation par contraintes à résoudre efficacement des problèmes complexes. Le caractère expressif des automates est ainsi utilisé pour modéliser des règles de séquencement complexes. Puis, afin d'intégrer ces automates multi-pondérés dans un modèle de programmation par contraintes, nous introduisons un nouvel algorithme de filtrage basé sur la relaxation lagrangienne : multicost-regular. Nous présentons également une version souple de cette contrainte permettant de pénaliser les violations d'une règle modélisée par un tel automate : soft-multicost-regular. Le modèle contraintes basé sur ces contraintes est automatiquement construit. Il est résolu à l'aide de la librairie de contraintes CHOCO et à été testé sur des instances réalistes issues des librairies ASAP et NRP10. La recherche de solution est améliorée par l'utilisation d'heuristiques spécifiques basées sur les regrets et s'appuyant sur la structure des contraintes multicost-regular et soft-multicost-regular

JooFlux : modification de code à chaud et injection d'aspects directement dans une JVM 7

National audienceChanging functional and non-functional software implementation at runtime is useful and even sometimes critical both in development and production environments. JooFlux is a JVM agent that allows both the dynamic replacement of method implementations and the application of aspect advices. It works by doing bytecode transformation to take advantage of the new invokedynamic instruction added in Java SE 7 to help implementing dynamic languages for the JVM. JooFlux can be managed using a JMX agent so as to operate dynamic modifications at runtime, without resorting to a dedicated domain-specific language. We compared JooFlux with existing AOP platforms and dynamic languages. Results demonstrate that JooFlux performances are close to the Java ones --- with most of the time a marginal overhead, and sometimes a gain --- where AOP platforms and dynamic languages present significant overheads. This paves the way for interesting future evolutions and applications of JooFlux.Modifier les portions fonctionnelles et non-fonctionnelles des applications au cours de leur exécution est utile et parfois critique tant lors des phases de développement que de suivi en production. JooFlux est un agent JVM qui permet à la fois de remplacer dynamiquement des implémentations de méthodes que d'appliquer des aspects. Il fonctionne en opérant des transformations de bytecode pour tirer parti de la nouvelle instruction invokedynamic apparue dans Java SE 7 pour faciliter l'implémentation de langages dynamiques au-dessus de la JVM. JooFlux peut être piloté à l'aide d'un agent JMX afin de conduire les modifications à l'exécution, et ce, sans s'appuyer sur un langage dédié. Nous avons comparé JooFlux à d'autres plates-formes d'AOP et des langages dynamiques. Les résultats montrent que les performances de JooFlux sont proches de celles du code Java non modifié. Le sur-coût est généralement négligeable, et nous observons même parfois de légers gains, tandis que les plates-formes d'AOP et langages dynamiques montrent des performances significativement dégradées. Ceci ouvre de prometteuses perspectives tant pour les évolutions futures de JooFlux que pour des études de cas

Gestion manuelle et sécuritaire de la mémoire en Typer

Dans ce mémoire, je présente une technique pour combiner du code de bas niveau à un langage purement fonctionnel avec types dépendants. Par code de bas niveau, je veux dire n’importe quel programme écrit dans un langage qui permet le contrôle direct des ressources de la machine. En particulier, ce texte s’intéresse à la gestion de la mémoire. Plus concrètement, un programmeur C contrôle l’endroit et le moment où un bloc de mémoire est alloué, ainsi que la façon dont l’objet est initialisé. Par exemple, on peut allouer de l’espace sur la pile pour immédiatement l’initialiser avec un memcpy. Alternativement, on peut allouer un bloc sur le tas et l’initialiser champ par champ plus tard. Pour certaines applications où la mémoire est limitée ou la performance importante, ce choix est important. Un tel niveau de contrôle n’est pas disponible dans les langages de haut niveau, sauf pour quelques exceptions. Les langages fonctionnels comme OCaml ou Haskell découragent ou même interdisent de modifier les champs d’un objet. C’est encore plus vrai pour les langages à types dépendants où la mutation est l’éléphant dans le magasin de porcelaine de la cohérence. C’est un choix de design intentionnel. Un programme pur est plus facile à comprendre et analyser, mais comment séparer l’initialisation de l’allocation quand un objet ne peut pas changer ? Ce mémoire essaie de démontrer que ce n’est pas parce que c’est impossible, mais parce que ces langages ne sont pas habituellement utilisés dans un contexte où c’est nécessaire. Par contre, ce n’est pas facile non plus. Pour garantir la sécurité et la cohérence, il faut modéliser l’état d’un objet partiellement initialisé au niveau des types, ce que la plupart des langages ont de la peine à faire. La combinaison du manque de nécessité et de la lourdeur syntaxique et conceptuelle est la raison pour laquelle cette fonctionnalité est souvent absente. Pour y parvenir, nous prenons un langage à types dépendants, Typer, et nous y ajoutons le nécessaire pour récupérer une partie du contrôle abandonné dans le design original. Nous permettons au programmeur d’allouer des blocs de mémoire et de les initialiser graduellement plus tard, sans compromettre les propriétés de sécurité du programme. Concrètement, nous utilisons les monades, un concept de la théorie des catégories déjà utilisé pour la modélisation d’effets de bord, pour limiter les mutations aux endroits sécuritaires.In this thesis, I will demonstrate how to combine low-level code with dependent types. By low-level code, I mean any program authored in a language that allows direct control of computer resources. In particular, this text will focus on memory management. Specifically, a C programmer has control over the location and time when a block of memory is allocated, as well as how it is initialized. For instance, it is possible to allocate stack space to immediately initialize it with an invocation of memcpy. Alternatively, one can allocate heap spate and initialize it field by field later. For some applications where memory is constrained or performance is important, this choice can matter. This level of control is not available in high-level languages, barring a few exceptions. Functional languages such as OCaml or Haskell discourage or simply forbid the mutation of objects. This is especially the case in dependently typed languages where mutation is the bull in the china shop of consistency. This is a deliberate choice as a pure program is easier to understand and reason about. However, having allocation and initialization done in two distinct steps seems impossible in this situation. This thesis shows that this is not impossible, it is simply done this way because these kinds of languages are seldom used in a context where such control is necessary. This does not mean though that adding this feature is easy. If we are to guarantee both safety and consistency, we need to keep track of the initialization state at the type level. Most languages struggle to do this. Language designers simply forgo this feature because it is not useful to them in addition to being difficult to use. To achieve it, we start with a dependently typed language, Typer, and add back the mechanisms necessary to recover the control relinquished in the original design. We let the programmer allocate blocks of memory to initialize later, without compromising the safety properties of the program. Specifically, we use monads, a concept from category theory, a know technique to model side effects, to limit mutation to situations where it is safe

Étude de l'impact des weak references sur la gestion mémoire d'un langage à objets de haut niveau

Stage de DEA. Rapport de stage.Ce rapport présente mon travail sur la conception et l'implantation de références faibles sûres dans le projet SmartEiffel. J'étudie dans un premier temps la notion de référence faible et j'analyse l'existant dans d'autres langages. Je travaille ensuite sur les concepts précédemment développés en vue de les intégrer au langage Eiffel. Enfin, je montre leur implantation dans le ramasse-miettes de SmartEiffel, le compilateur GNU Eiffel. || In this report, I present my work on the design and implementation of safe weak references within the SmartEiffel project. First, I introduce the known concept of weak references and summarize existing implementations in other languages. Then, I study th