Model-Driven Architectural Monitoring and Adaptation for Autonomic Systems

05/17/2018 ∙ by Thomas Vogel, et al. ∙ 0

Architectural monitoring and adaptation allows self-management capabilities of autonomic systems to realize more powerful adaptation steps, which observe and adjust not only parameters but also the software architecture. However, monitoring as well as adaptation of the architecture of a running system in addition to the parameters are considerably more complex and only rather limited and costly solutions are available today. In this paper we propose a model-driven approach to ease the development of architectural monitoring and adaptation for autonomic systems. Using meta models and model transformation techniques, we were able to realize an incremental synchronization between the run-time system and models for different self-management activities. The synchronization might be triggered when needed and therefore the activities can operate concurrently.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Software has to be frequently adapted to changes in the environment to keep its value for the user [11]. Software can be adapted by modifying program variables (parameter adaptation) or by exchanging algorithmic or structural system components (compositional adaptation) possibly changing the software architecture [12]. Continuous adaptations are impeded by the complexity of today’s software systems. The vision of Autonomic Computing (AC) approaches this problem by borrowing the concept of control loops, which originates from the domain of control engineering, and adapting it to suit business computing by self-management capabilities such as self-configuration, self-healing, self-optimization and self-protection [9]. Most of the work on AC employs parameter adaptation and therefore can employ well understood control engineering techniques [8]. For some systems this is sufficient, but sometimes compositional adaptations have to be employed to achieve the needed self-management goals [10]. Therefore, each capability requires its own corresponding abstract view on a managed software system that reflects the run-time state of a system regarding architectural components, links and parameters as far as they are relevant for the capability. These views should be provided by models. While there are many examples for the benefits of adapting architectures at run-time (cf. [5, 13, 16]), the model-driven development using meta-models of the architecture or other elements of autonomic systems such as policies has only recently found more attention [2, 14, 17]. The focus of these model-driven approaches is to exploit models for facilitating control loop activities. In this context, only first ideas to use model transformation techniques exist [1, 15], but no efficient solution working online has been presented so far.

In this paper we propose a model-driven approach to ease the development of architectural monitoring and adaptation for autonomic systems. By employing model-driven engineering techniques and our optimized model transformation technique [6, 7] the run-time system and several models aiming at different self-management capabilities are synchronized online and incrementally. The approach has been evaluated by means of an example implementation for Enterprise Java Beans [4], which supports only the monitoring part yet. It considers performance monitoring, architectural constraints checking and failure monitoring. The next section outlines our model-driven approach and the implementation, which is followed by a conclusion and an outlook on future work.

2 Approach

Our approach combines Model-driven Engineering (MDE) and the vision of autonomic computing. MDE techniques are employed to provide models describing different views on a managed software systems for different control loops being concerned with a certain self-management capability. The generic architecture of our approach is depicted in Figure 1. It extends the control loop as proposed in [12] by introducing models as the interface between Autonomic Managers and the Managed Element.

Figure 1: Generic Architecture

Sensors and Effectors provide a model-based view on a managed system in the form of a Source Model that can be used for monitoring or adapting the system at run-time. A source model represents all capabilities of sensors and effectors. Consequently, a source model might be quite complex, which makes it laborious to use it as a basis for autonomic managers implementing the control loop activities monitoring, analysis, planning and execution. Thus, we propose using model transformation techniques to derive several Target Models at run-time. Each target model raises the level of abstraction w.r.t. the source model and it provides a specific view on the software system required for an autonomic manager focusing on a certain self-management capability. E.g., a manager being concerned with self-optimization uses only those specific models that describe the resource utilization and performance attributes of a system, but does not have to consider views that are covered by other managers focusing on self-healing or self-protection. Consequently, several autonomic managers work on possibly different target models as depicted at the top of Figure 1.

The different target models are maintained by our generic Model Transformation Engine being based on Triple Graph Grammars (TGG) [6, 7]. Source and target models are causally connected, i.e., changes in a source model are reflected in target models (monitoring) and vice versa (adaptation). This is possible due to the bidirectional transformation and synchronization capabilities of TGGs present in our engine, which work incrementally facilitating an efficient application at run-time. How two models have to be synchronized is specified declaritvely by TGG Rules at the level of Meta Models for the source and target models. Hence, the rules are independent of concrete models. Synchronization between source and target models can be triggered on demand enabling concurrent operations of managers and the decoupling of target models from a source model to ensure consistent analysis or to transfer several target model changes to the source model atomically.

