Ensuring the Consistency of Adaptation through Inter- and Intra-Component Dependency Analysis

Dynamic adaptation should not leave a software system in an inconsistent state, as it could lead to failure. Prior research has used inter-component dependency models of a system to determine a safe interval for the adaptation of its components, where the most important tradeoff is between disruption in the operations of the system and reachability of safe intervals. This article presents Savasana, which automatically analyzes a software system’s code to extract both inter- and intra-component dependencies. In this way, Savasana is able to obtain more fine-grained models compared to previous approaches. Savasana then uses the detailed models to find safe adaptation intervals that cannot be determined using techniques from prior research. This allows Savasana to achieve a better tradeoff between disruption and reachability. The article demonstrates how Savasana infers safe adaptation intervals for components of a software system under various use cases and conditions.

[1]  José María Sierra,et al.  LAPSE+ Static Analysis Security Software: Vulnerabilities Detection in Java EE Applications , 2011 .

[2]  Deepak Gupta,et al.  On‐line software version change using state transfer between processes , 1993, Softw. Pract. Exp..

[3]  Hassan Gomaa,et al.  Software reconfiguration patterns for dynamic evolution of software architectures , 2004, Proceedings. Fourth Working IEEE/IFIP Conference on Software Architecture (WICSA 2004).

[4]  Sam Malek,et al.  Automated mining of software component interactions for self-adaptation , 2014, SEAMS 2014.

[5]  Sam Malek,et al.  A user-centric approach for improving a distributed software system's deployment architecture , 2007 .

[6]  Theo D'Hondt,et al.  Tranquility: A Low Disruptive Alternative to Quiescence for Ensuring Safe Dynamic Updates , 2007, IEEE Transactions on Software Engineering.

[7]  Luciano Baresi,et al.  Version-consistent dynamic reconfiguration of component-based distributed systems , 2011, ESEC/FSE '11.

[8]  Jeffrey S. Foster,et al.  Kitsune: efficient, general-purpose dynamic software updating for C , 2012, OOPSLA '12.

[9]  Michael Hicks,et al.  Rubah: Efficient, General-purpose Dynamic Software Updating for Java , 2013, HotSWUp.

[10]  Joseph Robert Horgan,et al.  Fault localization using execution slices and dataflow tests , 1995, Proceedings of Sixth International Symposium on Software Reliability Engineering. ISSRE'95.

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

[12]  Patrick Cousot,et al.  A static analyzer for large safety-critical software , 2003, PLDI.

[13]  Carlo Ghezzi,et al.  Formalizing correctness criteria of dynamic updates derived from specification changes , 2013, 2013 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS).

[14]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

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

[16]  Sam Malek,et al.  Inferring Software Component Interaction Dependencies for Adaptation Support , 2016, ACM Trans. Auton. Adapt. Syst..

[17]  Mary Lou Soffa,et al.  Efficient computation of interprocedural definition-use chains , 1994, TOPL.

[18]  Anas N. Al-Rabadi,et al.  A comparison of modified reconstructability analysis and Ashenhurst‐Curtis decomposition of Boolean functions , 2004 .

[19]  Laurie Hendren,et al.  Soot: a Java bytecode optimization framework , 2010, CASCON.

[20]  John N. Tsitsiklis,et al.  Introduction to Probability , 2002 .

[21]  Rod Johnson,et al.  Professional Java Development with the Spring Framework , 2005 .

[22]  Andres J. Ramirez,et al.  Design patterns for developing dynamically adaptive systems , 2010, SEAMS '10.

[23]  Sam Malek,et al.  Utilizing architectural styles to enhance the adaptation support of middleware platforms , 2012, Inf. Softw. Technol..

[24]  Deepak Gupta,et al.  A Formal Framework for On-line Software Version Change , 1996, IEEE Trans. Software Eng..

[25]  Michael Hicks,et al.  Contextual effects for version-consistent dynamic software updating and safe concurrent programming , 2008, POPL '08.

[26]  Sam Malek,et al.  On the Role of Architectural Styles in Improving the Adaptation Support of Middleware Platforms , 2010, ECSA.

[27]  Scott Nettles,et al.  Dynamic software updating , 2001, PLDI '01.

[28]  John Howard,et al.  Hybrid slicing: integrating dynamic information with static analysis , 1997, TSEM.

[29]  Sam Malek,et al.  Mining the execution history of a software system to infer the best time for its adaptation , 2012, SIGSOFT FSE.

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

[31]  Marija Mikic-Rakic,et al.  A style-aware architectural middleware for resource-constrained, distributed systems , 2005, IEEE Transactions on Software Engineering.

[32]  Jeff Magee,et al.  The Evolving Philosophers Problem: Dynamic Change Management , 1990, IEEE Trans. Software Eng..

[33]  David W. Binkley,et al.  Source Code Analysis: A Road Map , 2007, Future of Software Engineering (FOSE '07).

[34]  Carlo Ghezzi,et al.  Synthesizing dynamically updating controllers from changes in scenario-based specifications , 2012, 2012 7th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS).

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