Elsevier

Information Sciences

Volume 176, Issue 18, 22 September 2006, Pages 2603-2623
Information Sciences

Request-based token passing for self-stabilizing mutual exclusion

https://doi.org/10.1016/j.ins.2005.11.013Get rights and content

Abstract

This paper presents a new method for request-based self-stabilizing token passing. A token is passed via a dynamic BFS (breadth-first search) tree rooted at a requesting process. When one of the tree edges reaches a process that has a token, the process is aware of the occurrence of a request. Then the token is passed towards the root. Even if multiple tokens stay at distinct roots, it can be shown that they will be merged into a single token. Furthermore, each request-rooted tree continues to grow until the request is serviced. As a result, the tree with a request that has long been neglected grows larger and larger, which makes it easier for the requesting process to get a token. Such advantages can be achieved by using bounded memory. We also evaluate the stabilization time and the efficiency of servicing k requests, called k-covering time, of our method.

Introduction

Self-stabilization is the most fundamental concept of automatic recovery from transient faults in distributed systems. The transient faults are assumed only to perturb system states arbitrarily, but not the program codes. Starting from arbitrary initial states, self-stabilizing protocols eventually repair the transient faults without any aid of external actions. Then the system state is guaranteed to be legitimate thereafter. A lot of researchers have paid attention to its fault tolerance. Many interesting self-stabilizing algorithms, especially for token circulation, have been developed.

Most of the self-stabilizing token circulation schemes are classified into two categories; they pass the token in a depth-first fashion [2], [5] or in a randomized fashion [7]. The former is a commonly used method that has the advantage of fair token circulation. The latter is not so commonly used but has the advantage of merging multiple tokens. Though the latter method does not guarantee the fair token circulation in general, it has been recently improved [6]. Both methods do not consider whether or not each process needs the privilege of some task. However, the mutual exclusion problem, an important application of the token circulation, usually requires a “trying region” in which a process announces that it needs a service [10]. A similar problem has been pointed out in a non-stabilizing token circulation scheme [3]. Additionally, the efficiency after stabilization, called a service time, has recently attracted attention in self-stabilizing systems [1], [8]. We are motivated by such work because mutually exclusive tasks are usually driven by requests and the efficiency after stabilization should also be considered.

Instead of the token circulation without need of processing, our method is a request-based token passing scheme. Our key idea is to use dynamic BFS spanning (sub)trees, each of which has a requesting root process. The trees are implemented by commonly used Distance and Parent variables. The term “dynamic” is used in the sense that the shape of trees changes if a new request occurs. When one of the tree edges reaches a token, the process having the token is aware that there is a request towards the root. The token is then passed along the edges. So there is no need to keep request queues that have a risk of losing requests. Such queueless property has an application to mobile ad hoc networks [9]. Another key idea is to grow trees with neglected requests in size. First, the long absence of a token from a request periodically decreases the Priority variable of the corresponding root process. Second, every non-root process selects its parent process with the smallest Priority in the neighborhood. These ideas can be implemented by bounded variables.

Related work is summarized as follows: Feuerstein et al. [3] proposed request-based non-stabilizing mutual exclusion protocols in rings, and Prasath and Thangavel [11] extended it to mesh networks. As far as we know, there have been no request-based self-stabilizing token passing (or mutual exclusion) protocols so far. Johnen [8] and Beauquier et al. [1] studied the concept of service time, which is the duration of a token round after stabilization. We also take the efficiency after stabilization into account, that is, a token follows the shortest path to a request. For the non-stabilizing mutual exclusion, Raymond [12] proposed a similar tree-based protocol. Her method, however, is based on a predefined, static tree and it is not rooted at a request, but a token. Since the token moves on the static underlying tree, it may not follow the shortest path to request sources. Suzuki and Kasami [13] also presented a non-stabilizing mutual exclusion algorithm. Unlike our method, each request is always sent to all the processes and is stored in a queue.

In this paper we develop a request-based self-stabilizing token circulation protocol. The features of our method are as follows:

  • In safe execution, the token is not passed until a request occurs. In erroneous execution, multiple tokens are eventually merged into one as long as no requests prevent them.

  • A token is notified of request occurrence by constructing a dynamic BFS spanning (sub)tree rooted at the request. Then the token takes the shortest way to the root as long as stabilization is achieved.

  • A long-term neglected request gradually enlarges its spanning (sub)tree to achieve lockout-freedom.

  • Every variable is represented by bounded memory.

The rest of this paper is organized as follows. Section 2 states our underlying model. Section 3 presents our method and its basic idea. Section 4 proves the correctness and the property of our method. Section 5 concludes the paper.

Section snippets

Model

Here we describe a model used in this paper. We consider an arbitrary connected network consisting of n finite state processes, where each process i, identified by the hardwired name P = {1, 2,  , n}, has shared variables with a finite set of states Σi. The global state of all processes is called a configuration. The set of all configurations is denoted by Γ = Σ1 × Σ2 ×  × Σn. The network is represented by a connected graph G = (V, E), where V is a set of nodes (processes) and E is a set of edges (links).

Our method

First we outline our protocol, called RequestBase.

Correctness

In this section, we show the correctness of our protocol. The following definition states the desired configuration of our self-stabilizing protocol.

Definition 2 Legitimate configuration

A legitimate configuration for the protocol RequestBase is a global state such that

  • (1)

    each request source is the root of a spanning subtree, and

  • (2)

    there exists exactly one token in a network.

Conclusion

In usual non-stabilizing mutual exclusion protocols, a process has to execute a trying protocol in order to gain admittance to its critical section [10]. The trying protocol corresponds to the “request” in this paper. It would be necessary to adjust the conventional self-stabilizing approach to several practical problems. Thus we proposed a request-based self-stabilizing token passing protocol. Several features of this method include a queueless property, efficiency after stabilization, and

Acknowledgements

The author would like to thank Prof. Yamashita for his helpful comments. This work was partially supported by the Telecommunications Advancement Foundation.

References (13)

  • E. Feuerstein et al.

    Efficient token-based control in rings

    Information Processing Letters

    (1998)
  • S.-T. Huang et al.

    A self-stabilizing algorithm for constructing bread-first trees

    Information Processing Letters

    (1992)
  • J. Beauquier, A.K. Datta, M. Gradinariu, F. Magniette, Self-stabilizing local mutual exclusion and daemon refinement,...
  • A.K. Datta et al.

    Self-stabilizing depth-first token circulation in arbitrary rooted networks

    Distributed Computing

    (2000)
  • S.-T. Huang et al.

    Self-stabilizing depth-first token circulation on networks

    Distributed Computing

    (1993)
  • S. Ikeda et al.

    Fair circulation of a token

    IEEE Transactions on Parallel and Distributed Systems

    (2002)
There are more references available in the full text version of this article.

Cited by (3)

The preliminary version of this paper was presented at PDCS’03.

View full text