No description available.

L’un des buts de l’Ingénierie Dirigée par les Modèles (IDM) est de considérer les modèles comme des éléments productifs pour le développement d’applications. Dans cette optique, une nouvelle tendance concerne les modèles exécutables où un modèle produit en phase de conception est réutilisé en tant que tel en phase d’exécution grâce aux interpreted Domain-Specific Modeling Language (i DSML) qui sont interprétés par un moteur d’exécution. Cette façon de procéder permet de gagner du temps lors du développement d’un logiciel et est par conséquent moins coûteux. D’autre part, les logiciels peuvent être dotés de capacités adaptatives. Ces applications adaptatives sont généralement confrontées à un contexte qui est plus ou moins connu et susceptible de changer au cours de l’exécution et auquel elles vont devoir faire face en modifiant leur comportement dynamiquement, c’est-à-dire sans interruption de service. De telles adaptations dynamiques et automatiques sont censées éviter une phase de maintenance onéreuse pour le logiciel. Nous avons donc d’un côté les i DSML qui permettent de réduire les coûts de développement d’une application et de l’autre côté l’adaptation logicielle qui permet de réduire les coûts de maintenance d’un programme. Dans cette thèse nous souhaitons prendre le meilleur des deux mondes en fusionnant les deux idées. Le résultat revient in fine à directement adapter l’exécution d’un modèle via des i DSML adaptables. Pour cela, nous proposons une caractérisation des i DSML adaptables, la définition du concept de famille pour gérer l’adaptation des i DSML, puis la création d’un langage exécutable d’orchestration dédié à l’adaptation, aboutissant ainsi au fait particulier d’adapter un i DSML par un autre i DSML. Enfin, un prototype à base de deux moteurs d’exécution est proposé avec son implémentation en Java/EMF. / One of the goals of Model-Driven Engineering (MDE) is to treat models as productive elements for software development. From this point of view, a new trend is about executable models where a model that is produced at design time is reused as such at runtime through interpreted Domain-Specific Modeling Languages (i DSMLs) that are interpreted by an execution engine. This way to proceed allows to save time during the software development and consequently is more cost-effective. On the other hand, software can provide adaptive capabilities. These adaptive applications are often facing a context which is more or less known and which may change during the execution and they will address these various situations by modifying dynamically their own behavior, i.e. without any service disruption. Such dynamic and automatic adaptations ought to avoid a too expensive maintenance stage for the program. We have on one hand the i DSMLs that allow to decrease the development costs of a program and on the other hand the software adaptation that allows to decrease the maintenance costs of an application. In this thesis, we must succeed in having the best of both worlds by merging these two ideas. The result is ultimately to directly adapt the model execution through adaptable i DSMLs. To this end, we propose a characterization of adaptable i DSMLs, the definition of the family concept to manage adaptation of i DSMLs, then the creation of an executable orchestration language for adaptation, thereby leading to the fact that an i DSML is adapted through an other i DSML. Finally, a prototype based on two execution engines is proposed with its implementation in Java/EMF.

The goal of this thesis is the development of support for test generation and animation based on object-oriented specifications. We aim particularly to take advantage of state-of-the-art satisfiability solving techniques by using an appropriate representation of object-oriented data. While automated test generation seeks a large set of data to execute an implementation on, animation performs computations that comply with a specification based on user-provided input data. Animation is a valuable technique for validating specifications.As a foundation of this work, we present clarifications and a partial formalization of the Object Constraint Language (OCL) as well as some extensions in order to allow for test generation and animation based on OCL specifications.For test generation, we have implemented several enhancements to HOL-TestGen, a tool built on top of the Isabelle theorem proving system that generates tests from specifications in Higher-Order Logic (HOL). We show how SMT solvers can be used to solve various types of constraints in HOL and present a modular approach to case splitting for deriving test cases. The latter facilitates the introduction of splitting rules that are tailored to object-oriented specifications.For animation, we implemented the tool OCLexec for animating OCL specifications. OCLexec generates from operation contracts corresponding Java implementations that call an SMT-based constraint solver at runtime.

