Rainbow: cost-effective software architecture-based self-adaptation

Modern, complex software systems (e-commerce, IT, critical infrastructures, etc.) are increasingly required to continue operation in the face of change, to self-adapt to accommodate shifting user priorities, resource variability, changing environments, and component failures. While manual oversight benefits from global problem contexts and flexible policies, human operators are costly and prone to error. Low-level, embedded mechanisms (exceptions, time-outs, etc.) are effective and timely for error recovery, but are local in scope to the point-of-failure, application-specific, and costly to modify when adaptation objectives change. An ideal solution leverages domain expertise, provides an end-to-end system perspective, adapts the system in a timely manner, and can be engineered cost-effectively. Architecture-based self-adaptation closes the “loop of control,” using external mechanisms and the architecture model of the target system to adapt the system. An architecture model exposes important system properties and constraints, provides end-to-end problem contexts, and allows principled and automated adaptations. Existing architecture-based approaches specialize support for particular classes of systems and fixed sets of quality-of-service concerns; they are costly to develop for new systems and to evolve for new qualities. To overcome these limitations, we posit this thesis: We can provide software engineers the ability to add and evolve self-adaptation capabilities cost-effectively, for a wide range of software systems, and for multiple objectives, by defining a self-adaptation framework that factors out common adaptation mechanisms and provides explicit customization points to tailor self-adaptation capabilities for particular classes of systems, for multiple quality-of-service objectives. Our approach, embodied in a system called Rainbow, provides an engineering approach and a framework of mechanisms to monitor a target system and its environment, reflect observations into the system's architecture model, detect opportunities for improvements, select a course of action, and effect changes. The framework provides general and reusable infrastructures with well-defined customization points, a set of abstractions, and an adaptation engineering process, focusing engineers on adaptation concerns to systematically customize Rainbow to particular systems. To automate system self-adaptation, Rainbow provides a language, called Stitch, to represent routine human adaptation knowledge using a core set of adaptation concepts.

[1]  Gail E. Kaiser,et al.  A Mobile Agent Approach to Process-Based Dynamic Adaptation of Complex Software Systems , 2001, EWSPT.

[2]  Pablo de la Fuente,et al.  Dynamic coordination architecture through the use of reflection , 2001, SAC.

[3]  Donald W. Tufts,et al.  K-i L-l , 1985 .

[4]  Marco Dorigo,et al.  Swarm intelligence: from natural to artificial systems , 1999 .

[5]  John Durkin,et al.  Expert systems - design and development , 1994 .

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

[7]  Jeff Magee,et al.  Dynamic structure in software architectures , 1996, SIGSOFT '96.

[8]  Shlomi Dolev,et al.  Self Stabilization , 2004, J. Aerosp. Comput. Inf. Commun..

[9]  Shawn A. Butler Security attribute evaluation method: a cost-benefit approach , 2002, ICSE '02.

[10]  Robert A. Riemenschneider,et al.  Introduction to SADL 1.0: A Language for Specifying Software Architecture Hierarchies , 1997 .

[11]  Donald D. Dudenhoeffer,et al.  Mixed-initiative control for remote characterization of hazardous environments , 2003, 36th Annual Hawaii International Conference on System Sciences, 2003. Proceedings of the.

[12]  Peyman Oreizy,et al.  Using object-oriented typing to support architectural design in the C2 style , 1996, SIGSOFT '96.

[13]  GhemawatSanjay,et al.  The Google file system , 2003 .

[14]  Thaís Vasconcelos Batista,et al.  Managing Dynamic Reconfiguration in Component-Based Systems , 2005, EWSA.

[15]  Mary Shaw,et al.  Dynamic configuration of resource-aware services , 2004, Proceedings. 26th International Conference on Software Engineering.

[16]  Jay Ramachandran,et al.  Designing Security Architecture Solutions , 2002 .

[17]  George Candea,et al.  Microreboot - A Technique for Cheap Recovery , 2004, OSDI.

[18]  Emil C. Lupu,et al.  Security and management policy specification , 2002, IEEE Netw..

