We develop an efficient snapshot algorithm that needs no control messages and does not require channels to be first-in-first-out. We also show that several stable properties (e.g., termination, deadlock) can be detected with uncoordinated distributed snapshots. For such properties, our algorithm can be further simplified.

We study a new problem, the wakeup problem, that seems to be fundamental in distributed computing. We present efficient solutions to the problem and show how these solutions can be used to solve the consensus problem, the leader election problem, and other related problems. The main question we try to answer is, how much memory is needed to solve the wakeup problem? We assume a model that captures important properties of real systems that have been largely ignored by previous work on cooperative problems.

Dijkstra [4] [6] introduced the problem of self-stabilization in distributed systems as an interesting exercise for achieving global convergence through local actions. In [4], he presented three solutions to a specific version of the self-stabilization problem, one of which was proved in [5]. This paper presents an alternative solution to his self-stabilization problem with four-state machines. Categories and Subject Descriptors: C.2.4 [Computer-Communication Network]: Distributed Systems - distributed applications; D.4.1 [Operating Systems]: Process Management - synchronization. General Terms: Theory, Algorithms. Additional Keywords and Phrases: Self-stabilization, distributed algorithm, synthesis. 1 Introduction The task of synchronization in a distributed system corresponds to maintaining an invariance relationship over the global state of the system. When the invariant holds, the system is in the legitimate state, otherwise, the system state is illegitimate. A self-stabilizin...

We propose two distributed algorithms to maintain, respectively, a maximal matching and a maximal independent set in a given ad hoc network; our algorithms are fault tolerant (reliable) in the sense that the algorithms can detect occasional link failures and/or new link creations in the network (due to mobility of the hosts) and can readjust the global predicates. We provide time complexity analysis of the algorithms in terms of the number of rounds needed for the algorithm to stabilize after a topology change, where a round is defined as a period of time in which each node in the system receives beacon messages from all its neighbors. In any ad hoc network, the participating nodes periodically transmit beacon messages for message transmission as well as to maintain the knowledge of the local topology at the node; as a result, the nodes get the information about their neighbor nodes synchronously (at specific time intervals). Thus, the paradigm to analyze the complexity of the selfstabilizing algorithms in the context of ad hoc networks is very different from the traditional concept of an adversary deamon used in proving the convergence and correctness of self-stabilizing distributed algorithms in general.

We propose a simple and efficient self-stabilizing distributed algorithm to construct the breadth first search (BFS) spanning tree of an arbitrary connected symmetric graph. We develop a completely new direct approach of graph theoretical reasoning to prove the correctness of our algorithm. The approach seems to have potential to have applications in proving correctness of other self-stabilizing algorithms for graph theoretical problems. Address for Correspondence: Pradip K Srimani Department of Computer Science Colorado State University Ft. Collins, CO 80523 Tel: (303) 491-7097 Fax: (303) 491-6639 Email: srimani@CS.ColoState.Edu Department of Mathematics y Department of Computer Science 1 Introduction A distributed system can be viewed to consist of a set of loosely connected systems (state machines) which do not share a global memory but can share information by exchanging messages only. Each node or machine is allowed to have only a partial view of the global state which dep...

In this paper, we present a case study to demonstrate that the decomposition of a fault-tolerant program into its components is useful in its mechanical verification. More specifically, we discuss our experience in using the theorem prover PVS to verify Dijkstra's token ring program in a component-based manner. We also demonstrate the advantages of component based mechanical verification. Keywords : Component-based verification, Faulttolerance, Program decomposition, Mechanical verification, Self-stabilization 1 Introduction In this paper, we argue that the decomposition of a faulttolerant program into its components is beneficial in its mechanical verification, and that such a decomposition admits reuse of the proofs for other fault-tolerant programs as well as the variations of the given fault-tolerant program. Arora and Kulkarni [3] have shown that a fault-tolerant program can be decomposed into a fault-intolerant program and a set of `tolerance'-components, namely detectors and...

We propose a self stabilizing algorithm (protocol) for leader election in a tree graph. We show the correctness of the proposed algorithm by using a new technique involving induction. 1 Introduction In a distributed system the computing elements or nodes exchange information only by message passing. Every node has a set of local variables whose contents specify the local state of the node. The state of the entire system, called the global state, is the union of the local states of all the nodes in the system. Each node is allowed to have only a partial view of the global state, and this depends on the connectivity of the system and the propagation delay of different messages. Yet, the objective in a distributed system is to arrive at a desirable global final state (legitimate state), defined by some invariance relation on the global state. Systems that reach the legitimate state starting from any arbitrary (possibly illegitimate) state in a finite number of steps are called self-stabil...

The notion of self-stabilization was introduced by Dijkstra. He defined a system as selfstabilizing when "regardless of its initial state, it is guaranteed to arrive at a legitimate state in a finite number of steps". Such a property is very desirable for any distributed system, because after any unexpected perturbation modifying the memory state, the system eventually recovers and returns to a legitimate state, without any outside intervention. In this paper, we are interested in a distributed self-stabilizing depth-first token circulation protocol on an uniform rooted network (no identifiers, but a distinguished root). As already noted, a search algorithm together with a deterministic enumeration of the node's neighbors yields an algorithm determining a spanning tree. Our contribution is improving the best up to now known space complexity for this problem, from O(log(N)) to O(log(D)) where N is number of nodes and D is the network's degree. Moreover, we give a full proof o...

We propose two new self-stabilizing distributed algorithms for proper Δ+1 (Δ is the maximum degree of a node in the graph) coloring of arbitrary system graphs. Both algorithms are capable of working with multiple types of demons (schedulers) as is the most recent algorithm in [1]. The first algorithm converges in O(m) moves while the second converges in at most n moves (n is the number of nodes and m is the number of edges in the graph) as opposed to the O(Δ×n) moves required by the algorithm [1]. The second improvement is that neither of the proposed algorithms requires each node to have knowledge of Δ, as is required in [1]. Further, the coloring produced by our first algorithm provides an interesting special case of coloring, e.g., Grundy Coloring [2].

Self-stabilizing systems have been proposed as a desirable method of achieving fault tolerance. They are guaranteed to eventually eliminate any initial set of errors. This also implies that infrequent errors can be dealt with. For more details see [1-7]. In this paper we study deterministic self-stabilizing algorithms for leader election in rings. We have two sets of contributions. First, we introduce the formal definition of an observer at each location: a local process that can detect correctness, but cannot influence the protocol. Every self-stabilizing algorithm can have such associated observers. We believe that this is a good abstraction. We also claim that some such notion is necessary to make self-stabilizing protocols useful. The notion of an observer suggests a natural question to anyone familiar with the P vs. NP question: are there situations in which it is easier to detect stability than to achieve it? We exhibit a somewhat contrived problem where this is indeed the case. ...