Raimundo José de Araújo Macêdo

The mobile groups approach for the coordination of mobile agents

We present the concept of mobile groups as a basic mechanism for the reliable coordination of mobile agents. Analogously to traditional group systems, mobile groups also provide message delivery guarantees and virtual synchrony. Furthermore, they make agent mobility not only visible for the group, but also consistently ordered with other group actions (such as crashes, joins, leaves, and other migrations). The mobile groups approach represents a novel mobility support mechanism, which can be used to handle reliability of mobile agents required at both, the application and system level (e.g., for coordinating distributed agents and for reliable agent migration, respectively). In this paper, we discuss the motivations for the mobile groups approach, formally define their properties, and present a membership protocol for such groups. We also discuss some implementation issues and related performance data, and present the advantages of mobile groups against mechanisms commonly employed for the coordination of mobile agents.

Solving the consensus problem in a mobile environment

Atomic broadcast or non-blocking atomic commitment are classic agreement problems encountered when designing fault-tolerant distributed systems. Specific protocols that solve such agreement problems can be designed based on a common building block, namely the consensus service. Unfortunately, the consensus problem has no deterministic solution in an asynchronous distributed system that is subject to even a single process crash failure. Among the solutions proposed to circumvent this impossibility result, the concept of unreliable failure detectors proposed by Chandra and Toueg is particularly attractive. They have defined a protocol that solves the consensus problem when the assumption that the underlying failure detector belongs to the class /spl square/S holds true. This paper presents an extension of their protocol that allows to solve this fundamental problem in a mobile environment. In such an environment, the problem is more challenging: based on their initial states, a set of mobile hosts must agree on a common decision, despite disconnections, changes of location and failures of mobile/fixed hosts.

A non-intrusive component-based approach for deploying unanticipated self-management behaviour

Supporting self-management behaviour by means of component-based architectural solutions has been the focus of many current research projects. In such a context, handling unanticipated changes with no impacts in application-specific software artefacts is a challenging problem. In this paper, we present a component-based solution for the specification and execution of self-management behaviour that decouples application-specific from autonomic-specific software artefacts (non-intrusive approach) and supports unanticipated changes in distributed heterogeneous environments. We describe the designed components for environment monitoring, adaptation policies specification, and changes redeployment and present a reference implementation built on top of CIAO middleware - a Lightweight CORBA Component Model implementation that supports dynamic reconfiguration of components and connectors. We also present two evaluation experiments, which provide self-optimization and self-healing behaviour in a distributed industrial supervision and control system.

QoS self-configuring failure detectors for distributed systems

Failure detectors are basic building blocks from which fault tolerance for distributed systems is constructed. The Quality of Service (QoS) of failure detectors refers to the speed and accuracy of detections and is defined from the applications and computing environment under consideration. Existing failure detection approaches for distributed systems do not support the automatic (re)configuration of failure detectors from QoS requirements. However, when the behavior of the computing environment is unknown and changes over time, or when the application itself changes, self-configuration is a basic issue that must be addressed - particularly for those applications requiring response time and high availability requirements. In this paper we present the design and implementation of a novel autonomic failure detector based on feedback control theory, which is capable of self-configuring its QoS parameters at runtime from previously specified QoS requirements.

A Search-Based Approach for Architectural Design of Feedback Control Concerns in Self-Adaptive Systems

A number of approaches for endowing systems with self-adaptive behavior have been proposed over the past years. Among such efforts, architecture-centric solutions with explicit representation of feedback loops have currently been advocated as a promising research landscape. Although noteworthy results have been achieved on some fronts, the lack of systematic representations of architectural knowledge and effective support for well-informed trade-off decisions still poses significant challenges when designing modern self-adaptive systems. In this paper, we present a systematic and flexible representation of design dimensions related to feedback control concerns, a set of metrics which estimate quality attributes of resulting automated designs, and a search-based approach to find out a set of Pareto-optimal candidate architectures. The proposed approach has been fully implemented in a supporting tool and a case study with a self-adaptive cloud computing environment has been undertaken. The results indicate that our approach effectively captures the most prominent degrees of freedom when designing self-adaptive systems, helps to elicit effective subtle designs, and provides useful support for early analysis of trade-off decisions.