Wireless Sensor Networks (WSNs) are typically used to monitor specific phenomena and gather the data to a gateway node, where the data is further processed. WSNs nodes have limited power resources, which require developing power efficient systems. Additionally, reaching the nodes after a deployment to correct any design flaws is very challenging due the distributed nature of the nodes. The current development of WSNs occurs at the coding layer, which prevent the design from going through a typical software design process. Designing and analyzing the software modules of a WSN system at a higher abstraction layer than at the coding level will enable the designer of a WSN to fix any design errors and improve the system for power consumption at an early design stage, before the actual deployment of the network. This thesis presents multiple Unified Modeling Language (UML) design patterns that enable the designer to capture the structure and the behavior of the design of a WSN at higher abstraction layers. The UML models are developed based on these design patterns that are capable of early validation of the functional requirements and the power consumption of the system hardware resources by leveraging animation and instrumentation of the UML diagrams. To support the analysis of power consumption of the communication components of a WSN node, the Avrora network simulator was integrated with the UML design environment such that designer is able to analyze the power consumption analysis of the communication process at the UML layer. The UML and the Avrora simulation integration is achieved through developing a code generator that produces the necessary configuration for Avrora simulator and through parsing the simulator results. The methodology presented in this thesis is evaluated by demonstrating the power analysis of a typical collector system.

The development of self-adaptive software requires the engineering of an adaptation engine that controls and adapts the underlying adaptable software by means of feedback loops. The adaptation engine often describes the adaptation by using runtime models representing relevant aspects of the adaptable software and particular activities such as analysis and planning that operate on these runtime models. To systematically address the interplay between runtime models and adaptation activities in adaptation engines, runtime megamodels have been proposed for self-adaptive software. A runtime megamodel is a specific runtime model whose elements are runtime models and adaptation activities. Thus, a megamodel captures the interplay between multiple models and between models and activities as well as the activation of the activities. In this article, we go one step further and present a modeling language for ExecUtable RuntimE MegAmodels (EUREMA) that considerably eases the development of adaptation engines by following a model-driven engineering approach. We provide a domain-specific modeling language and a runtime interpreter for adaptation engines, in particular for feedback loops. Megamodels are kept explicit and alive at runtime and by interpreting them, they are directly executed to run feedback loops. Additionally, they can be dynamically adjusted to adapt feedback loops. Thus, EUREMA supports development by making feedback loops, their runtime models, and adaptation activities explicit at a higher level of abstraction. Moreover, it enables complex solutions where multiple feedback loops interact or even operate on top of each other. Finally, it leverages the co-existence of self-adaptation and off-line adaptation for evolution. / Die Entwicklung selbst-adaptiver Software erfordert die Konstruktion einer sogenannten "Adaptation Engine", die mittels Feedbackschleifen die unterliegende Software steuert und anpasst. Die Anpassung selbst wird häufig mittels Laufzeitmodellen, die die laufende Software repräsentieren, und Aktivitäten wie beispielsweise Analyse und Planung, die diese Laufzeitmodelle nutzen, beschrieben. Um das Zusammenspiel zwischen Laufzeitmodellen und Aktivitäten systematisch zu erfassen, wurden Megamodelle zur Laufzeit für selbst-adaptive Software vorgeschlagen. Ein Megamodell zur Laufzeit ist ein spezielles Laufzeitmodell, dessen Elemente Aktivitäten und andere Laufzeitmodelle sind. Folglich erfasst ein Megamodell das Zusammenspiel zwischen verschiedenen Laufzeitmodellen und zwischen Aktivitäten und Laufzeitmodellen als auch die Aktivierung und Ausführung der Aktivitäten. Darauf aufbauend präsentieren wir in diesem Artikel eine Modellierungssprache für ausführbare Megamodelle zur Laufzeit, EUREMA genannt, die aufgrund eines modellgetriebenen Ansatzes die Entwicklung selbst-adaptiver Software erleichtert. Der Ansatz umfasst eine domänen-spezifische Modellierungssprache und einen Laufzeit-Interpreter für Adaptation Engines, insbesondere für Feedbackschleifen. EUREMA Megamodelle werden über die Spezifikationsphase hinaus explizit zur Laufzeit genutzt, um mittels Interpreter Feedbackschleifen direkt auszuführen. Zusätzlich können Megamodelle zur Laufzeit dynamisch geändert werden, um Feedbackschleifen anzupassen. Daher unterstützt EUREMA die Entwicklung selbst-adaptiver Software durch die explizite Spezifikation von Feedbackschleifen, der verwendeten Laufzeitmodelle, und Adaptionsaktivitäten auf einer höheren Abstraktionsebene. Darüber hinaus ermöglicht EUREMA komplexe Lösungskonzepte, die mehrere Feedbackschleifen und deren Interaktion wie auch die hierarchische Komposition von Feedbackschleifen umfassen. Dies unterstützt schließlich das integrierte Zusammenspiel von Selbst-Adaption und Wartung für die Evolution der Software.

