An approach based on runtime models for developing dynamically adaptive systems

https://doi.org/10.1016/j.future.2016.07.006Get rights and content

Highlights

  • Our proposed approach is based on runtime models and aspect oriented software development.

  • Supports both anticipated and unanticipated dynamic reconfigurations.

  • Provides a set of routines ensuring the dynamic reconfiguration using a defined middleware.

  • Verifies the consistency of the system at runtime using a constraint evaluator.

  • Evaluated through a known real world example Znn.com.

Abstract

We propose an approach based on runtime models and Aspect Oriented Software Development for modeling and implementing dynamically adaptive systems. Such system requires specific modeling formalisms to support the definition of the monitoring and reconfiguration modules at an abstract level. The verification of the consistency during the reconfiguration is also an essential and primordial task in the development process of dynamically adaptive systems. In addition, a middleware that enables to perform the dynamic reconfiguration during execution should be implemented.

Our proposed approach addresses these requirements: It enables specifying dynamically adaptive systems using AADL and AO4AADL and verifying the integrity of the system at any time of its life cycle even at runtime based on a set of architectural patterns. Our approach uses the Aspect Oriented Software Development to ensure the monitoring of the system and perform the reconfiguration through a set of routines developed in our middleware.

Introduction

A dynamically adaptive system should be able to adapt its structure and/or behavior in response to changes in the execution context and varying user needs. These systems have become indispensable for large companies, such as airports, banks, telecommunication operators, etc. Such system should be reliable and always available to maintain its usefulness. For this purpose, dynamic reconfiguration should be applied at runtime whenever it is needed.

The dynamic reconfiguration is to transform the current system configuration to another one at runtime. A reconfiguration can be either anticipated or unanticipated. Anticipated reconfiguration is caused by expected changes in requirements, so the reconfiguration can be considered and planned before it is needed, whereas, unanticipated reconfiguration is caused by unexpected requirements change, so it is impossible to predict or plan the reconfiguration before the requirement for the change occurs.

The development of dynamically adaptive systems presents some challenges. These challenges are associated with developing effective mechanisms for (i) modeling dynamically adaptive systems, (ii) monitoring running systems, reasoning about and planning reconfigurations, (iii) executing these reconfigurations, and (vi) maintaining consistency of the system especially upon reconfiguration.

The first challenge in the development of dynamically adaptive system is the need to define formalisms and techniques to support both anticipated and unanticipated reconfigurations. Experience with adaptive systems has proofed that it is not always preferable to rely on the autonomic adaptation based only on anticipated reconfigurations. User interaction with the system is rather required  [1] to best fit his needs and intentions and to be able to resolve problems raised from unanticipated changes.

The second major challenge, involved by many researchers in  [2], [3], is the need to use abstract models to define and perform dynamic reconfiguration. Abstract models allow defining reconfiguration strategies in a more reusable way. This challenge consists then in raising the level of abstraction of the artifacts that a designer must specify to describe dynamically adaptive systems. Moreover, for such system, one of the important aspects that we want to abstract is the running system itself. This requires the use of abstract models that reflect the system architecture, its behavior and goals.

The third challenge is related to the development of an execution support (i.e; middleware) for dynamically adaptive systems. Actually, most of existing middlewares  [4], [5], [6], [7] do not support architectural reconfiguration resulting from requirements change at runtime. In fact, they assume that requirements can be well-defined at design time and remain unchanged at runtime. In addition, the majority of existing middlewares  [7], [8], [9] provides no mechanisms to manage concurrency between reconfigurations. Therefore, a conflict between reconfigurations during execution may affect the system functioning.

The fourth challenging issue in the development of a dynamically adaptive system is how to check its consistency, especially upon reconfiguration at runtime. In fact, applying dynamic reconfiguration directly on the running system can be error-prone and can lead to inconsistent system. A system is consistent if it remains in compliance with its specification, i.e. it does not violate any constraint defined at the specification level.

