1,435 research outputs found
A deliberative model for self-adaptation middleware using architectural dependency
A crucial prerequisite to externalized adaptation is an understanding of how components are interconnected, or more particularly how and why they depend on one another. Such dependencies can be used to provide an architectural model, which provides a reference point for externalized adaptation. In this paper, it is described how dependencies are used as a basis to systems' self-understanding and subsequent architectural reconfigurations. The approach is based on the combination of: instrumentation services, a dependency meta-model and a system controller. In particular, the latter uses self-healing repair rules (or conflict resolution strategies), based on extensible beliefs, desires and intention (EBDI) model, to reflect reconfiguration changes back to a target application under examination
Using Process Technology to Control and Coordinate Software Adaptation
We have developed an infrastructure for end-to-end run-time monitoring, behavior/performance analysis, and dynamic adaptation of distributed software. This infrastructure is primarily targeted to pre-existing systems and thus operates outside the target application, without making assumptions about the target's implementation, internal communication/computation mechanisms, source code availability, etc. This paper assumes the existence of the monitoring and analysis components, presented elsewhere, and focuses on the mechanisms used to control and coordinate possibly complex repairs/reconfigurations to the target system. These mechanisms require lower level effectors somehow attached to the target system, so we briefly sketch one such facility (elaborated elsewhere). Our main contribution is the model, architecture, and implementation of Workflakes, the decentralized process engine we use to tailor, control, coordinate, etc. a cohort of such effectors. We have validated the Workflakes approach with case studies in several application domains. Due to space restrictions we concentrate primarily on one case study, briefly discuss a second, and only sketch others
Recommended from our members
An Approach to Autonomizing Legacy Systems
Adding adaptation capabilities to existing distributed systems is a major concern. The question addressed here is how to retrofit existing systems with self-healing, adaptation and/or self management capabilities. The problem is obviously intensified for 'systems of systems' composed of components, whether new or legacy, that may have been developed by different vendors, mixing and matching COTS and 'open source' components. This system composition model is expected to be increasingly common in high performance computing. The usual approach is to train technicians to understand the complexities of these components and their connections, including performance tuning parameters, so that they can then manually monitor and reconfigure the system as needed. We envision instead attaching a 'standard' feedback loop infrastructure to existing distributed systems for the purposes of continual monitoring and dynamically adapting their activities and performance. (This approach can also be applied to 'new' systems, as an alternative to 'building in' adaptation facilities, but we do not address that here.) Our proposed infrastructure consists of multiple layers with the objectives of probing, measuring and reporting of activity and state within the execution of the legacy system among its components and connectors; gauging, analysis and interpretation of the reported events; and possible feedback to focus the probes and gauges to drill deeper, or when necessary - direct but automatic reconfiguration of the running system
Runtime observable and adaptable UML state machines: [email protected] approach
n embedded system is a self-contained system that incorporateselements of control logic and real-world interaction. UML State Ma-chines constitute a powerful formalism to model the behaviour ofthese types of systems. In current industrial environments, the soft-ware of these embedded systems have to cope with the increasingcomplexity and robustness requirements at runtime. One way tomanage these requirements is having the software component’sbehaviour model available at runtime ([email protected]). Thus,it is possible to enhance the safety of the software component byenabling verification and adaptation at runtime. In this paper, wepresent a model-driven approach to generate software components(namely, RESCO framework), which are able both to provide theirinternal information in model terms at runtime and adapt their be-haviour automatically when an error or an unexpected situation isdetected. The aforementioned runtime introspection and adaptationabilities are added automatically to the software component and itdoes not require the developer make any extra effort. The solutionhas been tested in the design and implementation of an industrialBurner controller. Results indicate that the software components ge-nerated by the presented solution provides introspection at runtime.Thanks to this introspection ability at runtime, the software com-ponents are able to adapt automatically from their normal-modebehaviour to a safe-mode behaviour which was defined to be usedin erroneous or unexpected situations at runtime. Therefore, it ispossible to enhance the safety of the systems consisting of thesesoftware components
Architectural Approaches for Self-Healing Systems Based on Multi Agent Technologies
Self-healing systems are able to adapt themselves at runtime time in response to changing environmental or operational circumstances, shifting user requirements, and unanticipated faults without human intervention. Conceptually, a self-managing system is composed of four key capabilities; Monitoring, performing Analysis, Planning and Executing the plan. The preferred way to enable repair in a self-healing system is to use externalized repair/adaptation architecture. Adaptability, dynamicity, awareness, observability, autonomy, robustness, distributability, mobility and traceability are requirements that an architecture style for self-healing system should satisfy. In this paper we discuss Multi agent based self-healing system has a characteristics that can satisfy mentioned requirement. We define associations between architecture style requirements for self-healing system and MAS characteristics. As a case study in a real project we have designed Automated Teller Machine (ATM) combination with biometric sensors based on multi-agent architecture.DOI:http://dx.doi.org/10.11591/ijece.v3i6.395
Recommended from our members
Adding Self-healing capabilities to the Common Language Runtime
Self-healing systems require that repair mechanisms are available to resolve problems that arise while the system executes. Managed execution environments such as the Common Language Runtime (CLR) and Java Virtual Machine (JVM) provide a number of application services (application isolation, security sandboxing, garbage collection and structured exception handling) which are geared primarily at making managed applications more robust. However, none of these services directly enables applications to perform repairs or consistency checks of their components. From a design and implementation standpoint, the preferred way to enable repair in a self-healing system is to use an externalized repair/adaptation architecture rather than hardwiring adaptation logic inside the system where it is harder to analyze, reuse and extend. We present a framework that allows a repair engine to dynamically attach and detach to/from a managed application while it executes essentially adding repair mechanisms as another application service provided in the execution environment
Manipulating Managed Execution Runtimes to Support Self-Healing Systems
Self-healing systems require that repair mechanisms are available to resolve problems that arise while the system executes. Managed execution environments such as the Common Language Runtime (CLR) and Java Virtual Machine (JVM) provide a number of application services (application isolation, security sandboxing, garbage collection and structured exception handling) which are geared primarily at making managed applications more robust. However, none of these services directly enables applications to perform repairs or consistency checks of their components. From a design and implementation standpoint, the preferred way to enable repair in a self-healing system is to use an externalized repair/adaptation architecture rather than hardwiring adaptation logic inside the system where it is harder to analyze, reuse and extend. We present a framework that allows a repair engine to dynamically attach and detach to/from a managed application while it executes essentially adding repair mechanisms as another application service provided in the execution environment
Recommended from our members
Retrofitting Autonomic Capabilities onto Legacy Systems
Autonomic computing - self-configuring, self-healing, self-optimizing applications, systems and networks - is a promising solution to ever-increasing system complexity and the spiraling costs of human management as systems scale to global proportions. Most results to date, however, suggest ways to architect new software constructed from the ground up as autonomic systems, whereas in the real world organizations continue to use stovepipe legacy systems and/or build 'systems of systems' that draw from a gamut of disparate technologies from numerous vendors. Our goal is to retrofit autonomic computing onto such systems, externally, without any need to understand, modify or even recompile the target system's code. We present an autonomic infrastructure that operates similarly to active middleware, to explicitly add autonomic services to pre-existing systems via continual monitoring and a feedback loop that performs, as needed, reconfiguration and/or repair. Our lightweight design and separation of concerns enables easy adoption of individual components, independent of the rest of the full infrastructure, for use with a large variety of target systems. This work has been validated by several case studies spanning multiple application domains
A Review on Present State-of-the-Art of Self Adaptive Dynamic Software Architecture
Enterprises across the world are increasingly depending on software to drive their businesses. It is more so with distributing computing technologies in place that pave way for realization of seamless business integration. On the other hand those complex software systems are expected to adapt changes dynamically without causing administrative overhead. Moreover software systems should exhibit fault tolerance, location transparency, availability, scalability self-adaptive capabilities to fit into present enterprise business use cases. To cope with such expectations software systems are to be built with a dynamic and self-adaptive software architecture which drives home quality of services perfectly. The point made here is that software systems are facing unprecedented level of complexity and aware of self-adaptation. Therefore it is essential to have technical knowhow pertaining to self adaptive dynamic software architecture. Towards this end, we explore present state-of-the-art of this area in software engineering domain. It throws light into dynamic software architectures, distributed component technologies for realizing such architectures, besides dynamic software composition and metrics to evaluate the quality of dynamic adaptation
Recommended from our members
Orchestrating the Dynamic Adaptation of Distributed Software with Process Technology
Software systems are becoming increasingly complex to develop, understand, analyze, validate, deploy, configure, manage and maintain. Much of that complexity is related to ensuring adequate quality levels to services provided by software systems after they are deployed in the field, in particular when those systems are built from and operated as a mix of proprietary and non-proprietary components. That translates to increasing costs and difficulties when trying to operate large-scale distributed software ensembles in a way that continuously guarantees satisfactory levels of service. A solution can be to exert some form of dynamic adaptation upon running software systems: dynamic adaptation can be defined as a set of automated and coordinated actions that aim at modifying the structure, behavior and performance of a target software system, at run time and without service interruption, typically in response to the occurrence of some condition(s). To achieve dynamic adaptation upon a given target software system, a set of capabilities, including monitoring, diagnostics, decision, actuation and coordination, must be put in place. This research addresses the automation of decision and coordination in the context of an end-to-end and externalized approach to dynamic adaptation, which allows to address as its targets legacy and component-based systems, as well as new systems developed from scratch. In this approach, adaptation provisions are superimposed by a separate software platform, which operates from the outside of and orthogonally to the target application as a whole; furthermore, a single adaptation possibly spans concerted interventions on a multiplicity of target components. To properly orchestrate those interventions, decentralized process technology is employed for describing, activating and coordinating the work of a cohort of software actuators, towards the intended end-to-end dynamic adaptation. The approach outlined above, has been implemented in a prototype, code-named Workflakes, within the Kinesthetics eXtreme project investigating externalized dynamic adaptation, carried out by the Programming Systems Laboratory of Columbia University, and has been employed in a set of diverse case studies. This dissertation discusses and evaluates the concept of process-based orchestration of dynamic adaptation and the Workflakes prototype on the basis of the results of those case studies
- …