Design and Performance Guarantees in Cloud Computing: Challenges and Opportunities

In the last years, cloud computing received an increasing attention both from academia and industry. Most of the solutions proposed in the literature strive to limit the effect of uncertain and unpredictable behaviors that may occur in cloud environments, like for example flash crowds or hardware failures. However, managing uncertainty in a cloud environment is still an open problem. In such a panorama, the service provider is not able to define suitable Service Level Objectives (SLO) that are easy to measure, and control. In this work we analyze two of the critical problems that are encountered in cloud environments, but seldom discussed or addressed in the literature: (1) how to reduce the uncertainty providing suitable control interfaces at different levels of the computing infrastructure; (2) how to assess performance evaluation in order to get probabilistic guarantees for the SLOs. We here briefly describe the two problems and envision some possible control-theoretical solutions

Lightweight adaptive filtering for efficient learning and updating of probabilistic models

Adaptive software systems are designed to cope with unpredictable and evolving usage behaviors and environmental conditions. For these systems reasoning mechanisms are needed to drive evolution, which are usually based on models capturing relevant aspects of the running software. The continuous update of these models in evolving environments requires efficient learning procedures, having low overhead and being robust to changes. Most of the available approaches achieve one of these goals at the price of the other. In this paper we propose a lightweight adaptive filter to accurately learn time-varying transition probabilities of discrete time Markov models, which provides robustness to noise and fast adaptation to changes with a very low overhead. A formal stability, unbiasedness and consistency assessment of the learning approach is provided, as well as an experimental comparison with state-of-the-art alternatives

A hybrid approach combining control theory and AI for engineering self-adaptive systems

Control theoretical techniques have been successfully adopted as methods for self-adaptive systems design to provide formal guarantees about the effectiveness and robustness of adaptation mechanisms. However, the computational effort to obtain guarantees poses severe constraints when it comes to dynamic adaptation. In order to solve these limitations, in this paper, we propose a hybrid approach combining software engineering, control theory, and AI to design for software self-adaptation. Our solution proposes a hierarchical and dynamic system manager with performance tuning. Due to the gap between high-level requirements specification and the internal knob behavior of the managed system, a hierarchically composed components architecture seek the separation of concerns towards a dynamic solution. Therefore, a two-layered adaptive manager was designed to satisfy the software requirements with parameters optimization through regression analysis and evolutionary meta-heuristic. The optimization relies on the collection and processing of performance, effectiveness, and robustness metrics w.r.t control theoretical metrics at the offline and online stages. We evaluate our work with a prototype of the Body Sensor Network (BSN) in the healthcare domain, which is largely used as a demonstrator by the community. The BSN was implemented under the Robot Operating System (ROS) architecture, and concerns about the system dependability are taken as adaptation goals. Our results reinforce the necessity of performing well on such a safety-critical domain and contribute with substantial evidence on how hybrid approaches that combine control and AI-based techniques for engineering self-adaptive systems can provide effective adaptation

Autotuning control structures for reliability-driven dynamic binding

Abstract-This paper explores a formally grounded approach to solve the problem of dynamic binding in serviceoriented software architecture. Dynamic binding is a widely adopted mean to automatically bind exposed software interfaces to actual implementations. The execution of an operation on one or another implementation, though providing the same result, could turn out in different quality of service, e.g. due to failure occurrence. Dynamic binding is thus of primary importance to achieve what in the Software Engineering domain is called "selfadaptiveness", the capability to preserve a desired quality of service, if this is feasible. It is important to reach this goal also in the presence of environmental fluctuations -a route congestion increase -or even abrupt variations -a server breakdown. A quite general dynamic binding problem is here reformulated as a discrete-time feedback control one, and the use of autotuning techniques is discussed, extending previous research, in a view to guaranteeing the desired quality of service without the need for computationally-intensive optimisations

Supporting self-adaptation via quantitative verification and sensitivity analysis at run time

