Auxo: an architecture-centric framework supporting the online tuning of software adaptivity
Science China Information Sciences
Adaptivity is the capacity of software to adjust itself to changes in its environment. A common approach to achieving adaptivity is to introduce dedicated code during software development stage. However, since those code fragments are designed a priori, self-adaptive software cannot handle situations adequately when the contextual changes go beyond those that are originally anticipated. In this case, the original builtin adaptivity should be tuned. For example, new code should be added to
... e the capacity to sense the unexpected environment or to replace outdated adaptation decision logic. The technical challenges in this process, especially that of tuning software adaptivity at runtime, cannot be understated. In this paper, we propose an architecture-centric application framework for self-adaptive software named Auxo. Similar to existing work, our framework supports the development and running of self-adaptive software. Furthermore, our framework supports the tuning of software adaptivity without requiring the running self-adaptive software to be terminated. In short, the architecture style that we are introducing can encapsulate not only general functional logic but also the concerns in the self-adaptation loop (such as sensing, decision, and execution) as architecture elements. As a result, a third party, potentially the operator or an augmented software entity equipped with explicit domain knowledge, is able to dynamically and flexibly adjust the self-adaptation concerns through modifying the runtime software architecture. To truly exercise, validate, and evaluate our approach, we describe a self-adaptive application that was deployed on the framework, and conducted several experiments involving self-adaptation and the online tuning of software adaptivity. Citation Wang H M, Ding B, Shi D X, et al. Auxo: an architecture-centric framework supporting the online tuning of software adaptivity. Sci China Inf Sci, 2015, 58: 092103(15), trend has given rise to active research and development in the area of software adaptation     , with the aim of coming up with software that will adjust its behavior in response to changes in the environment. A common approach in software engineering to achieve this goal is to introduce dedicated code during the software development stage, including code to detect environmental changes (sensing), code to guide adaptation decisions (decision), and code to adjust its business behavior accordingly (execution). By building such a "sensing-decision-execution" self-adaptation loop [7, 8] , the software is equipped with adaptivity, i.e., the capacity to adjust itself to changes in the environment. However, since the "sensing-decision-execution" loop is designed a priori in the development stage, self-adaptive software may not be able to handle the situation adequately if the running environment goes beyond what was originally anticipated. This phenomenon is becoming increasingly probable in many "open-world" settings , such as long-life systems in which the designer's cognition is inevitably limited, or in the case of cyber-physical systems  that are tightly coupled with the real world. In order to cope with an unexpected environment, the original adaptivity in self-adaptive software requires tuning. For example, new code can be added to provide sensing of new contextual environments or to replace outdated adaptation logic (i.e., code to guide adaptation decisions  ). For systems that require continuous availability, it is critically important that this kind of adjustment be executable on-the-fly. We name this kind of online adjustment of the self-adaptation loop as the online tuning of software adaptivity. In this paper, we propose an application framework named Auxo, which supports both self-adaptation and the online tuning of software adaptivity. Similar to existing frameworks such as [11, 12] , our framework can support the construction and running of self-adaptive software. Moreover, our framework can support a third party to dynamically adjust each concern (i.e., sensing, decision, and execution) in the selfadaptation loop, to enable the running self-adaptive software to cope with unanticipated environments. Our approach is based on the software architecture technology  . It mainly consists of two parts: the Auxo architecture style and the Auxo runtime infrastructure. Similar to other architecture-based approaches, our architecture style captures the structure and organization of the functional logic while providing intrinsic support for its adaptation. Importantly, the Auxo architecture style can also model the concerns in the self-adaptation loop. For example, a sensor and its associated data can be abstracted as a component of a special kind, while the adaptation logic can be encapsulated as connectors of a special kind. During runtime, the software can perform architecture-based self-adaptation according to its predefined adaptivity with the support of the runtime infrastructure. Meantime, a third party can selectively modify the architecture model to make changes to the self-adaptation loop, such as composing a specific component to detect an unanticipated contextual environment or replacing a specific connector to update a piece of adaptation logic. In addition, by abstracting software on an established architectural model, our infrastructure provides the foundational means to systematically evaluate architecture constraints, which can be used to guard against inappropriate adaptivity-tuning actions. The main contributions of this paper include: (1) Describing and highlighting the challenges to the online tuning of software adaptivity. (2) Proposing an architecture-centric framework that concurrently supports self-adaptation and the online tuning of software adaptivity. (3) Validating our approach with a performance analysis based on two case studies and a real-life application. The rest of this paper is organized as follows. A further introduction to the research background is given in Section 2. Our framework is presented in Sections 3-5, with the architecture style presented in Section 3, the runtime infrastructure presented in Section 4, and those concepts reinforced in Section 5 by illustrating how selfadaptation and the online tuning of software adaptivity is realized. The case example and the evaluation results are presented in Section 6. In Section 7 our work is compared to related work. Research background This section begins with the presentation of a motivated scenario being extracted from a real-life cloud computing application. Subsequently, we give an overview of the technical foundation of our research, i.e., the runtime software architecture.