This thesis takes place in the field of Ambient Intelligence (AmI). AmI Systems are interactive systems composed of many heterogeneous components. From a hardware perspective these components can be divided into two main classes: sensors, using which the system observes its surroundings, and actuators, through which the system acts upon its surroundings in order to execute specific tasks.From a functional point of view, the goal of AmI Systems is to activate some actuators, based on data provided by some sensors. However, sensors and actuators may suffer failures. Our motivation in this thesis is to equip ambient systems with self fault detection capabilities. One of the particularities of AmI systems is that instances of physical resources (mainly sensors and actuators) are not necessarily known at design time; instead they are dynamically discovered at run-time. In consequence, one could not apply classical control theory to pre-determine closed control loops using the available sensors. We propose an approach in which the fault detection and diagnosis in AmI systems is dynamically done at run-time, while decoupling actuators and sensors at design time. We introduce a Fault Detection and Diagnosis framework modeling the generic characteristics of actuators and sensors, and the physical effects that are expected on the physical environment when a given action is performed by the system's actuators. These effects are then used at run-time to link actuators (that produce them) with the corresponding sensors (that detect them). Most importantly the mathematical model describing each effect allows the calculation of the expected readings of sensors. Comparing the predicted values with the actual values provided by sensors allows us to achieve fault-detection.

Les techniques dynamiques de vérification et validation (V&V) de modèles sont nécessaires pour assurer la qualité des modèles exécutables. La plupart de ces techniques reposent sur la concept de trace d'exécution, une séquence contenant un ensemble d'informations sur une exécution. Par conséquent, pour permettre la V&V dynamique de modèles exécutables conformes à n'importe quel langage de modélisation dédié exécutable (LMDx), il est crucial de fournir des outils pour construire et manipuler toutes sortes de traces d'exécution. À cet effet, nous proposons d'abord une approche de clonage efficace de modèles afin de pouvoir construire des traces d'exécution génériques à base de clones. À l'aide d'un générateur aléatoire de métamodèles, nous montrons que cette approche passe à l'échelle avec seulement un léger surcoût lors de la manipulation de clones. Nous présentons ensuite une approche générative pour définir des métamodèles dédiés et multidimensionnels pour représenter des traces d'exécution, qui consiste à créer la structure de données spécifique aux traces d'exécution d'un LMDx donné. Ainsi, les traces d'exécution de modèles conformes à ce LMDx peuvent être capturées et manipulées efficacement de manière dédiée et à l'aide de différentes dimensions. Nous appliquons cette approche à deux techniques de V&V dynamiques existantes, à savoir la différentiation sémantique et le débogage omniscient. Nous montrons qu'un tel métamodèle de traces d'exécution généré fournit une bonne facilité d'usage et un bon passage à l'échelle pour la V&V dynamique au plus tôt pour n'importe quel LMDx. Nous avons intégré notre travail au sein du GEMOC Studio, un environnement de définition de langages et de modélisation issu de l'initiative internationale du même nom. / Dynamic verification and validation (V&V) techniques are required to ensure the correctness of executable models. Most of these techniques rely on the concept of execution trace, which is a sequence containing information about an execution. Therefore, to enable dynamic V&V of executable models conforming to any executable domain-specific modeling language (xDSML), it is crucial to provide efficient facilities to construct and manipulate all kinds of execution traces. To that effect, we first propose a scalable model cloning approach to conveniently construct generic execution traces using model clones. Using a random metamodel generator, we show that this approach is scalable in memory with little manipulation overhead. We then present a generative approach to define multidimensional and domain-specific execution trace metamodels, which consists in creating the execution trace data structure specific to an xDSML. Thereby, execution traces of models conforming to this xDSML can be efficiently captured and manipulated in a domain-specific way. We apply this approach to two existing dynamic V&V techniques, namely semantic differencing and omniscient debugging. We show that such a generated execution trace metamodel provides good usability and scalability for dynamic early V&V support for any xDSML. Our work have been implemented and integrated within the GEMOC Studio, which is a language and modeling workbench resulting from the eponym international initiative.