Modern software-intensive systems often interact with an environment whose behavior changes over time, often unpredictably. The occurrence of changes may jeopardize their ability to meet the desired requirements. It is therefore desirable to design software in a way that it can self-adapt to the occurrence of changes with limited, or even without, human intervention. Self-adaptation can be achieved by bringing software models and model checking to run time, to support perpetual automatic reasoning about changes. Once a change is detected, the system itself can predict if requirements violations may occur and enable appropriate counter-actions. However, existing mainstream model checking techniques and tools were not conceived for run-time usage; hence they hardly meet the constraints imposed by on-the-fly analysis in terms of execution time and memory usage. This paper addresses this issue and focuses on perpetual satisfaction of non-functional requirements, such as reliability or energy consumption. Its main contribution is the description of a mathematical framework for run-time efficient probabilistic model checking. Our approach statically generates a set of verification conditions that can be efficiently evaluated at run time as soon as changes occur. The proposed approach also supports sensitivity analysis, which enables reasoning about the effects of changes and can drive effective adaptation strategies

A framework for robust control of uncertainty in self-adaptive software connectors

Context and motivations. The desired behavior of a system in ubiquitous environments considers not only its correct functionality, but also the satisfaction of its non-functional properties, i.e., its quality of service. Given the heterogeneity and dynamism characterizing the ubiquitous environments and the need for continuous satisfaction of non-functional properties, self-adaptive solutions appear to be an appropriate approach to achieve interoperability. In this work, self-adaptation is adopted to enable software connectors to adapt the interaction protocols run by the connected components to let them communicate in a timely manner and with the required level of quality. However, this self-adaptation should be dependable, reliable and resilient to be adopted in dynamic, unpredictable environments with different sources of uncertainty. The majority of current approaches for the construction of self-adaptive software ignore the uncertainty underlying non-functional requirement verification and adaptation reasoning. Consequently, these approaches jeopardize system reliability and hinder the adoption of self-adaptive software in areas where dependability is of utmost importance. Objective. The main objective of this research is to properly handle the uncertainties in the non-functional requirement verification and the adaptation reasoning part of the self-adaptive feedback control loop of software connectors. This will enable a robust and runtime efficient adaptation in software connectors and make them reliable for usage in uncertain environments. Method. In the context of this thesis, a framework has been developed with the following functionalities: 1) Robust control of uncertainty in runtime requirement verification. The main activity in runtime verification is fine-tuning of the models that are adopted for runtime reasoning. The proposed stochastic approach is able to update the unknown parameters of the models at runtime even in the presence of incomplete and noisy observations. 2) Robust control of uncertainty in adaptation reasoning. A general methodology based on type-2 fuzzy logic has been introduced for the control of adaptation decision-making that adjusts the configuration of component connectors to the appropriate mode. The methodology enables a systematic development of fuzzy logic controllers that can derive the right mode for connectors even in the presence of measurement inaccuracy and adaptation policy conflicts. Results. The proposed model evolution mechanism is empirically evaluated, showing a significant precision of parameter estimation with an acceptable overhead at runtime. In addition, the fuzzy based controller, generated by the methodology, has been shown to be robust against uncertainties in the input data, efficient in terms of runtime overhead even in large-scale knowledge bases and stable in terms of control theory properties. We also demonstrate the applicability of the developed framework in a real-world domain. Thesis statement. We enable reliable and dependable self-adaptations of component connectors in unreliable environments with imperfect monitoring facilities and conflicting user opinions about adaptation policies by developing a framework which comprises: (a) mechanisms for robust model evolution, (b) a method for adaptation reasoning, and (c) tool support that allows an end-to-end application of the developed techniques in real-world domains

Reliability-driven Dynamic Binding via Feedback Control

We are concerned with software that can self-adapt to satisfy certain reliability requirements, in spite of adverse changes affecting the environment in which it is embedded. Self-adapting software architectures are heavily based on dynamic binding. The bindings among components are dynamically set as the conditions that require a self-adaptation are discovered during the system’s lifetime. By adopting a suitable modeling approach, the dynamic binding problem can be formulated as a discrete-time feedback control problem, and solved with very simple techniques based on linear blocks. Doing so, reliability objectives are in turn formulated as set point tracking ones in the presence of disturbances, and attained without the need for optimization. At design time, the proposed formulation has the advantage of naturally providing system sizing clues, while at operation time, the inherent computational simplicity of the obtained controllers results in a low overhead. Finally, the formulation allows for a rigorous assessment of the achieved results in both nominal and off-design conditions for any desired operation point