Perfect Failure Detection in the Partitioned Synchronous Distributed System Model

In this paper we show that it is possible to implement a perfect failure detector P (one that detects all faulty processes if and only if those processes failed) in a non-synchronous distributed system. To realize that, we introduce the partitioned synchronous system (Spa) that is weaker than the conventional synchronous system. From some properties we introduce (such as strong partitioned synchrony) that must be valid in Spa and a trivially implementable Timeliness oracle, we show how to implement P in Spa. Moreover, we show that even if strong partitioned synchrony is not valid, we are still able to take advantage of the existing synchronous partitions for improving the robustness of applications, by introducing a partially perfect failure detector named xP. We also discus show applications can benefit from these failure detectors and present some related experimental data. The necessary properties and algorithms for implementing P and xP are presented in the paper, as well as the related correctness proofs.

A hybrid and adaptive model for fault-tolerant distributed computing

The capability of dynamically adapting to distinct runtime conditions is an important issue when designing distributed systems where negotiated quality of service (QoS) cannot always be delivered between processes. Providing fault-tolerance for such dynamic environments is a challenging task. Considering such a context, this paper proposes an adaptive model for fault-tolerant distributed computing. This model encompasses both the synchronous model (where there are time bounds on processing speed and message delay) and the asynchronous model (where there is no time bound). To illustrate what can be done in this model and how to use it, the consensus problem is taken as a benchmark problem. An implementation of the model is also described. This implementation relies on a negotiated quality of service (QoS) for channels, that can be timely or untimely. Moreover, the QoS of a channel can be lost during the execution (i.e., dynamically modified from timely to untimely), thereby adding uncertainty into the system.

Consensus Based on Strong Failure Detectors: A Time and Message-Efficient Protocol

The class of strong failure detectors (denoted S) includes all failure detectors that suspect all crashed processes and that do not suspect some (a priori unknown) process that never crashes. So, a failure detector that belongs to S is intrinsically unreliable as it can arbitrarily suspect correct processes. Several S-based consensus protocols have been designed. Some of them systematically require n computation rounds (n being the number of processes), each round involving n2 or n messages. Others allow early decision (i.e., the number of rounds depends on the maximal number of crashes when there are no erroneous suspicions) but require eac h round to involv en2 messages.This paper presents an early deciding S-based consensus protocol each round of which involv es 3(n - 1) messages. So, the proposed protocol is particularly time and message-efficient.

A Self-Manageable Group Communication Protocol for Partially Synchronous Distributed Systems

In order to provide upper-layer applications with continuous message delivery and updated information on membership changes - due to process failures, leaves and joins -, group communication protocols must exchange messages and continuously monitor all group members, which in certain load conditions may incur unacceptable message overhead to the underlying communication system. Therefore, the design of such protocols must deal with the trade-off between performance requirements such as speed (e.g., delivery latency) and cost (e.g., message overhead). However, when the behavior of the computing environment is unknown and can change over time, or when the application requirements can dynamically change, self-configuring is a basic issue that is usually ignored in existing implementations. In this paper we present the design, implementation and evaluation of a novel self-manageable group communication protocol based on the feedback control theory, which is capable of self-configuring its operation parameters at run-time from previously specified requirements such as resource consumption.

Enhancing group communication with self-manageable behavior

Group communication protocols (GCPs) play an important role in the design of modern distributed systems. A typical GCP exchanges control messages to provide message delivery guarantees, and a key point in the configuration of such a protocol is to establish the right trade-off between message overhead and delivery latency. This trade-off becomes even a greater challenge in systems where computing resources and application requirements may change at runtime. In such scenarios, the configuration of a GCP must be continuously re-adjusted to attain certain performance goals, or to adapt to current resource availability. This paper addresses this challenge by proposing self-managing mechanisms based on feedback control theory to a GCP especially designed to be self-manageable; in the proposed protocol, message overhead and delivery latency can be adjusted at runtime to follow some new operating set-point. The evaluation performed under varied scenarios shows the effectiveness of our approach.