The implementation of our approach currently covers the monitoring capabilities. It is based on sensors the AC infrastructure mKernel [3] provides for monitoring systems being realized with Enterprise Java Beans 3.0 (EJB) [4] technology. Based on the capabilities of these sensors, we developed a meta model for the EJB domain that defines the source model. For target models we developed three meta models and the required TGG rules covering the architecture, performance and failure states, which aim at autonomic managers being concerned with self-configuration, self-optimization, and self-healing, respectively. Our model transformation engine implementation and all meta models are based on the Eclipse Modeling Framework. However, the whole infrastructure can run decoupled from the Eclipse workbench.

3 Conclusion & Future Work

We have presented an approach to support the architectural monitoring and adaptation by using meta models and model transformation techniques that operate efficiently and online and that can address different self-management capabilities. As our current solution fully automates the monitoring of a system, we plan to cover the adaptation of architectures and to investigate the degree of automation for adaptations.

References

  • [1] B. Becker and H. Giese. Modeling of correct self-adaptive systems: A graph transformation system based approach. In Proc. of the 5th Intl. Conference on Soft Computing as Transdisciplinary Science and Technology, pages 508 – 516. ACM Press, Oct. 2008.
  • [2] L. Broto, D. Hagimont, E. Annoni, B. Combemale, and J.-P. Bahsoun. Towards a model driven autonomic management system. Information Technology: New Generations, Third International Conference on, 0:63–69, 2008.
  • [3] J. Bruhn, C. Niklaus, T. Vogel, and G. Wirtz. Comprehensive support for management of Enterprise Applications. In Proc. of the 6th ACS/IEEE International Conference on Computer Systems and Applications, pages 755–762. IEEE, March 2008.
  • [4] L. DeMichiel and M. Keith. JSR 220: Enterprise JavaBeans, Version 3.0: EJB Core Contracts and Requirements. 2006.
  • [5] D. Garlan, S.-W. Cheng, A.-C. Huang, B. Schmerl, and P. Steenkiste. Rainbow: Architecture-Based Self-Adaptation with Reusable Infrastructure. Computer, 37(10):46–54, 2004.
  • [6] H. Giese and S. Hildebrandt. Incremental Model Synchronization for Multiple Updates. In Proc. of the 3rd International Workshop on Graph and Model Transformation. ACM Press, May 2008.
  • [7] H. Giese and R. Wagner. From model transformation to incremental bidirectional model synchronization. Software and Systems Modeling, 8(1), 28 March 2009.
  • [8] J. Hellerstein, Y. Diao, S. Parekh, and D. Tilbury. Control engineering for computing systems - industry experience and research challenges. Control Systems Magazine, IEEE, 25(6):56–68, 2005.
  • [9] J. O. Kephart and D. M. Chess. The Vision of Autonomic Computing. IEEE Computer, 36(1):41–50, January 2003.
  • [10] J. Kramer and J. Magee. Self-Managed Systems: an Architectural Challenge. In Proc. of the Workshop on the Future of Software Engineering, pages 259–268. IEEE, 2007.
  • [11] M. M. Lehman. Software’s Future: Managing Evolution. IEEE Software, 15(01):40–44, 1998.
  • [12] P. K. McKinley, S. M. Sadjadi, E. P. Kasten, and B. H. C. Cheng. Composing Adaptive Software. IEEE Computer, 37(7), July 2004.
  • [13] P. Oreizy, M. M. Gorlick, R. Taylor, D. Heimbigner, G. Johnson, N. Medvidovic, A. Quilici, D. S. Rosenblum, and A. L. Wolf. An Architecture-Based Approach to Self-Adaptive Software. IEEE Intelligent Systems, 14(3):54–62, June 1999.
  • [14] B. Solomon, D. Ionescu, M. Litoiu, and M. Mihaescu. Model-driven engineering for autonomic provisioned systems. In Proc. of the 32nd Annual IEEE International Computer Software and Applications Conference, pages 1110–1115. IEEE, 2008.
  • [15] H. Song, Y. Xiong, Z. Hu, G. Huang, and H. Mei. A model-driven framework for constructing runtime architecture infrastructures. Technical Report GRACE-TR-2008-05, GRACE Center, National Institute of Informatics, Dec. 2008.
  • [16] J. Yang, G. Huang, W. Zhu, X. Cui, and H. Mei. Quality attribute tradeoff through adaptive architectures at runtime. Journal of Systems and Software, 82(2):319 – 332, 2009.
  • [17] J. Zhang and B. H. C. Cheng. Model-based development of dynamically adaptive software. In Proc. of the 28th International Conference on Software Engineering, pages 371–380. ACM Press, 2006.