Self-adaptation through incremental generative model transformations at runtime

A self-adaptive system uses runtime models to adapt its architecture to the changing requirements and contexts. However, there is no one-to-one mapping between the requirements in the problem space and the architectural elements in the solution space. Instead, one refined requirement may crosscut multiple architectural elements, and its realization involves complex behavioral or structural interactions manifested as architectural design decisions. In this paper we propose to combine two kinds of self-adaptations: requirements-driven self-adaptation, which captures requirements as goal models to reason about the best plan within the problem space, and architecture-based self-adaptation, which captures architectural design decisions as decision trees to search for the best design for the desired requirements within the contextualized solution space. Following these adaptations, component-based architecture models are reconfigured using incremental and generative model transformations. Compared with requirements-driven or architecture-based approaches, the case study using an online shopping benchmark shows promise that our approach can further improve the effectiveness of adaptation (e.g. system throughput in this case study) and offer more adaptation flexibility.

[1]  João Pimentel,et al.  Deriving software architectural models from requirements models for adaptive systems: the STREAM-A approach , 2011, Requirements Engineering.

[2]  Vicente Pelechano,et al.  Dynamic evolution of context-aware systems with models at runtime , 2012, MODELS'12.

[3]  John Mylopoulos,et al.  Self-Repair through Reconfiguration: A Requirements Engineering Approach , 2009, 2009 IEEE/ACM International Conference on Automated Software Engineering.

[4]  Frank Eliassen,et al.  Using architecture models for runtime adaptability , 2006, IEEE Software.

[5]  Richard N. Taylor,et al.  A highly-extensible, XML-based architecture description language , 2001, Proceedings Working IEEE/IFIP Conference on Software Architecture.

[6]  John Mylopoulos,et al.  Representing and Using Nonfunctional Requirements: A Process-Oriented Approach , 1992, IEEE Trans. Software Eng..

[7]  Brice Morin,et al.  Models@ Run.time to Support Dynamic Adaptation , 2009, Computer.

[8]  Brice Morin,et al.  Taming Dynamically Adaptive Systems using models and aspects , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[9]  Nenad Medvidovic,et al.  PLASMA: a plan-based layered architecture for software model-driven adaptation , 2010, ASE '10.

[10]  Bashar Nuseibeh,et al.  Requirements-driven adaptive security: Protecting variable assets at runtime , 2012, 2012 20th IEEE International Requirements Engineering Conference (RE).

[11]  Richard N. Taylor,et al.  Policy-based self-adaptive architectures: a feasibility study in the robotics domain , 2008, SEAMS '08.

[12]  Jeff Magee,et al.  Exploiting non-functional preferences in architectural adaptation for self-managed systems , 2010, SAC '10.

[13]  Hui Song,et al.  Supporting runtime software architecture: A bidirectional-transformation-based approach , 2011, J. Syst. Softw..

[14]  Mira Mezini,et al.  AO4BPEL: An Aspect-oriented Extension to BPEL , 2007, World Wide Web.

[15]  Jim Steel,et al.  MOF QVT final adopted specification: meta object facility (MOF) 2.0 query/view/transformation specification. , 2005 .

[16]  Yijun Yu,et al.  Requirements-Driven Self-Optimization of Composite Services Using Feedback Control , 2015, IEEE Transactions on Services Computing.

[17]  John Mylopoulos,et al.  Integrating Preferences into Goal Models for Requirements Engineering , 2010, 2010 18th IEEE International Requirements Engineering Conference.

[18]  Bradley R. Schmerl,et al.  Software Engineering for Self-Adaptive Systems: A Second Research Roadmap , 2010, Software Engineering for Self-Adaptive Systems.

[19]  Bernhard Rumpe,et al.  Model-driven Development of Complex Software : A Research Roadmap , 2007 .

[20]  Bashar Nuseibeh,et al.  Weaving Together Requirements and Architectures , 2001, Computer.