To overcome the problems related to the development of dynamically adaptive systems, we combine runtime models  [10] and Aspect Oriented Software Development  [11]. Based on these techniques, we define a complete development process for dynamically adaptive systems. The proposed process covers the entire software development cycle starting from the architecture specification to code generation. First, this process allows modeling the system structure using the architecture description language AADL (Architecture Analysis and Design Language)  [12] as well as specifying the reconfiguration logic using AO4AADL  [13], [14], an aspect-oriented extension of AADL. It allows also imposing architectural invariants on the model based on a set of defined specification patterns. Second, the proposed process allows to automatically generate code from high-level specifications based on a dedicated middleware for dynamically adaptive systems. This middleware offers mechanisms to guarantee the system consistency during reconfigurations. Third, the proposed process includes a Constraints Evaluator allowing to check the integrity of the system during its life cycle. This avoids the risk that system reconfigurations lead to undesirable states.

The paper is composed of 9 sections. Section  2 presents the adopted development process to support dynamic reconfiguration in the context of dynamically adaptive systems. In Section  3, we present the proposed patterns to define architectural invariants. Section  4 presents the defined metamodel to specify dynamic reconfigurations. In Section  5, we describe the main functionalities of our proposed middleware. Section  6 describes our proposed Constraints Evaluator. Section  7 presents an evaluative comparison which shows the effectiveness and feasibility of our approach through a real world scenario called Znn.com. Section  8 details some related work. Finally, Section  9 concludes the paper.

Section snippets

Development process

We propose a three-phase development process (Fig. 1) for dynamically adaptive systems. First, the modeling phase allows specifying, at a high level of abstraction, both the business logic and the reconfiguration-related logic. Second, the code generation phase takes place to transform these high-level specifications into executable code. The generated code will naturally resort to the runtime middleware library that ensures dynamic reconfiguration of the system. Third, the monitoring and

Specification of architectural invariants

The designer can impose a set of architectural invariants on the described model. These invariants allow defining the range of possible configurations in which the system can operate. In this context, we propose a set of specification patterns to make easier the task of definition of the architectural invariants. Specification patterns allow structuring the specification of the invariants in order to automate and facilitate the verification process of the preservation of these invariants.

Specification of dynamic reconfiguration

A reconfiguration specification must describe how the system is monitored to trigger a reconfiguration and how the system is reconfigured (i.e.; reconfiguration actions). Fig. 5 illustrates the reconfiguration metamodel that captures the relationship between the main entities to specify the reconfiguration problem. This metamodel includes state variables, monitoring aspects, reconfiguration aspects, reconfiguration actions, and reconfiguration strategies. The rest of this section describes

Our proposed middleware

One of the main contributions of our work is the development of a middleware  [25] to support dynamically adaptive systems. This middleware is dedicated to systems specified in AADL and AO4AADL. It allows the execution of the code generated from AADL and AO4AADL specifications. Our proposed middleware allows ensuring dynamic reconfiguration of the system, monitoring of some structural properties, preserving the consistency of the system during reconfiguration, and establishing a causal

Verification of the dynamically adaptive system

Before the modification of the running system, our approach applies reconfiguration actions first on the execution model that accurately represents the current system in order to be able to verify its integrity. Actually, our approach does not provide any guarantee that the defined reconfigurations satisfy the invariants. Our proposed Constraints Evaluator allows checking whether the new obtained configuration preserves the architectural invariants. If all invariants are preserved, then the new

Evaluation

We present an evaluation of our work based on a comparison between the Rainbow  [29] approach and ours, through a well-known example Znn.com. The choice of Rainbow/Znn.com was motivated by two main reasons. First, Rainbow has been recognized as a reference approach in the adaptation research community. Second, Znn.com has been used by many researchers to present and compare proposals.

In the following, we present an overview of the Znn.com system and we evaluate our approach using this system.

Related work

