Sukumar Ghosh

Fault-containing self-stabilizing algorithms

Self-stabilization provides a non-masking approach to fault tolerance. Given this fact, one would hope that in a self-stabilizing system, the amount of disruption caused by a fault is proportional to the severity of the fault. However, this is not true for many self-stabilizing systems. Our paper addresses this weakness of distributed self-stabilizing systems by introducing the notion of fault containment. Informally, a fault-containing self-stabilizing algorithm is one that contains the effects of limited transient faults while retaining the property of self-st abilization. The paper begins with a formal framework for specifying and evaluating fault-containing self-stabilizing protocols. Then, it is shown that self-stabilization and fault containment are goals that can conflict. For example, it is shown that imposing a O(1) bound on the worst case recovery time from a l-faulty state necessitates added overhead for stabilization: for some tasks, the O(1) recovery time implies sfiabilization time cannot be within O(1) rounds from the optimum value. The paper then presents a transformer T that maps any non-reactive self-stabilizing algorithm P into an equivalent fault-containing self-stabilizing algorithm Pf that can repair any l-faulty state in O(1) time with O(1) space overhead. This transformation is baaed on a novel stabilizing timer paradigm that significantly simplifies the ti=k of fault containment. The paper concludes by generalizing the transformer ‘T into a parameterized transformer 7(k) such that for varying k we obtain varying performance measures for Pf.

A self-stabilizing algorithm for coloring planar graphs

SummaryThis paper describes an algorithm for coloring the nodes of a planar graph with no more than six colors using a self-stabilizing approach. The first part illustrates the coloring algorithm on a directed acyclic version of the given planar graph. The second part describes a selfstabilizing algorithm for generating the directed acyclic version of the planar graph, and combines the two algorithms into one.

An exercise in fault-containment: self-stabilizing leader election

Self-stabilizing algorithms are designed to guarantee convergence to some desired stable state from arbitrary initial states arising out of an arbitrarily large number of faults. However, in a well-designed system, the simultaneous occurrence of a large number of faults is rare. It is therefore desirable to design algorithms that are not only self-stabilizing, but also have the ability to recover very fast from a bounded number of faults. As an illustration, we present a simple self-stabilizing leader election protocol that recovers in O(1) time from a state with a single transient fault on oriented rings. Only the faulty node and its two neighbors change their state during convergence to a stable state. Thus, the effect of a single fault is tightly contained around the fault. The technique for transforming a self-stabilizing algorithm into its fault-contained version is simple and general, and can be applied to other problems as well that satisfy certain properties.

Dissecting Self-* Properties

The scale and complexity of distributed systems have steadily grown in the recent years. Management of this complexity has drawn attention towards systems that can automatically maintain themselves throughout different scenarios. These systems have been described with many terms, such as self-healing, self-stabilizing, self-organizing, self-adaptive, self-optimizing, self-protecting, and self-managing. These attributes are collectively referred to as self-* properties. Even with the increased focus on self-* research, there exists much ambiguity in the perceptions of the different self-* properties. In this paper, we propose to resolve the ambiguity by introducing a template for defining self-* properties, and use it to offer formal definitions of existing self-* terms. We then present some observations about the relationships among the different self-* properties. Finally, we propose two new self-* properties that are meaningful in this space.

A self-organized grouping (SOG) method for efficient Grid resource discovery

This paper presents a self-organized grouping (SOG) method that achieves efficient Grid resource discovery by forming and maintaining autonomous resource groups. Each group dynamically aggregates a set of resources that are similar to each other in some pre-specified resource characteristic. The SOG method takes advantage of the strengths of both centralized and decentralized approaches that were previously developed for Grid/P2P resource discovery. The design of the SOG method minimizes the overhead incurred in forming and maintaining groups and maximizes resource discovery performance. The way SOG method handles resource discovery queries is metaphorically similar to searching for a word in an English dictionary by identifying its alphabetical groups at the first place. It is shown from a series of computational experiments that SOG method achieves more stable (i.e., independent of the factors such as resource densities, and Grid sizes) and efficient lookup performance than other existing approaches.

Self-Stabilizing Algorithms for Finding Centers and Medians of Trees

Locating a center or a median in a graph is a fundamental graph-theoretic problem. Centers and medians are especially important in distributed systems because they are ideal locations for placing resources that need to be shared among different processes in a network. This paper presents simple self-stabilizing algorithms for locating centers and medians of trees. Since these algorithms are self-stabilizing, they can tolerate transient failures. In addition, they can automatically adjust to a dynamically changing tree topology. After the algorithms are presented, their correctness is proven and upper bounds on their time complexity are established. Finally, extensions of our algorithms to trees with arbitrary, positive edge costs are sketched.

Stabilizing phase-clocks

Abstract This note considers the problem of synchronizing a network of digital clocks: the clocks all run at the same rate, however, an initial state of the network may place the clocks in arbitrary phases. The problem is to devise a protocol to advance or retard clocks so that eventually all clocks are in phase. The solutions presented in this note are protocols in which all processes are identical and use a constant amount of space per process. One solution is a deterministic protocol for a tree network; another solution is a probabilistic protocol for a network of arbitrary topology.

Fault-containing self-stabilization using priority scheduling

Schedulers play a vital role in the design of distributed algorithms. This paper introduces priority scheduling that can be used to design as well as reason about correctness proofs at a higher level of abstraction. The application of priority scheduling in solving problems related to stabilization and fault containment in spanning tree generation is presented. This paper also presents an implementation of the priority scheduling scheme.

Fault-containing network protocols

Self-stabilization is a simple and elegant approach towards designing fault-tolerant network protocols. While self-stabilization provides automatic recovery from arbitrary transient faults, self-stabilizing systems do not incorporate any optimization for more efficient recovery from limited transient faults, even though such limited faults are more likely to occur in practice than arbitrary faults. Fault-containing self-stabilizing protocols are proposed to efficiently contain the effects of more frequent, limited transient faults while retaining the desirable property of self-stabilization. In this paper, we propose a methodology for designing fault-containing selfstabilizing network protocols. The methodology views the properties of self-stabilization and fault-containment in separation. Since self-stabilizing protocols already exist for many important network problems, the design starts with an existing self-stabilizing protocol, and adds to it the fault-containment property. The feasibilitv of this technique is illustrated bv the design of a fault-containing self-stabilizing protocol for the breadthfirst-search (BFS) spanning tree problem. The applicability of the technique used in deriving the BFS protocol to other problems is also discussed.

Fault-containing self-stabilizing distributed protocols

Self-stabilization is an elegant approach for designing a class of fault-tolerant distributed protocols. A self-stabilizing protocol is guaranteed to eventually converge to a legitimate state after a transient fault. However, even a minor transient fault can cause vast disruption in the system before legitimacy is reached. This paper introduces the notion of fault-containment to address this particular weakness of self-stabilizing systems. Informally, a fault-containing self-stabilizing protocol, in addition to providing self- stabilization, contains the effects of faults. This ensures that disruption during recovery from faults, is proportional to the extent of the faults. The paper begins with a formal framework for specifying and evaluating fault-containing self-stabilizing protocols. The main result of the paper is a transformer that converts any non-reactive self-stabilizing protocol into an equivalent fault-containing self-stabilizing protocol that can repair any single fault in the system in O(1) time. For a large class of input protocols, the corresponding output protocols produced by the transformer have O(1) space overhead. The small time and space overhead make the fault-containing self-stabilizing protocol a practical alternative to the original self-stabilizing protocol. The transformer is based on a novel stabilizing timer paradigm that significantly simplifies the task of fault-containment.