[21]  Bradley R. Schmerl,et al.  Rainbow: architecture-based self-adaptation with reusable infrastructure , 2004, International Conference on Autonomic Computing, 2004. Proceedings..

[22]  Thierry Coupaye,et al.  The FRACTAL component model and its support in Java: Experiences with Auto-adaptive and Reconfigurable Systems , 2006 .

[23]  Jeffrey O. Kephart,et al.  The Vision of Autonomic Computing , 2003, Computer.

[24]  David Garlan,et al.  Documenting software architectures: views and beyond , 2002, 25th International Conference on Software Engineering, 2003. Proceedings..

[25]  Rogério de Lemos,et al.  Software Engineering for Self-Adaptive Systems [outcome of a Dagstuhl Seminar] , 2009, Software Engineering for Self-Adaptive Systems.

[26]  Gordon S. Blair,et al.  Models@ run.time , 2009, Computer.

[27]  Gordon S. Blair,et al.  A generic component model for building systems software , 2008, TOCS.

[28]  Jeff Magee,et al.  Self-Managed Systems: an Architectural Challenge , 2007, Future of Software Engineering (FOSE '07).

[29]  Jeff Magee,et al.  From goals to components: a combined approach to self-management , 2008, SEAMS '08.

[30]  Marco Sinnema,et al.  VxBPEL: Supporting variability for Web services in BPEL , 2009, Inf. Softw. Technol..

[31]  David Garlan,et al.  Stitch: A language for architecture-based self-adaptation , 2012, J. Syst. Softw..

[32]  Yijun Yu,et al.  Stateful requirements monitoring for self-repairing socio-technical systems , 2012, 2012 20th IEEE International Requirements Engineering Conference (RE).

[33]  John Mylopoulos,et al.  Reasoning with Goal Models , 2002, ER.

[34]  Jeff Magee,et al.  Plan-directed architectural change for autonomous systems , 2007, SAVCBS '07.

[35]  Sam Malek,et al.  FUSION: a framework for engineering self-tuning self-adaptive software systems , 2010, FSE '10.

[36]  Eric S. K. Yu,et al.  Towards modelling and reasoning support for early-phase requirements engineering , 1997, Proceedings of ISRE '97: 3rd IEEE International Symposium on Requirements Engineering.

[37]  Ladan Tahvildari,et al.  Requirements driven software evolution , 2004, Proceedings. 12th IEEE International Workshop on Program Comprehension, 2004..

[38]  Mary Shaw,et al.  Software Engineering for Self-Adaptive Systems: A Research Roadmap , 2009, Software Engineering for Self-Adaptive Systems.

[39]  Yijun Yu,et al.  Self-tuning of software systems through dynamic quality tradeoff and value-based feedback control loop , 2012, J. Syst. Softw..

[40]  David Garlan,et al.  Rainbow: architecture-based self-adaptation with reusable infrastructure , 2004 .

[41]  Hans van Vliet,et al.  Software engineering - principles and practice , 1993 .

[42]  Peyman Oreizy,et al.  Architecture-based runtime software evolution , 1998, Proceedings of the 20th International Conference on Software Engineering.

[43]  Luciano Baresi,et al.  Fuzzy Goals for Requirements-Driven Adaptation , 2010, 2010 18th IEEE International Requirements Engineering Conference.

[44]  Jan Bosch,et al.  Software Architecture as a Set of Architectural Design Decisions , 2005, 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05).

[45]  Yijun Yu,et al.  Are your sites down? Requirements-driven self-tuning for the survivability of Web systems , 2011, 2011 IEEE 19th International Requirements Engineering Conference.

[46]  Nelly Bencomo,et al.  Requirements-Aware Systems: A Research Agenda for RE for Self-adaptive Systems , 2010, 2010 18th IEEE International Requirements Engineering Conference.

[47]  John Mylopoulos,et al.  An Architecture for Requirements-Driven Self-reconfiguration , 2009, CAiSE.