L'objectif de cette thèse est l'assistance à la génération de tests et à l'animation de spécifications orientées objet. Nous cherchons en particulier à profiter de l'état de l'art des techniques de résolution de satisfaisabilité en utilisant une représentation appropriée des données orientées objet. Alors que la génération automatique de cas de tests recherche un large ensemble de valeurs à fournir en entrée d'une application, l’animation de spécifications effectue les calculs qui sont conformes à une spécification à partir de valeurs fournies par l'utilisateur. L'animation est une technique importante pour la validation des spécifications.Comme fondement de ce travail, nous présentons des clarifications et une formalisation partielle du langage de spécification OCL (Object Constraint Language) ainsi que quelques extensions, afin de permettre la génération de tests et l'animation à partir de spécifications OCL.Pour la génération de tests, nous avons implémenté plusieurs améliorations à HOL-TestGen, outil basé sur le démonstrateur de théorème Isabelle, qui engendre des tests à partir de spécifications en Logique d’Ordre Supérieure (Higher-Order Logic ou HOL). Nous montrons comment des solveurs SMT peuvent être utilisés pour résoudre différents types de contraintes en HOL et nous présentons une approche modulaire de raisonnement par cas pour dériver des cas de tests. Cette dernière approche facilite l'introduction de règles de decomposition par cas qui sont adaptées aux spécifications orientées objet.Pour l'animation de spécifications, nous avons développé OCLexec, outil d'animation de spécifications en OCL. A partir de contrats de fonctions OCLexec produit les implémentations Java correspondantes qui appellent un solveur de contraintes SMT lors de leur exécution. / The goal of this thesis is the development of support for test generation and animation based on object-oriented specifications. We aim particularly to take advantage of state-of-the-art satisfiability solving techniques by using an appropriate representation of object-oriented data. While automated test generation seeks a large set of data to execute an implementation on, animation performs computations that comply with a specification based on user-provided input data. Animation is a valuable technique for validating specifications.As a foundation of this work, we present clarifications and a partial formalization of the Object Constraint Language (OCL) as well as some extensions in order to allow for test generation and animation based on OCL specifications.For test generation, we have implemented several enhancements to HOL-TestGen, a tool built on top of the Isabelle theorem proving system that generates tests from specifications in Higher-Order Logic (HOL). We show how SMT solvers can be used to solve various types of constraints in HOL and present a modular approach to case splitting for deriving test cases. The latter facilitates the introduction of splitting rules that are tailored to object-oriented specifications.For animation, we implemented the tool OCLexec for animating OCL specifications. OCLexec generates from operation contracts corresponding Java implementations that call an SMT-based constraint solver at runtime.

Cette thèse s’inscrit dans le domaine de l'intelligence ambiante (Ambient Intelligence - AmI). Les systèmes AmI sont des systèmes interactifs composés de plusieurs éléments hétérogènes. Principalement : les capteurs et les effecteurs.D'un point de vue fonctionnel, l'objectif des systèmes AmI est d'activer certains effecteurs, sur la base des mesures des capteurs. Toutefois, les capteurs et les effecteurs peuvent subir des défaillances. Notre motivation dans cette thèse est de munir les systèmes AmI de capacités d'auto-détection des pannes.Les ressources physiques ne sont pas nécessairement connues au moment de la conception, mais elles sont plutôt découvertes dynamiquement lors de l'exécution. Il est donc impossible d’appliquer les techniques classiques pour prédéterminer des boucles de régulation ad-hoc.Nous proposons une nouvelle approche où la stratégie de détection de défaillances est déterminée dynamiquement lors de l'exécution. Pour cela, les couplages entre capteurs et effecteurs sont déduits automatiquement lors de l’exécution. Ceci est rendu possible par la modélisation des caractéristiques des capteurs, des effecteurs, ainsi que des phénomènes physiques (que nous appelons effets) qui sont attendus dans l'environnement ambiant suite à une action d’un effecteur. Ces effets sont utilisés en run-time pour lier les effecteurs (produisant les effets) avec les capteurs correspondants (détectant ces effets). Nous introduisons une plateforme de détection des pannes qui génère à l’exécution un modèle de prédiction des valeurs attendues sur les capteurs. Ce modèle, de nature hétérogène (il mêle flots de données et automates finis) est exécuté par un outil adapté (ModHel’X) de façon à fournir les valeurs attendues à chaque instant. Notre plateforme compare alors ces valeurs avec les valeurs réellement mesurées de façon à détecter les défaillances. / This thesis takes place in the field of Ambient Intelligence (AmI). AmI Systems are interactive systems composed of many heterogeneous components. From a hardware perspective these components can be divided into two main classes: sensors, using which the system observes its surroundings, and actuators, through which the system acts upon its surroundings in order to execute specific tasks.From a functional point of view, the goal of AmI Systems is to activate some actuators, based on data provided by some sensors. However, sensors and actuators may suffer failures. Our motivation in this thesis is to equip ambient systems with self fault detection capabilities. One of the particularities of AmI systems is that instances of physical resources (mainly sensors and actuators) are not necessarily known at design time; instead they are dynamically discovered at run-time. In consequence, one could not apply classical control theory to pre-determine closed control loops using the available sensors. We propose an approach in which the fault detection and diagnosis in AmI systems is dynamically done at run-time, while decoupling actuators and sensors at design time. We introduce a Fault Detection and Diagnosis framework modeling the generic characteristics of actuators and sensors, and the physical effects that are expected on the physical environment when a given action is performed by the system's actuators. These effects are then used at run-time to link actuators (that produce them) with the corresponding sensors (that detect them). Most importantly the mathematical model describing each effect allows the calculation of the expected readings of sensors. Comparing the predicted values with the actual values provided by sensors allows us to achieve fault-detection.

