Leveraging Models from Design-time to Runtime to Support Dynamic Variability

Society's increasing dependence on software-intensive systems is driving the need for dependable, robust, continuously available adaptive systems. Such systems often propose many variability dimensions with many possible variants, leading to an explosion of the number of configurations that is impossible to fully specify and validate at design-time because of time and resource constraints. This thesis presents a Model-Driven and Aspect-Oriented approach to tame the complexity of Dynamically Adaptive Systems (DAS). At design-time, we capture the different facets of a DAS (variability, environment/context, reasoning and architecture) using dedicated metamodels. Each feature of the variability model describing a DAS is refined into an aspect model. We leverage these design models at runtime to drive the dynamic adaptation process. Both the running system and its execution context are abstracted as models. Depending on the current context (model) a reasoner interprets the reasoning model to determine a well fitted selection of features. We then use Aspect-Oriented Modeling techniques to automatically compose the aspect models (associated to the selected features) together in order to automatically derive the corresponding architecture. This way, there is no need to specify the whole set of possible configurations at design-time: each configuration is automatically built when needed. We finally rely on model comparison to fully automate the reconfiguration process in order to actually adapt the running system, with no need to write low-level reconfiguration scripts. An important point is that models embedded at runtime are really mirrors of what really happens in the running system. It is however possible to work on copies of these models, independently of the running system and resynchronize these copies with the reality to actually adapt the running system. In other words, our approach makes it possible to perform offline activities such as continuous design or prediction, while the system is running, but independently from it.La dépendance croissante de la société à l'égard des systèmes logiciels nécessite de concevoir des logiciels robustes, adaptatifs et disponibles sans interruption. De tels systèmes proposent souvent de nombreux points de variation avec de nombreuses variantes, conduisant à une explosion combinatoire du nombre des configurations. Il devient rapidement impossible de spécifier et de valider toutes ces configurations lors de la conception d'un système adaptatif complexe. Cette thèse présente une approche dirigée par les modèles et basée sur la modélisation par aspects pour contenir la complexité de systèmes logiciels adaptatifs (Dynamically Adaptive Systems, DAS). Lors de la conception, les différentes facettes d'un DAS (variabilité, environnement/contexte, raisonnement et architecture) sont capturées à l'aide de différents méta-modèles dédiés. En particuliers, les variants de chaque point de variation sont raffinés à l'aide d'aspect (niveau model). Ces modèles sont embarqués à l'exécution pour contrôler et automatiser le mécanisme de reconfiguration dynamique. Le système courant et son contexte d'exécution sont abstraits par des modèles. Selon le contexte courant (modèle) un composant de raisonnement interprète le modèle de raisonnement et détermine un ensemble de variantes bien adaptées au contexte. Nous utilisons un tisseur d'aspects (niveau model) pour dériver automatiquement l'architecture correspondante à cette sélection de variantes. Ainsi, les concepteurs du DAS n'ont pas besoin de spécifier toutes les configurations : au contraire, chaque configuration est automatiquement construite lorsqu'il y en a besoin. Nous utilisons finalement une comparaison de modèle pour automatiser entièrement le processus de reconfiguration dynamique, sans avoir besoin d'écrire des scripts de reconfiguration de bas niveau. Les modèles embarqués à l'exécution sont des miroirs reflétant ce qui se produit vraiment dans le système courant. Il est cependant possible de travailler sur des copies de ces modèles, indépendamment du système courant et de re-synchronizer ces copies avec la réalité pour adapter réellement le système courant. En d'autres termes, notre approche permet d'exécuter des activités offline (pendant que le système fonctionne, mais indépendamment de lui) telles que la conception continue (continuous design) ou la prévisio