Currently, paradigms such as component-based software development and service-oriented software architectures promote modularization of software systems into highly decoupled and reusable software components and services. In addition, to improve manageability and evolveability, software systems are extended with management capabilities and self-managed behavior. Because of their very nature, these self-managed software systems often are mission critical and highly available. In this paper, we focus on the complexity of preserving correctness in modularized self-managed systems. We discuss the importance of consistent software compositions in the context of self-managed systems, and the need for a correctness-preserving adaptation process. We also give a flavor of possible approaches for preserving correctness, and conclude with some remarks and open questions.
Traditionally, software models are associated with development and maintenance related activities. This paper demonstrates that models also serve a vital purpose in supporting the self awareness and management of software systems in their deployed environments. We use probes to observe the executing software system by extracting the outside stimuli the system is subjected to. We use this information to concurrently simulate the model-behavior of the software system. The state of the simulating system then mirrors the state of the executing system. In this setting, the simulation serves as a foundation to self awareness through which differences among simulated behavior and real behavior are investigated. The simulation also serves as a guide to self management (i.e., self healing, self configuration) where the system uses additional information provided in the simulating model to manage itself.
Self-adaptive software continually evaluates and modifies its own behavior to meet changing demands. One of the key issues in constructing such software is that of planning when and what kinds of adaptations are appropriate. In this paper, we present an architecture-centric knowledge-based approach for specifying and enacting architectural adaptation policies as the main driver for self-adaptive behavior. Our work applies explicitly represented knowledge-based policies for the definition and enactment of software adaptation at the architectural level. A key benefit of our approach is the decoupling of adaptation policy from system implementation as well as the independent and dynamic evolution of policies themselves. We elaborate our overall approach, present prototype tools and techniques for its support, and discuss future research directions.
Increasing demands for reliability and dependability clash with the reality of escalating security compromises and vulnerability discoveries. Improvements in attack methodologies such as polymorphic viruses, tampering of source code repositories, and automation of distributed strikes are no match for the untimely detection and manual recovery practices used today. We present a run-time method to automate recovery from kernel level system compromises. It is capable of returning modified system call table addresses back to their original values, terminating hidden processes, removing hidden files, and blocking attacker traffic to hidden connections. Self-healing mechanisms such as this can be employed to create more reliable intrusion tolerant operating systems and applications. A working prototype has been implemented as a loadable kernel module on Linux, and can be easily enhanced for other operating systems.
This paper proposes the RAFTING approach (Resource-based Approach to FeaTure InteractioN) to address the feature interaction problem in the context of dynamically adapted software. RAFTING focuses on the resources used by features, rather than the features themselves. Therefore, for this paper's purposes, resource contention will be considered the main cause for feature interaction. We illustrate how a resource-based approach simplifies the detection of feature interactions, particularly when a limited amount of information is known about the individual components being dynamically added to the system.
It is by now motherhood-and-apple-pie that complex distributed Internet services form the basis not only of ecommerce but increasingly of mission-critical networkbased applications. What is new is that the workload and internal architecture of three-tier enterprise applications presents the opportunity for a new approach to keeping them running in the face of both inaturali failures and adversarial attacks. The core of the approach is anomaly detection and localization based on statistical machine learning techniques. Unlike previous approaches, we propose anomaly detection and pattern mining not only for operational statistics such as mean response time, but also for structural behaviors of the systemowhat parts of the system, in what combinations, are being exercised in response to different kinds of external stimuli. In addition, rather than building baseline models a priori, we extract them by observing the behavior of the system over a short period of time during normal operation. We explain the necessary underlying assumptions and why they can be realized by systems research, report on some early successes using the approach, describe benets of the approach that make it competitive as a path toward selfmanaging systems, and outline some research challenges. Our hope is that this approach will enable inew sciencei in the design of self-managing systems by allowing the rapid and widespread application of statistical learning theory techniques (SLT) to problems of system dependability.
Constructing adaptive software that is capable of changing behavior at runtime is a challenging software engineering problem. However, the problem of determining when and how such a system should adapt, i.e., the system's adaptation policy, can be even more challenging. To optimize the behavior of a system over its lifetime, the policy must often take into account not only the current system state, but also the anticipated future behavior of the system. This paper presents a systematic approach based on using Markov Decision Processes to model the system and to generate optimal adaptation policies for it. In our approach, we update the model on-line based on system measurements and generate updated adaptation policies at runtime when necessary. We present the general approach and then outline its application to a distributed message dissemination system based on AT&T's iMobile platform.
This paper describes an online control framework to design self-managing distributed computing systems that continually optimize their performance in response to changing computing demands and environmental conditions. An online control technique is used in conjunction with predictive filters to tune the performance of individual system components based on their forecast behavior. In a distributed setting, a global controller is used to manage the interaction between components such that overall system requirements are satisfied.
A distributed software system's deployment architecture can have a significant impact on the system's properties, which depend on various system parameters, such as network bandwidth, frequencies of software component interactions, and so on. Recent studies have shown that the quality of deployment architectures can be improved significantly via active system monitoring, efficient estimation of the improved deployment architecture, and system redeployment. However, the lack of a common framework for improving a system's deployment architecture has resulted in ad hoc solutions. In this paper, we present an extensible framework that guides the design and development of solutions to this problem, enables the extension and reuse of the solutions, and facilitates autonomic analysis and redeployment of a system's deployment architecture.
Self-adaptive systems modify their own behaviour in response to stimuli from their operating environments. The major policy considerations for such systems are determining what, when and how adaptations should be carried out. This paper presents mechanisms for feedback and change that support policy decisions for self-adaptation within a computationally complete architecture description language based on the π-calculus. Our contribution is support for feedback through software-encoded probes, gauges and an event distribution network together with support for change through decomposition, reification, reflection, recomposition and hyper-code.
Component-based software engineering offers a way to partition complex systems into well-defined parts. Adaptation mechanisms are crucial to enable run-time reconfiguration and to increase the reuse of these parts in other applications and environments. In this paper we utilize the concept of composite components to map component parameters to different predefined internal configurations of subcomponents. The structural adaptation is thereby encapsulated and hidden from other parts of the system. Configuration variations allow to specify parameterizable configuration patterns. Some extensions to UML diagrams are introduced to model reconfiguration steps. Optional adaptation and aspect operators as additional constituents of composite components increase the flexibility of the presented approach.
The use of handheld networked devices to access information systems by people moving around is spreading rapidly. Systems being used in this way typically face dynamic variation in their operating environment. In order to maintain the usability and usefulness for mobile users, self-adapting systems are needed. Self-adaptation has so far typically been applied only to mission critical systems at considerable additional cost. However, we now need ways to implement such capabilities that are affordable also in everyday systems development.In this paper we propose an approach to building such self-adapting systems where the adaptation is handled by generic middleware. The proposed approach builds on component frameworks and variability engineering to achieve adaptable systems, and property modelling, architectural reflection and context monitoring to support dynamic self-adaptation. We define a set of requirements for affordable self-adaptation and discuss the proposed approach in relation to these requirements.
Self-managed software requires monitoring and code changes to an executing program. One technology that enables such self management is software dynamic translation (SDT), which allows a program's execution to be intercepted and controlled by a separate software layer. SDT has been used to build many useful applications, including software security checkers that check for code vulnerabilities, dynamic code optimizers, and program introspection tools. While these systems use program instrumentation, the instrumentation is usually tailored to a specific application and infrastructure. What is missing is a single scalable and flexible instrumentation framework that can be used in different self-managed SDT infrastructures. In this paper, we describe such a framework, called "FIST," that can be used and targeted by different algorithms and tools to enable instrumentation applications that are portable across SDTs and machine platforms. Our interface supports multiple levels of granularity from source level constructs to the instruction and machine level. We describe and evaluate FIST's capabilities in the Strata system for the SPARC and the Jikes Research Virtual Machine for Java on the Intel x86.
Components in a decentralised system are faced with uncertainty as how to best adapt to a changing environment to maintain or optimise system performance. How can individual components learn to adapt to recover from faults in an uncertain environment? How can a decentralised system coordinate the adaptive behaviour of its components to realise system optimisation goals given problems establishing consensus in dynamic environments? This paper introduces a self-adaptive component model, called K-Components, that enables individual components adapt to a changing environment and a decentralised coordination model, called collaborative reinforcement learning, that enables groups of components to learn to collectively adapt their behaviour to establish and maintain system-wide properties in a changing environment.
Recently there has been increasing interest in developing systems that can adapt dynamically to cope with changing environmental conditions and unexpected system errors. Most efforts for achieving self-adaptation have focused on the mechanisms for detecting opportunities for improvement and then taking appropriate action. However, such mechanisms beg the question: what is the system trying to achieve? In a given situation there may be many possible adaptations, and knowing which one to pick is a difficult question. In this paper we advocate the use of explicit representation of user task as a critical element in addressing this missing link.
Continuous numeric prediction techniques known as model trees which build decision trees and then use linear regression at the terminal nodes are used to characterize resource consumption in a computer system. An advantage of model trees over time series and other traditional statistical models is the ability to add background knowledge to the model. Models are built using production data from several banks in collaboration with domain experts at those institutions. A demonstration of improving the models by adding background expert knowledge is given. An example of using model predictions to allow adaptive elements of an operating system to become more self-managing with respect to memory usage is also presented. Comparisons with other predictive techniques are made and advantages and disadvantages of using this technique in the operating system are discussed.
The development of dependable software systems is a costly undertaking. Fault tolerance techniques as well as self-repair capabilities usually result in additional system complexity which can even spoil the intended improvement with respect to dependability. We therefore present a pattern-based approach for the design of service-based systems which enables self-managing capabilities by reusing proven fault tolerance techniques in form of Fault Tolerance Patterns. The pattern specification consists of a service-based architectural design and deployment restrictions in form of UML deployment diagrams for the different architectural services. The architectural design is reused when designing the system architecture. The deployment restrictions are employed to determine valid deployment scenarios for an application. During run-time the same restrictions are at first used to automatically map additional services on suitable nodes. If node crashes are detected, we secondly employ the restrictions to guide the self-repair of the system in such a way that only suitable repair decisions are made.
Failure recovery in distributed systems poses a difficult challenge because of the requirement for high availability. Failure scenarios are usually unpredictable so they can not easily be foreseen. In this research we propose a planning based approach to failure recovery. This approach automates failure recovery by capturing the state after failure, defining an acceptable recovered state as a goal and applying planning to get from the initial state to the goal state. By using planning, this approach can recover from a variety of failed states and reach any of several acceptable states: from minimal functionality to complete recovery.