Several research frameworks and approaches  [29], [31], [8], [32] have been proposed to address the modeling and the development of dynamically adaptive applications. We detail in this section, the most related ones to our proposed approach.

The Rainbow framework  [29] uses an abstract architectural model representing the running system to perform the dynamic reconfiguration. This framework implements a control loop with the architectural model to observe and reconfigure the system. In Rainbow,

Conclusion

We proposed a three-phase approach for modeling and developing dynamically adaptive systems based on the combination of the runtime models technique and the AOSD paradigm. The first phase consists in specifying the software architecture and both anticipated and unanticipated dynamic reconfigurations at a high level of abstraction using, respectively, AADL and AO4AADL (aspect-oriented extension for AADL). The second phase allows automatically generating code from the specifications defined in

Sihem Loukil obtained his diploma of master degree in Computer Science in 2010 from National Engineering School of Sfax (Tunisia). Actually, she is a Ph.D. student at the ReDCAD laboratory of the National School of Engineers in Sfax (Tunisia). She started her Ph.D. work since 2010. She joined the Faculty of Sciences of Monastir as Assistant of Computer science in 2014.

Her work focuses on managing dynamic reconfiguration at runtime while checking the imposed architectural constraints. It relies

References (34)

  • Jacqueline Floch et al.

    Playing MUSIC–building context-aware and self-adaptive mobile applications

    Softw. Pract. Exp.

    (2013)
  • Brice Morin et al.

    Taming dynamically adaptive systems using models and aspects

  • SAE International. Architecture Analysis & Design Language,...
  • Sihem Loukil et al.

    Toward an aspect oriented ADL for embedded systems

  • Sihem Loukil et al.

    Ao4aadl: Aspect oriented extension for AADL

    Cent. Eur. J. Comput. Sci.

    (2013)
  • Sihem Loukil obtained his diploma of master degree in Computer Science in 2010 from National Engineering School of Sfax (Tunisia). Actually, she is a Ph.D. student at the ReDCAD laboratory of the National School of Engineers in Sfax (Tunisia). She started her Ph.D. work since 2010. She joined the Faculty of Sciences of Monastir as Assistant of Computer science in 2014.

    Her work focuses on managing dynamic reconfiguration at runtime while checking the imposed architectural constraints. It relies on the combination of Architecture Description Language (ADL) and Aspect-Oriented Software Development (AOSD). More details are available on his home page: http://www.redcad.org/members/sihem.loukil/.

    Slim Kallel obtained his diploma of master degree in computer science from National Engineering School of Sfax (Tunisia) in 2005 and his Ph.D. from Darmstadt University of Technology (Germany) in 2011. He joined the Faculty of Economics and Management (Tunisia) as Assistant Professor of Computer Science in 2009. He became an Associate Professor in 2012.

    His current research areas include Adaptive systems, Software architecture, Business process, Service oriented architecture. More details are available on his home page: http://www.redcad.org/members/kallel/.

    Mohamed Jmaiel obtained his diploma of engineer in Computer Science from Kiel (Germany) University in 1992 and his Ph.D. from the Technical University of Berlin in 1996. He joined the National School of Engineers of Sfax (Tunisia) as Assistant Professor of Computer Science in 1995. He became an Associate Professor in 1997 and full Professor in January 2009. He participated to the initiation of many graduate courses at the University of Sfax. His current research areas include software engineering of distributed systems, formal methods in model-driven architecture, component oriented development, self-adaptive and pervasive systems, autonomic middleware. He conducted many research projects and published more than 120 regular and invited papers in international conferences and journals, and has co-edited four conferences proceedings and three journals special issues on these subjects. He organized and cochaired the program committees of many international conferences, like MCSEAI2004, CRiSIS2009, NOTERE2010, OPODIS2010, and WETICE2013. He was director of the National Engineering School of Sfax (ENIS), from 2011 to 2014. Currently, he is director of the Digital research centre in Sfax.

    More details are available on his home page: http://www.redcad.org/members/jmaiel/.

    View full text