An approach based on runtime models for developing dynamically adaptive systems
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 . 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 . The choice of Rainbow/ was motivated by two main reasons. First, Rainbow has been recognized as a reference approach in the adaptation research community. Second, has been used by many researchers to present and compare proposals.
In the following, we present an overview of the 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)
- et al.
The user in the loop: Enabling user participation for self-adaptive applications
Future Gener. Comput. Syst.
(2014) - et al.
A layered interface-adaptation architecture for distributed component-based systems
Future Gener. Comput. Syst.
(2015) - et al.
A development framework and methodology for self-adapting applications in ubiquitous computing environments
J. Syst. Softw.
(2012) - et al.
Achieving dynamic adaptation via management and interpretation of runtime models
J. Syst. Softw.
(2012) - et al.
Software architecture constraint reuse-by-composition
Future Gener. Comput. Syst.
(2016) - et al.
Stitch: A language for architecture-based self-adaptation
J. Syst. Softw.
(2012) - et al.
Improving reliability and performances in large scale distributed applications with erasure codes and replication
Future Gener. Comput. Syst.
(2016) Software engineering for self-adaptive systems: A second research roadmap
- et al.
A component-based middleware platform for reconfigurable service-oriented architectures
Softw. - Pract. Exp.
(2012) Rainbow: Cost-effective software architecture-based self-adaptation
(2008)
Playing MUSIC–building context-aware and self-adaptive mobile applications
Softw. Pract. Exp.
Taming dynamically adaptive systems using models and aspects
Toward an aspect oriented ADL for embedded systems
Ao4aadl: Aspect oriented extension for AADL
Cent. Eur. J. Comput. Sci.
Cited by (17)
Special issue on advanced technologies enabling adaptive and collaborative smart systems
2017, Future Generation Computer SystemsAn event-based approach for formally verifying runtime adaptive real-time systems
2021, Journal of SupercomputingDesigning Cyber-Physical Systems for Runtime Self-Adaptation: Knowing More about What We Miss...
2021, Journal of Integrated Design and Process ScienceAn Architecture-Based Approach for Modeling Dynamically Adaptive IoT Systems
2020, 2020 International Conference on Computing and Information Technology, ICCIT 2020Decision model change patterns for dynamic system evolution
2020, Knowledge and Information Systems
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/.