[19]  Mary Shaw,et al.  Tailoring configuration to user's tasks under uncertainty , 2008 .

[20]  T. Longstaff,et al.  Quality Attributes , 1995 .

[21]  Richard N. Taylor,et al.  Towards architecture-based self-healing systems , 2002, WOSS '02.

[22]  Joefon Jann,et al.  Dynamic reconfiguration: Basic building blocks for autonomic computing on IBM pSeries servers , 2003, IBM Syst. J..

[23]  Gregory D. Abowd,et al.  Using style to understand descriptions of software architecture , 1993, SIGSOFT '93.

[24]  George T. Heineman A model for designing adaptable software components , 1998, Proceedings. The Twenty-Second Annual International Computer Software and Applications Conference (Compsac '98) (Cat. No.98CB 36241).

[25]  Richard N. Taylor,et al.  A Component- and Message-Based Architectural Style for GUI Software , 1995, 1995 17th International Conference on Software Engineering.

[26]  Hong Yan,et al.  DiscoTect: a system for discovering architectures from running systems , 2004, Proceedings. 26th International Conference on Software Engineering.

[27]  Priya Narasimhan,et al.  Using Interceptors to Enhance CORBA , 1999, Computer.

[28]  John Gersh,et al.  Goal-Based Operations: An Overview , 2007 .

[29]  David Garlan,et al.  Rapid development of custom software architecture design environments , 1999 .

[30]  Steve Vestal,et al.  Using an architecture description language for quantitative analysis of real-time systems , 2002, WOSP '02.

[31]  Bradley R. Schmerl,et al.  Software architecture-based adaptation for Grid computing , 2002, Proceedings 11th IEEE International Symposium on High Performance Distributed Computing.

[32]  Don W. Green,et al.  Perry's chemical engineers' handbook. 7th ed. , 1997 .

[33]  Edsger W. Dijkstra,et al.  Guarded commands, non-determinacy and a calculus for the derivation of programs , 1975, Language Hierarchies and Interfaces.

[34]  Christopher D. Gill,et al.  Comparing and contrasting adaptive middleware support in wide-area and embedded distributed object applications , 2001, Proceedings 21st International Conference on Distributed Computing Systems.

[35]  Tori Kensington 2:00 AM , 1988 .

[36]  D. Barrios-Aranibar,et al.  LEARNING FROM DELAYED REWARDS USING INFLUENCE VALUES APPLIED TO COORDINATION IN MULTI-AGENT SYSTEMS , 2007 .

[37]  Flávio Oquendo,et al.  An Active Architecture Approach to Dynamic Systems Co-evolution , 2007, ECSA.

[38]  Mary Shaw,et al.  Software architecture - perspectives on an emerging discipline , 1996 .

[39]  Paul Clements,et al.  Software product lines - practices and patterns , 2001, SEI series in software engineering.

[40]  Marija Mikic-Rakic,et al.  Architectural style requirements for self-healing systems , 2002, WOSS '02.

[41]  David Garlan,et al.  Compositional transformation of software connectors , 2004 .

[42]  David Garlan,et al.  Scaling task management in space and time: reducing user overhead in ubiquitous-computing environments , 2005 .

[43]  Jim Dowling,et al.  The K-Component Architecture Meta-model for Self-Adaptive Software , 2001, Reflection.

[44]  Peyman Oreizy,et al.  Self-Adaptive Software: An Architecture-based Approach , 1999 .

[45]  Thomas A. Corbi,et al.  The dawning of the autonomic computing era , 2003, IBM Syst. J..

[46]  Sandeep S. Kulkarni,et al.  Mixed-Mode Adaptation in Distributed Systems: A Case Study , 2007, International Workshop on Software Engineering for Adaptive and Self-Managing Systems (SEAMS '07).

[47]  Bradley R. Schmerl,et al.  An architecture for coordinating multiple self-management systems , 2004, Proceedings. Fourth Working IEEE/IFIP Conference on Software Architecture (WICSA 2004).

[48]  Klaus Meißner,et al.  Adaptation and Distribution of Pipeline-Based Context-Aware Web Architectures , 2007, 2007 Working IEEE/IFIP Conference on Software Architecture (WICSA'07).

[49]  Paul Clements,et al.  Software architecture in practice , 1999, SEI series in software engineering.

[50]  Jürgen Dingel,et al.  A survey of self-management in dynamic software architecture specifications , 2004, WOSS '04.

[51]  Alexandre Sztajnberg,et al.  Describing and Deploying Self-Adaptive Applications , 2006 .

[52]  B. J. Ferro Castro,et al.  Pattern-Oriented Software Architecture: A System of Patterns , 2009 .

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

[54]  Volker Markl,et al.  LEO: An autonomic query optimizer for DB2 , 2003, IBM Syst. J..

[55]  David Garlan,et al.  Aura: an Architectural Framework for User Mobility in Ubiquitous Computing Environments , 2002, WICSA.

[56]  Chris Watkins,et al.  Learning from delayed rewards , 1989 .

[57]  Peter Steenkiste,et al.  Building self-configuring services using service-specific knowledge , 2004, Proceedings. 13th IEEE International Symposium on High performance Distributed Computing, 2004..

[58]  Emil C. Lupu,et al.  The Ponder Policy Specification Language , 2001, POLICY.

[59]  Marius Mikalsen,et al.  Distributed context management in a mobility and adaptation enabling middleware (MADAM) , 2006, SAC '06.

[60]  Yixin Diao,et al.  Feedback Control of Computing Systems , 2004 .

[61]  Gail E. Kaiser,et al.  A case study in software adaptation , 2002, WOSS '02.

[62]  Michael Gertz,et al.  THE WILLOW SURVIVABILITY ARCHITECTURE , 2001 .

[63]  C. Chambers,et al.  ArchJava: connecting software architecture to implementation , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[64]  Nenad Medvidovic,et al.  Composing architectural styles from architectural primitives , 2003, ESEC/FSE-11.

[65]  Timothy W. Curry,et al.  Profiling and Tracing Dynamic Library Usage Via Interposition , 1994, USENIX Summer.

[66]  P. Pazandak,et al.  ProbeMeister Distributed Runtime Software Instrumentation , 2002 .

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

[68]  Dean Sutherland,et al.  The architecture of the Remos system , 2001, Proceedings 10th IEEE International Symposium on High Performance Distributed Computing.

[69]  Gail E. Kaiser,et al.  An Active Events Model for Systems Monitoring , 2001 .

[70]  Erann Gat The MDS autonomous control architecture , 2000 .

[71]  David Garlan,et al.  Analyzing architectural styles with alloy , 2006, ROSATEA '06.

[72]  Luiz André Barroso,et al.  Web Search for a Planet: The Google Cluster Architecture , 2003, IEEE Micro.

[73]  John A. Bather,et al.  Decision Theory: An Introduction to Dynamic Programming and Sequential Decisions , 2000 .

[74]  Bradley R. Schmerl,et al.  AcmeStudio: supporting style-centered architecture development , 2004, Proceedings. 26th International Conference on Software Engineering.

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

[76]  Manuela M. Veloso,et al.  FLECS: Planning with a Flexible Commitment Strategy , 1995, J. Artif. Intell. Res..

[77]  Thomas F. Edgar,et al.  Process Dynamics and Control , 1989 .

[78]  K. Mani Chandy,et al.  Computer Systems Performance Modeling , 1981 .

[79]  Bradley R. Schmerl,et al.  Increasing System Dependability through Architecture-Based Self-Repair , 2002, WADS.

[80]  Martin Glinz,et al.  A framework for dynamically adaptive applications in a self-organized mobile network environment , 2004, 24th International Conference on Distributed Computing Systems Workshops, 2004. Proceedings..

[81]  Nathan Combs,et al.  Adaptive mirroring of system of systems architectures , 2002, WOSS '02.

[82]  R. Bellman,et al.  Dynamic Programming and Markov Processes , 1960 .

[83]  David Garlan,et al.  Architecture-Based Performance Analysis , 1998 .

[84]  Michael M. Gorlick,et al.  Using weaves for software construction and analysis , 1991, [1991 Proceedings] 13th International Conference on Software Engineering.

[85]  David Garlan,et al.  A Formal Approach to Software Architectures , 1992, IFIP Congress.

[86]  Peyman Oreizy,et al.  An architecture-based approach to self-adaptive software , 1999, IEEE Intell. Syst..

[87]  Gregory D. Abowd,et al.  Formalizing style to understand descriptions of software architecture , 1995, TSEM.

[88]  David Garlan,et al.  Architectural Styles, Design Patterns, And Objects , 1997, IEEE Softw..

[89]  Peyman Oreizy,et al.  Open architecture software: a flexible approach to decentralized software evolution , 2000 .

[90]  Leonard J. Bass,et al.  Designing software architectures to achieve quality attribute requirements , 2005, IEE Proc. Softw..

[91]  David S. Rosenblum,et al.  Design and evaluation of a wide-area event notification service , 2001, TOCS.

[92]  Steve Vestal,et al.  Improving Predictability in Embedded Real-Time Systems , 2000 .

[93]  Daniel Le Métayer Describing Software Architecture Styles Using Graph Grammars , 1998, IEEE Trans. Software Eng..

[94]  Spike Cramphorn Blink: The Power of Thinking without Thinking / Strangers to Ourselves: Discovering the Adaptive Unconscious , 2006, Journal of Advertising Research.

[95]  Mary Shaw,et al.  Beyond objects: a software design paradigm based on process control , 1995, SOEN.

[96]  Alexander L. Wolf,et al.  Acm Sigsoft Software Engineering Notes Vol 17 No 4 Foundations for the Study of Software Architecture , 2022 .

[97]  Edward D. Lazowska,et al.  Quantitative system performance - computer system analysis using queueing network models , 1983, Int. CMG Conference.

[98]  Mahadev Satyanarayanan,et al.  Balancing performance, energy, and quality in pervasive computing , 2002, Proceedings 22nd International Conference on Distributed Computing Systems.

[99]  Paul Clements,et al.  ATAM: Method for Architecture Evaluation , 2000 .

[100]  Priya Narasimhan,et al.  Strongly consistent replication and recovery of fault-tolerant CORBA applications , 2002, Comput. Syst. Sci. Eng..

[101]  Peter Norvig,et al.  Artificial Intelligence: A Modern Approach , 1995 .

[102]  Michel Wermelinger,et al.  A graph based architectural (Re)configuration language , 2001, ESEC/FSE-9.

[103]  Naranker Dulay,et al.  Specifying Distributed Software Architectures , 1995, ESEC.

[104]  Paul C. Clements,et al.  A survey of architecture description languages , 1996, Proceedings of the 8th International Workshop on Software Specification and Design.

[105]  David Garlan,et al.  Using Gauges for Architecture-Based Monitoring and Adaptation , 2001 .

[106]  Emil C. Lupu,et al.  A policy deployment model for the Ponder language , 2001, 2001 IEEE/IFIP International Symposium on Integrated Network Management Proceedings. Integrated Network Management VII. Integrated Management Strategies for the New Millennium (Cat. No.01EX470).

[107]  Debanjan Ghosh,et al.  Self-healing systems - survey and synthesis , 2007, Decis. Support Syst..

[108]  Michel D. Ingham,et al.  Goal-Based Operations: An Overview , 2007, J. Aerosp. Comput. Inf. Commun..

[109]  Mahadev Satyanarayanan,et al.  Multi-fidelity algorithms for interactive mobile applications , 1999, DIALM '99.

[110]  Ian Gorton,et al.  Implementing Adaptive Performance Management in Server Applications , 2007, International Workshop on Software Engineering for Adaptive and Self-Managing Systems (SEAMS '07).

[111]  David J. Goodman,et al.  Personal Communications , 1994, Mobile Communications.

[112]  Leonard J. Bass,et al.  Linking usability to software architecture patterns through general scenarios , 2003, J. Syst. Softw..