Submitted by Franciele Moreira (francielemoreyra@gmail.com) on 2018-02-01T11:58:08Z No. of bitstreams: 2 Dissertação - Weider Alves Barbosa - 2017.pdf: 3232518 bytes, checksum: 2a1f899f2cf8bf0f76707049183a9888 (MD5) license_rdf: 0 bytes, checksum: d41d8cd98f00b204e9800998ecf8427e (MD5) / Approved for entry into archive by Luciana Ferreira (lucgeral@gmail.com) on 2018-02-02T09:42:07Z (GMT) No. of bitstreams: 2 Dissertação - Weider Alves Barbosa - 2017.pdf: 3232518 bytes, checksum: 2a1f899f2cf8bf0f76707049183a9888 (MD5) license_rdf: 0 bytes, checksum: d41d8cd98f00b204e9800998ecf8427e (MD5) / Made available in DSpace on 2018-02-02T09:42:07Z (GMT). No. of bitstreams: 2 Dissertação - Weider Alves Barbosa - 2017.pdf: 3232518 bytes, checksum: 2a1f899f2cf8bf0f76707049183a9888 (MD5) license_rdf: 0 bytes, checksum: d41d8cd98f00b204e9800998ecf8427e (MD5) Previous issue date: 2017-10-30 / Coordenação de Aperfeiçoamento de Pessoal de Nível Superior - CAPES / This thesis presents an approach to construct model execution machines based on the concept of Domain Specific Virtual Machines (DSVMs), focusing on the control middleware layer that is responsible for the control of model execution. In order to build this layer, we used techniques derived from model-driven engineering (MDE), in order to take advantage of the fact that DSVMs can both interpret models directly and be constructed using models. Another concept used in the proposed approach is the Separation of Concerns, separating the execution model from the knowledge of the application domain. In this sense, the main objective of this work is to propose an approach that unifies the MDE techniques and separation of concerns for the construction of DSVMs, thus allowing to express both the structure and operational semantics of the middleware. As a result, an instance of the control layer of a DSVM for the user-centric communication domain is displayed. We also present the results of a performance evaluation that was carried out to analyze the impact of proposed approach on the execution time. / Esta dissertação apresenta uma abordagem para construção de máquinas de execução de modelos baseadas no conceito de Domain Specific Virtual Machines (DSVMs), com foco na camada de middleware de controle, que é responsável pelo controle de execução de modelos. Para construir essa camada, foram utilizadas técnicas provenientes da engenharia dirigida por modelos (MDE), visando aproveitar o fato de que DSVMs podem tanto interpretar modelos diretamente, quanto ser construída por meio de modelos. Outro conceito utilizado na abordagem proposta é a separação de interesses (Separation of Concerns), separando o modelo de execução do conhecimento de domínio de aplicação. Neste sentido, o objetivo principal deste trabalho é propor uma abordagem que faça a união das técnicas MDE e separação de interesses para construção de DSVMs, permitindo assim expressar tanto a estrutura quanto a semântica operacional do middleware. Como resultado, é apresentada uma instância da camada de controle de uma DSVM para o domínio de comunicação centrada no usuário. Também são apresentados os resultados de uma avaliação de desempenho realizada para analisar a abordagem proposta sobre o tempo de execução.