J. Parallel Distrib. Comput. 70 (2010) 406–415

Contents lists available at ScienceDirect

J. Parallel Distrib. Comput. journal homepage: www.elsevier.com/locate/jpdc

A survey on self-stabilizing algorithms for independence, domination, coloring, and matching in graphs Nabil Guellati a,∗ , Hamamache Kheddouci b a

Department of Computer Science, University of Abderrahmane Mira, Bejaia, Algeria

b

LIESP Laboratory, University of Claude Bernard, Lyon, France

article

info

Article history: Received 21 March 2009 Received in revised form 28 August 2009 Accepted 23 November 2009 Available online 1 December 2009 Keywords: Distributed algorithm Self-stabilization Graph algorithm Independence Domination Coloring Matching

abstract Dijkstra defined a distributed system to be self-stabilizing if, regardless of the initial state, the system is guaranteed to reach a legitimate (correct) state in a finite time. Even though the concept of selfstabilization received little attention when it was introduced, it has become one of the most popular fault tolerance approaches. On the other hand, graph algorithms form the basis of many network protocols. They are used in routing, clustering, multicasting and many other tasks. The objective of this paper is to survey the self-stabilizing algorithms for dominating and independent set problems, colorings, and matchings. These graph theoretic problems are well studied in the context of self-stabilization and a large number of algorithms have been proposed for them. © 2009 Elsevier Inc. All rights reserved.

1. Introduction Self-stabilization is an optimistic fault tolerance approach for distributed systems. It was introduced by Dijkstra in [8]. According to him, a self-stabilizing system is guaranteed to reach a correct state, in a finite time, regardless of its initial state. Thus, a self-stabilizing system can recover from any transient fault without any external intervention. Self-stabilization is also a nonmasking approach, since after the occurrence of a transient fault, the system exhibits temporarily disrupted behavior for a certain period of time. Graph algorithms have natural applications in networks and distributed systems, since these latter may be modeled by graphs. For example, dominating sets are used in clustering. Coloring is used in mutual exclusion and resource allocation problems. Spanning trees are used in tasks like broadcasting and multicasting. Shortest path algorithms are used in routing, while matchings can be used in situations of communication where a node must be coupled with exactly one of its neighbors. Thus, several distributed graph algorithms have been developed to be used in network protocols.

Since the publication of Dijkstra’s pioneering paper, a lot of self-stabilizing algorithms for a variety of problems have been proposed in the literature. Herman [31] tried to classify works on self-stabilization into several categories such as synchronization and clocks, communication protocols, proof techniques, trees and graphs, etc. Here, we are interested in the category of graph theoretic problems, which has been deeply investigated. Selfstabilizing algorithms for a variety of graph theoretic problems have been published. However, some problems such as spanning tree construction, independence, domination, coloring, and matching have received more attention than other problems. Since there exists only one survey that treats self-stabilizing graph algorithms, in particular spanning tree construction algorithms [15], we are devoting this survey to the self-stabilizing algorithms for dominating sets, independent sets, colorings, and matchings in graphs. The rest of the paper is organized as follows. In Section 2, we define a few terms and concepts used throughout this paper, and we recall the most important system assumptions used with selfstabilizing algorithms. In Sections 3–6, we respectively present the self-stabilizing algorithms for independent sets, dominating sets, colorings, and matchings. In Section 7 we refer the reader to other related works, and finally, Section 8 concludes this paper. 2. Definitions and system assumptions

∗

Corresponding address: Département d’informatique, Faculté des sciences de l’ingénieur, Université Ferhat Abbas Sétif, 19000, Algeria. E-mail addresses: [email protected] (N. Guellati), [email protected] (H. Kheddouci). 0743-7315/$ – see front matter © 2009 Elsevier Inc. All rights reserved. doi:10.1016/j.jpdc.2009.11.006

We consider a distributed system whose topology is represented as an undirected graph G(V , E ) (called the system’s communication graph), where the nodes represent the processes and

N. Guellati, H. Kheddouci / J. Parallel Distrib. Comput. 70 (2010) 406–415

the edges represent the interconnections between the processes. Throughout this paper, we denote by n the number of nodes (|V | = n), and by m the number of edges (|E | = m) in the graph G. Let i be a node; we denote by N (i) the set of nodes to which i is adjacent (its neighbors). We denote by deg (i) the number of neighbors of node i, or its degree (deg (i) = |N (i)|), and we denote by ∆ the maximum degree of G (∆ = max{deg (i) | i ∈ V }). The distance of two nodes x, y is the length of a shortest path between x and y in the graph G. We denote the diameter of G by d, which is the greatest distance between any two nodes in the graph. A node is said to be central in G if its greatest distance from any other node is as small as possible. This distance is called the radius of G. Also, note that we use the terms node and process interchangeably. A distributed algorithm is said to be self-stabilizing [8,59,13, 9], if the following two properties hold: convergence and closure. The convergence property ensures that, starting from any incorrect state, the distributed system reaches a correct state. Here, the state of a distributed system (also called system configuration) consists of the state of every process and the content of every communication channel (or communication register). The closure property ensures that, after convergence, the system remains in the set of correct states. A distributed algorithm may assume the inter-process communication to be performed by exchanging messages; this is called the message-passing model of communication. However, self-stabilizing algorithms usually use the shared memory model of communication, where neighboring processes may communicate via common variables or registers. We distinguish two variants of the shared memory models of communication: with the state reading model, each process can directly read the internal state of its neighboring processes, while, with the link-register model, processes can communicate with each other only by using separate registers. The system processes are modeled as state machines performing a sequence of steps. If a process may read all its input variables, perform a state transition and write all its output variables in a single atomic step, we say in this case that the algorithm uses composite atomicity. The algorithm uses read/write atomicity if each atomic step contains either a single read operation or a single write operation of a communication variable. Note that most of the algorithms presented in this survey use composite atomicity and the state reading model of communication. Various execution models have been suggested for developing self-stabilizing algorithms. These models are encapsulated within the notion of a daemon (or scheduler). Under a central daemon, only one process can execute an atomic step at one time. If a synchronous daemon is supposed, then all the system processes will execute an atomic step at the same time. Another popular scheduler is the distributed daemon, which selects a subset of the system processes to execute an atomic step at the same time. Those are the most popular schedulers; however, variants of these schedulers have been used with some self-stabilizing algorithms. Also, the scheduler may be assumed to be fair, which guarantees that every process is eventually selected for executing a step. Otherwise, the scheduler only guarantees global system progress. The stabilization time is the maximum amount of time it takes for the system to reach a correct state. When estimating the time complexity of a self-stabilizing algorithm, we consider the stabilization time, since a self-stabilizing algorithm is usually a do forever loop and it does not terminate. The time complexity is estimated in terms of process atomic steps (or simply steps), or in terms of rounds. A round is usually defined to be the minimum time period in which every process is scheduled to execute an action at least once. However, slightly different definitions are given in the literature, and this is why we include the round definition given by the authors with the description of the corresponding algorithm.

407

A distributed algorithm is said to be uniform if all of the individual processes run the same code. If all processes run the same code except a single process, then the algorithm is semi-uniform. Some algorithms are designed for anonymous systems, where the processes do not have any identification [62], whereas other algorithms assume that processes have globally unique identifiers. Also, when a process can take actions with random outputs the algorithm is said to be probabilistic (or randomized); otherwise it is deterministic. A distributed algorithm is dynamic if it tolerates changes in the topology of the system during execution. It is pointed out in [13] that self-stabilizing uniform algorithms designed for systems of arbitrary topology are dynamic. 3. Independent set algorithms For a graph G(V , E ), a set of nodes S ⊂ V is independent [27] (Fig. 1) if no two nodes in S are adjacent. A maximal independent set (MIS) is an independent set that is not properly contained in any independent set. The first self-stabilizing algorithm that calculates a maximal independent set was introduced in [62] by Shukla et al. This algorithm is uniform, works for an arbitrary graph under a central daemon, and it is designed for an anonymous system. In this algorithm, each node maintains a variable that should indicate, after stabilization, whether the node is in the constructed MIS or not. The idea of the algorithm is as follows: a node joins the set under construction S if it has no neighbor in S, and leaves the set S if at least one of its neighbors is in S. So after the system stabilizes, we obtain an MIS. The authors showed that it is impossible to develop a deterministic and uniform algorithm for the MIS problem in an anonymous system under a distributed daemon. This result is obviously due to symmetry problems. Moreover, a large collection of graph problems is concerned by this impossibility result. Another uniform algorithm for the MIS problem was presented in [38] by Ikeda et al. This algorithm works for an arbitrary graph, and supposes the nodes to have globally unique identifiers (the system is not anonymous). This latter assumption allows one to break the symmetry and hence to design an algorithm that works under a distributed daemon. In this algorithm, each node joins the set under construction S if it has no neighbor in S. Also, each node leaves the set S if one of its neighbors, with a lower identifier, is in S. Goddard et al. [22] presented a uniform self-stabilizing algorithm that maintains an MIS in a mobile ad hoc network. They assume a synchronous execution model and globally unique identifiers for the nodes. The communication is performed through beacon messages that nodes in ad hoc networks transmit periodically to inform their neighbors of their continued presence. It is also assumed that the system’s communication graph always has the same node set (no node leaves the system and no new node joins the system), and that it remains connected despite the mobility of the nodes. The idea of the algorithm is as follows: each node joins the set under construction S if it has no neighbor with higher identifier in S, and leaves the set S if it has a neighbor with a higher identifier in S. Thus, after each topology change the system stabilizes and the set under construction becomes an MIS. The authors measure the time complexity of their algorithm using the number of rounds, and define a round as a period of time in which each node in the system receives beacon messages from all its neighbors. Shi et al. [60] presented a uniform self-stabilizing algorithm for the 1-maximal independent set (1-MIS) problem. Here, a 1-maximal independent set is an MIS, with the additional property that one cannot increase the cardinality of the independent set by removing one node and adding more nodes. The algorithm is designed for anonymous trees, and works under a central daemon. It works in a similar way as the previously described MIS algorithms, but moreover, each node is able to leave the set under construction

408

N. Guellati, H. Kheddouci / J. Parallel Distrib. Comput. 70 (2010) 406–415

IS

1– MIS

MIS

Fig. 1. Examples of independent sets (the shaded nodes denote the elements of the independent sets).

DS

TDS

MDS

2D – S

Fig. 2. Examples of dominating sets (the shaded nodes denote the elements of the dominating sets). Table 1 Self-stabilizing independent set algorithms. Reference

Output

Required topology

System is anonymous

Daemon

Complexity

Shukla et al. [62] Ikeda et al. [38] Goddard et al. [22] Shi et al. [60] Turau [67]

MIS MIS MIS 1-MIS MIS

Arbitrary Arbitrary Arbitrary Tree Arbitrary

Yes No No Yes No

Central Distributed Synchronous Central Distributed

O(n) steps O(n2 ) steps O(n) rounds O(n2 ) steps O(n) steps

when that would allow two or more of its neighbors to join the set under construction. Recently, Turau [67] proposed a uniform algorithm for the MIS problem assuming the nodes to have globally unique identifiers and an arbitrary graph. The objective of Turau was to design the first linear time MIS algorithm assuming a distributed daemon. The idea is to maintain, on each node, a variable that may have one of three different values. Thus, a node may be in one of the following states: in the set under construction (IN), out of the set under construction (OUT ), or waiting to join the set under construction (WAIT ). So, a node that has no neighbor in the set under construction will first change its state to WAIT. After that, it will change its state to IN if it has no neighbor with a lower identifier in WAIT state. Also, a node may leave the set under construction (change its state to OUT ) if it has some neighbors in this latter set. 3.1. Discussion The algorithms presented in this section are summarized in Table 1. As we can see, the basic ideas of the first three algorithms are similar, while the assumptions made are different. Both of the algorithms proposed by Ikeda et al. and Goddard et al. extend the algorithm of Shukla et al. by using unique identifiers in order to support parallel execution. And while Ikeda et al. point out that their algorithm is space optimal (i.e. the space complexity is twostate), this is also true for the other two algorithms. On the other hand, the algorithms of Shi et al. and Turau have different functioning since the former produces a 1-MIS and the latter aims at reducing the time complexity. Finally, the space complexity of those two algorithms is respectively six-state and three-state. 4. Dominating set algorithms In a graph G(V , E ), a set of nodes D ⊆ V is called a dominating set [27] (Fig. 2) if every node i ∈ V is either a member of D or is adjacent to a member of D. A dominating set D is minimal (minimal dominating set: MDS) if no proper subset of D is a dominating set. In the literature, we can find self-stabilizing algorithms for the total

dominating set (TDS) and the k-dominating set (KDS). A set D of nodes is said to be total dominating if each node of the graph is adjacent to some member of D. The set is said to be k-dominating if each node not in D is adjacent to at least k nodes in D. When the positive integer k = 1, it is a question of single domination. Otherwise, we speak about multiple domination (i.e. when k ≥ 2). We use this last criterion to classify the dominating set algorithms into two classes. 4.1. Single domination Hedetniemi et al. [28] presented two uniform algorithms for the dominating set (DS) and the minimal dominating set (MDS) problems. The algorithms work for any connected graph and assume a central daemon. The idea of the first algorithm is to partition the set of nodes into two disjoint sets, such that each set is dominating. To obtain this result, each node has a boolean variable that indicates whether it is in the first or the second set. Then, a node is allowed to change its state if all nodes in its neighborhood have the same state. According to the authors, this is called a dominating bipartition. In the second algorithm, which calculates an MDS, each node maintains a boolean variable that indicates after stabilization whether the node is in the MDS or not. Also, each node maintains another variable (pointer) that indicates if it is dominated by only one node (where a node is said to be dominated if it is adjacent to some member of the dominating set). So, a node will point to null if it is in the set under construction S or it is dominated by more than one node; otherwise it will point to the unique node that dominates it. The algorithm allows a node to join the set S, if it has no neighbor in S. On the other hand, a node that is already a member of S, and has a neighbor that is also a member of S, will leave the set if all its neighbors are not pointing to it. Thus, after stabilization the set S will be an MDS. Xu et al. [69] proposed a uniform algorithm for calculating an MDS in arbitrary graphs under a synchronous daemon. This algorithm uses the same system assumptions as the MIS algorithm presented in [22]. In a similar way to the previously described algorithm, each node maintains a boolean variable and a pointer. Here,

N. Guellati, H. Kheddouci / J. Parallel Distrib. Comput. 70 (2010) 406–415

a node i adjusts its pointer so that it points to itself if i is not dominated, and points to null if i is dominated by at least two neighbors; otherwise it points to the unique neighbor that dominates i. A node, which is not in the set under construction S nor any of its neighbors, will join the set S if it has the smallest identifier in its neighborhood. Also, a node will leave the set S if it has a neighbor in S and all of its neighbors are not pointing to it. In a distributed system, dominating sets may be used for selecting some nodes to act as servers; thus a node soliciting a service is guaranteed to find it in its neighborhood. If a total dominating set is used, then each server will be adjacent to at least one other server which may provide backup resource. Goddard et al. [20] gave this argument to motivate their work on the minimal total dominating set (MTDS) problem. Thus, a uniform algorithm that works in arbitrary graphs has been proposed. The authors assume globally unique identifiers for the nodes and a central daemon. The algorithm uses a mechanism of pointers similar to the one used by the previous algorithm. So, a node i will point to its neighbor having the minimum identifier if i has no neighbor in the set under construction S. On the other hand, if a node i has more than one neighbor in the set S then i will point to null; otherwise i will point to its unique neighbor that is a member of the set S. The algorithm allows a node to join the set S if some neighbor is pointing to it, and to leave the set S otherwise. So after stabilization, the set S will become an MTDS. Turau [67] extended his MIS algorithm (presented in the previous section) to design a uniform algorithm for the MDS problem. So, each node has an additional variable that points to another node or to null. This variable is used as follows. If a node is dominated by exactly one neighbor, then it will point to this neighbor. And if a node is dominated by more than one neighbor, or it is a member of the set under construction, then it will point to null. This algorithm allows a node to join the set under construction using the same rules as the MIS algorithm; however, in order to leave the set under construction a node must have no neighbor pointing to it. Note that this is the first MDS algorithm that stabilizes in linear time under a distributed daemon. Recently, Goddard et al. [24] proposed another uniform algorithm for finding a minimal dominating set (MDS) in an arbitrary graph under a distributed daemon. Locally distinct identifiers (within radius one) for the nodes are assumed and a possible implementation in ad hoc networks is described (though it has been previously described in [69,22]). The algorithm uses a boolean to determine whether a node is member of the MDS or not, and an integer to count a node’s neighbors that are members of the MDS. The algorithm allows an undominated node that has smaller identifier than any undominated neighbor to join the set under construction. On the other hand, a node leaves this latter set if it is not the unique dominator of itself nor any of its neighbors. 4.2. Multiple domination Kamei and Kakugawa [41] presented two uniform algorithms for the minimal k-dominating set (MKDS) problem in a tree. The first algorithm works for an anonymous system and a central daemon, whereas the second supposes the nodes to have globally unique identifiers and works under a distributed daemon. The first algorithm allows a node to join the set under construction S if it has fewer than k neighbors in S, and to leave the set S if it has more than k neighbors in S. This idea was extended to design the second algorithm that works under a distributed daemon. Thus, in the second algorithm, a node having more than k neighbors in the set under construction S will first make a request to leave S, and then leaves the set S only if its identifier is the smallest among all the neighbors requesting to leave S. So, after stabilization the set S will become a minimal k-dominating set (MKDS) for both of the algorithms.

409

Rather than proposing a new algorithm, Huang et al. [36] relaxed some restrictions used with the first MKDS algorithm proposed by Kamei and Kakugawa [41]. More precisely, this latter algorithm was shown to find a minimal 2-dominating set (M2DS) in an arbitrary graph, under a central daemon, with linear time complexity. Another algorithm for the MKDS problem was presented by Kamei and Kakugawa in [42]. The algorithm is uniform, works for an arbitrary graph and supposes the nodes to have globally unique identifiers. The authors suppose a synchronous execution model, where every node executes the same step in parallel. First, the algorithm calculates an MIS from the set of nodes i such that deg (i) ≥ k, then it selects the members of the MKDS from the complement of the MIS. The authors showed that their algorithm is an approximation algorithm for the minimum k-dominating set 1 problem with approximation ratio ∆k (1 + ∆k− ), if, for each node +1 i ∈ V , deg (i) ≥ k. Also, the authors measured the time complexity using the number of rounds, and defined a round to be a period from the beginning to the end of an execution of a complete iteration of the algorithm loop. Huang et al. [37] presented a uniform algorithm to find a minimal 2-dominating set (M2DS), assuming globally unique identifiers for the nodes. An M2DS can be calculated using the previous algorithms for the MKDS problem. However, none of them assumes a distributed daemon and an arbitrary graph at the same time like the present algorithm. Here, each node maintains two variables: the first indicates whether the node is in the constructed set or not, and the second indicates whether a node is dominated by fewer than, exactly, or more than two neighbors. The algorithm allows a node to join the set under construction if it is dominated by fewer than two nodes and none of its neighbors having smaller identifier is in the same situation. Also, a node may leave the set under construction if it is dominated by more than two nodes, and all of its neighbors are either in the set under construction or dominated by more than two nodes. 4.3. Discussion The algorithms presented in this section are summarized in Table 2. As we can see, the MDS algorithms of Hedetniemi et al. and Xu et al. use a similar pointing mechanism. It seems that Xu et al. designed their solution while trying to extend the first algorithm by using distinct identifiers to support parallel execution. The MDS algorithms proposed by Turau and Goddard et al. are both linear time ones, and they work under a distributed daemon. While Goddard et al. point out that locally distinct identifiers (within radius one) are sufficient for their algorithm to perform correctly, this is also true for Turau’s solution. In fact, these identifiers (referred to in the literature as chromatic identifiers) are sufficient for many other self-stabilizing graph algorithms. One may ask which algorithm is the best among these two latter. It is difficult to answer this question but we may mention here that the space complexity of Goddard et al.’s MDS algorithm is better since it is only six-state. On the other hand, some algorithms have been proposed in the multiple domination case. However, there is no algorithm for the MKDS problem in arbitrary graphs that works under a distributed daemon. The proposed algorithms either work for trees (Kamei and Kakugawa [41]) or find a M2DS (Huang et al. [37]). 5. Coloring algorithms Another graph theoretic problem that was studied in the context of self-stabilization is the coloring of graphs [7]. A nodecoloring (or simply a coloring) of a graph G(V , E ) is a function c : V → N such that c (i) 6= c (j) whenever i and j are adjacent. The elements of N are called the available colors. If a graph G may be colored using k colors, we say that it is k-colorable. The smallest

410

N. Guellati, H. Kheddouci / J. Parallel Distrib. Comput. 70 (2010) 406–415

Table 2 Self-stabilizing dominating set algorithms. Reference

Output

Required topology

System is anonymous

Daemon

Complexity

Hedetniemi et al. [28]-1 Hedetniemi et al. [28]-2 Xu et al. [69] Goddard et al. [20] Turau [67] Goddard et al. [24]

DS MDS MDS MTDS MDS MDS

Arbitrary Arbitrary Arbitrary Arbitrary Arbitrary Arbitrary

Yes Yes No No No No

Central Central Synchronous Central Distributed Distributed

O(n) steps O(n2 ) steps O(n) rounds

Kamei and Kakugawa [41]-1 Kamei and Kakugawa [41]-2 Huang et al. [36] Kamei and Kakugawa [42] Huang et al. [37]

MKDS MKDS M2DS MKDS M2DS

Tree Tree Arbitrary Arbitrary Arbitrary

Yes No Yes No No

Central Distributed Central Synchronous Distributed

O(n2 ) steps O(n2 ) steps O(n) steps O(n) rounds

integer k such that G is k-colorable is the chromatic number of G, denoted by χ (G). A coloring that uses k ≥ χ (G) colors is called a proper coloring. A coloring that uses χ(G) colors is called minimum coloring. A Grundy coloring of a graph is a proper coloring such that every node i has a neighbor of color r for all r, 1 ≤ r < c (i). 5.1. Coloring bipartite graphs One of the first self-stabilizing algorithms proposed for the coloring problem is the algorithm by Sur and Srimani [65]. This latter is semi-uniform, realizes a 2-coloring of a bipartite graph and assumes a central daemon. In this algorithm, a specific node is designated as a root, and the other nodes determine their distance from the root in a breadth-first manner. Then, nodes at even distance from the root color themselves black and nodes at odd distance from the root color themselves white. This coloring corresponds to a proper 2-coloring of the graph. Kosowski and Kuszner [46] proposed a semi-uniform algorithm for the 2-coloring of bipartite graphs, assuming a central daemon and an anonymous system. Here, the idea is slightly similar to the one used by Sur and Srimani to design their algorithm. Thus, firstly a spanning tree rooted to a specific node is constructed. Then, each node tries to take the minimum available color that satisfies the following two conditions: the color is not taken by a neighbor, and it is from a different class than the color of the parent of the node (in the spanning tree). Here, the set of available colors is partitioned into two classes, namely the class of odd colors and the class of even colors. Kosowski and Kuszner modified the previous algorithm so that it may work under a distributed daemon. Thus, the new version assumes the nodes to have globally unique identifiers, and a boolean variable is added (to each node) in order to allow mutual exclusion between neighboring nodes. Now, a node wanting to change its color will first change the value of its boolean variable to true. Then, it will change its color if its identifier is the smallest among all neighbors having their boolean variables set to true. It is to be noted that both of the algorithms proposed by Kosowski and Kuszner produce a coloring of any graph using at most 2∆ colors, within the same time complexity. 5.2. Coloring planar graphs Ghosh and Karaata [18] presented a uniform algorithm for coloring planar graphs with at most six colors. In fact, the solution described here is a combination of two algorithms, where the first generates a directed acyclic version of the planar graph, and the second colors the generated graph. In the coloring part, each node takes a color not taken by its successors in the directed acyclic graph. The authors firstly supposed composite atomicity and a central daemon. Then, a new version of the algorithm that works under a distributed daemon and a finer level of atomicity has been proposed.

O(n) steps O(n) steps

Huang et al. [33] revisited the problem of coloring planar graphs and proposed an algorithm having two layers like the one by Ghosh and Karaata. The first layer orders the nodes and the second layer colors the nodes by following the calculated order. In the coloring layer each node takes the minimum of available colors not taken by its neighbors with greater or equal order values. This algorithm works under a fair central daemon, it is uniform and produces a Grundy coloring. To measure the time complexity of their algorithm, the authors used the round measure and defined it to be the minimum time period in which every node is scheduled to execute at least once. 5.3. Coloring chains and rings Shukla et al. [61] studied the problem of developing uniform self-stabilizing algorithms for coloring anonymous chains and rings. They first proposed a uniform algorithm for the 2-coloring of a chain. The algorithm works as follows. Each node i maintains an integer variable Xi and keeps it at the value zero if i is at the extremity of the chain, or keeps it at the minimum value Xj of its neighbors plus one. Then, the color of a node i is Ci = Xi mod 2. This algorithm produces a 2-coloring of any odd chain under a distributed daemon. For even chains, however, the algorithm does not produce a proper 2-coloring under a central daemon, and moreover there is no uniform deterministic self-stabilizing algorithm that works under a distributed daemon for this problem. The second algorithm presented by Shukla et al. is uniform and produces a 3-coloring for any oriented ring under a central daemon. The idea of the algorithm is as follows. Each node maintains a variable that represents its color. If a node has the same color as its two neighbors, it will take the minimum of the available colors not taken by its neighbors. And, if a node has the same color as its left neighbor, it will take any other available color. Here, also, there is no uniform deterministic self-stabilizing algorithm that works under a distributed daemon for the 3-coloring for an oriented ring. However, a randomized solution can be designed for this problem. 5.4. Coloring arbitrary graphs Gradinariu and Tixeuil [26] presented a uniform algorithm for coloring any graph with at most (∆ + 1) colors. The algorithm works under a central daemon and assumes that the system is anonymous. It is also assumed that each node knows ∆, the maximum degree of the system’s communication graph. In this algorithm the nodes always try to take the maximum color from the set {0, . . . , ∆} which is not taken by a neighbor. So, after stabilization we obtain a proper coloring of the system’s communication graph. Gradinariu and Tixeuil modified the previous algorithm so that it may work under a distributed daemon in two ways. So, they presented two other uniform algorithms for coloring any graph with at most (∆+1) colors. In order to break the symmetry, the first algorithm assumes the nodes to have globally unique identifiers,

N. Guellati, H. Kheddouci / J. Parallel Distrib. Comput. 70 (2010) 406–415

411

Table 3 Self-stabilizing coloring algorithms. Reference

Required topology

System is anonymous

Daemon

Complexity

Sur and Srimani [65] Kosowski and Kuszner [46]-1 Kosowski and Kuszner [46]-2

Bipartite graph Bipartite graph Bipartite graph

Yes Yes No

Central Central Distributed

O(mn3 d) steps O(mn3 ∆d) steps

Ghosh and Karaata [18] Huang et al. [33]

Planar graph Planar graph

No Yes

Distributed Central

O(d) rounds

Shukla et al. [61]-1 Shukla et al. [61]-2

Odd chain Oriented ring

Yes Yes

Distributed Central

Gradinariu and Tixeuil [26]-1 Gradinariu and Tixeuil [26]-2 Gradinariu and Tixeuil [26]-3 Hedetniemi et al. [30]-1 Hedetniemi et al. [30]-2 Goddard et al. [23]

Arbitrary Arbitrary Arbitrary Arbitrary Arbitrary Arbitrary

Yes No Yes Yes Yes Yes

central Distributed Distributed Central Central Central

Matching

Maximal matching

1–maximal matching

O(n∆) steps O(n∆) steps O(n∆) steps O(m) steps O(n) steps

2– matching (generalized matching)

Fig. 3. Examples of matchings (the shaded edges denote the elements of the matchings).

and the second uses randomization. In the first algorithm, a node that has the same color as one of its neighbors changes its color only if its identifier is maximal among all identically colored neighbors. And in the second algorithm, a node that has the same color as one of its neighbors tosses a coin before changing its color. Hedetniemi et al. [30] presented a uniform algorithm for a Grundy coloring of any graph using at most (∆ + 1) colors. The algorithm is designed for an anonymous system and assumes a central daemon. In this algorithm, each node maintains an integer that represents its color. The nodes always try to take the minimum color not taken by any neighbor, which produces a Grundy coloring. In the same paper and using the same assumptions, Hedetniemi et al. presented another uniform algorithm for coloring any graph with at most (∆ + 1) colors. In this algorithm a node changes its color if it is not properly colored or its color is greater than its degree plus one. A node i that wants to change its color takes any available color from the set {1, 2, . . . , deg (i)}; otherwise, it takes the color deg (i) + 1. This algorithm is fast, since it stabilizes after at most n steps. Thus, it is the first linear time self-stabilizing algorithm for the proper coloring of any graph. In [23] Goddard et al. investigated a problem, which has strong connection with the coloring problem, called the k-forward numbering of graphs. This latter consists in assigning integers to the nodes, such that no node will have more than k neighbors with larger assigned values. The authors, first, proposed some selfstabilizing algorithms to find a k-forward numbering, and then extended one of these algorithms by adding a coloring layer, and obtained a self-stabilizing uniform algorithm for k-coloring arbitrary graphs. This algorithm works under a central daemon and assumes an anonymous system. In the coloring layer, a node always tries to take a color that is not taken by a neighbor with larger assigned integer. 5.5. Discussion Table 3 summarizes the algorithms presented in this section. The proposed algorithms of coloring bipartite graphs and odd chains use only two colors, which is optimal. The other algorithms,

however, do not produce an optimal coloring. The two algorithms of coloring planar graphs, for example, use at most six colors while planar graphs have been proved to be five-colorable. The coloring algorithms proposed by Gradinariu and Tixeuil as well as those of Hedetniemi et al. use at most (∆ + 1) colors; however, unlike the former algorithms, the latter algorithms do not assume the knowledge of ∆ by each node. It is to be noted that some coloring algorithms produce an MIS. This is true for any Grundy coloring algorithm, since the set of nodes having the smallest color form an MIS. These two problems are, in fact, closely related and achieve similar bounds [16]. Some bounds on the time complexity of distributed graph algorithms have been established in the literature, and they obviously apply to self-stabilizing graph algorithms. We may cite here a lower bound for the (∆ + 1)-coloring which is q Ω (log∗ n)[51], and a lower bound for the MIS problem which is Ω

log n loglog n

[48].

6. Matching algorithms We can find in the literature a considerable number of selfstabilizing algorithms for the matching problem [7]. A matching (Fig. 3) in a graph G(V , E ) is a set M of independent (pairwise nonadjacent) edges. A matching M is maximal if no proper superset of M is also a matching. A matching of a graph G is called maximum matching if it has largest cardinality among all possible matchings in G. A node that is incident with an edge of a matching M is called matched, and nodes not incident with any edge of M are called unmatched. A set M ⊆ E of edges is called a generalized matching (or a b-matching) of G if, for all nodes i ∈ V , |Ei ∩ M | ≤ b, where Ei is the set of edges incident with i. An alternating path in a graph G(V , E ), with respect to a matching M, is a path whose edges are alternately in M and in (E − M). An alternating path is an augmenting path if the first and the last edges are in (E − M). 6.1. Maximal matchings The first self-stabilizing algorithm designed to calculate a maximal matching was published by Hsu and Huang [32]. The algorithm is uniform, works for an anonymous system, and assumes a central daemon. In this algorithm each node maintains a variable referred

412

N. Guellati, H. Kheddouci / J. Parallel Distrib. Comput. 70 (2010) 406–415

to as a pointer. This latter may be null or may point to a neighboring node. Two nodes are matched if they point at each other, so after stabilization, the pairs of matched nodes form a maximal matching. The algorithm works as follows. A node i that points to null will point to a neighbor j if this latter points to i or to null (which means that i accepts or proposes to be matched with j). Also, if a node i points to a node j that points to another node k, then i will change its pointer to null (which means that i withdraws a proposal of matching). Hsu and Huang showed that the time complexity of this algorithm is O(n3 ) steps. However, this upper bound is not tight, since Tel [66] has shown the upper bound to be O(n2 ) steps. Later, the time complexity was improved to O(m) steps by Hedetniemi et al. [29]. Chattopadhyay et al. [3] published a uniform algorithm that works under a distributed daemon and the read/write atomicity. It assumes each node to have a locally distinct identifier that distinguishes it from its neighbors within distance two. In this algorithm, each node tries to be matched with its neighbor having the minimum identifier. Since the read/write atomicity is assumed, each node must read the identifiers of its neighbors one by one before choosing a neighbor to be matched with. The authors extended this algorithm by a mechanism that randomly generates locally distinct identifiers, to obtain a version that works for an anonymous system. However, the new version requires the knowledge of ∆ (the maximum degree of the system’s communication graph) by the nodes. To calculate the time complexity, the authors used the round measure and defined it as the period in which every node executes at least one full iteration of its code. Goddard et al. [22] presented a synchronous version of the algorithm by Hsu and Huang. The new version requires globally unique identifiers for the nodes and works in mobile ad hoc networks. The authors also assume the number of nodes to remain unchanged during execution, and the system’s communication graph to remain connected despite the mobility of the nodes. Also, the communication is supposed to be performed thought beacon messages transmitted periodically in the ad hoc network. Note that these same assumptions have been considered with MIS and MDS algorithms presented previously in this survey. Goddard et al. [19] presented a uniform algorithm for finding a generalized maximal matching (b-matching) in an arbitrary graph. The algorithm works under a central daemon and assumes an anonymous system. This algorithm is a generalization of the one by Hsu and Huang. So, each node i maintains a list of pointers that indicates, after stabilization, the set of neighbors matched with i. In this algorithm a node is allowed to accept a proposal of matching, if it is pointed to by a neighbor. Also, a node i may propose a matching by pointing to a neighbor j if both i and j have available space in their lists of pointers (the lists contain fewer than b pointers). And finally, a node may withdraw a proposal of matching if it points to a neighbor whose list if full (the list contains b pointers). Goddard et al. [25] presented a uniform algorithm for the 1maximal matching in anonymous trees assuming a central daemon. A maximal matching is said to be 1-maximal if its cardinality cannot be increased by removing an edge and adding two edges. This algorithm is also based on the solution of Hsu and Huang. In order to obtain a 1-maximal matching, the authors provided a mechanism for exchanging one edge of the matching by two when it is possible. The presented algorithm works also for rings with length not divisible by three. And for rings of length a multiple of three, there is no self-stabilizing deterministic anonymous algorithm for the 1-maximal matching problem. Recently, Manne et al. [53] presented a uniform algorithm for the maximal matching problem in an arbitrary graph. The authors assume node identifiers to be unique within distance two and a distributed daemon. Each node maintains two variables: a pointer (that may point to a neighbor or to null) and a boolean variable that

indicates whether the node is matched or not. In this algorithm, a node i will update its boolean variable if it contains an incorrect value; otherwise it will try to execute one of the following actions. (1) Proposing a matching by pointing to a non-matched neighbor having greater identifier. (2) Accepting a proposal of matching if the node is pointed to by a neighbor. (3) Withdrawing a proposal of matching (by pointing to null) if the node j, which i is pointing to, does not point back at i and j is either matched or has a lower identifier than i. Note that the identifiers are used here to avoid the creation of cycles of pointer values. 6.2. Maximum matchings Karaata and Saleh [45] presented an algorithm for finding a maximum matching in a tree. The algorithm works for an anonymous system and assumes a central daemon. It works in two phases. First, the tree is converted to one or two directed trees rooted at one or two nodes that are the centers of the tree, by using the algorithm of Bruell et al. [1]. The second phase is executed in several steps: in each step a matching containing the pendant edges is constructed, and all pendant edges along with edges adjacent to them are discarded. The second phase ends when all edges are discarded and the system converges to a maximum matching. A second algorithm has been proposed by Chattopadhyay et al. in [3] for the maximum matching problem. Contrary to their maximal matching algorithm, the new one assumes composite atomicity. It is uniform and works for anonymous bipartite graphs under a central daemon. The algorithm assumes also that each node knows its bipartition and some upper bound on the number of nodes in the system’s communication graph. This algorithm is motivated by a sequential one based on the following well-known result: a matching M in a graph G is maximum if and only if there is no augmenting path in G with respect to M (Berge 1957). Thus, in the present algorithm, if the matching is not maximum, an augmenting path is detected (by the nodes), and then augmentation along this path is performed to increase the size of the matching by one. 6.3. Discussion Table 4 summarizes the matching algorithms presented in this section. As we can see, the algorithm of Hsu and Huang, the first to be proposed, has inspired a lot of later works. When its complexity was improved two times, Goddard et al. proposed a synchronous version, a generalization, and an algorithm for finding 1-maximal matching based on this algorithm. Even the recent solution by Manne et al. uses a similar pointing mechanism. It is also to be noted that the algorithm of Chattopadhyay et al. differs from the other algorithms by using the read/write atomicity. In fact, it is the only algorithm presented in this survey that uses this level of atomicity. This algorithm is of course better than the others from an implementation point of view. Finally, note that if maximum matching algorithms have been proposed, they work only for trees and bipartite graphs and not for arbitrary graphs. 7. Other algorithms Firstly, it is to be noted that a graph problem in a distributed system may be solved by collecting the topology of the system at each node and then computing locally. Such a general solution may be realized using an algorithm for topology update (e.g. Dolev [10]), but this way it is hard to achieve the efficiency of a solution designed for a specific problem. In the literature, there are some works on extensions of selfstabilization for quick convergence, tolerance to permanent faults, and other improvements. We can mention, for example, the concepts of fault containment and safe convergence. In this section,

N. Guellati, H. Kheddouci / J. Parallel Distrib. Comput. 70 (2010) 406–415

413

Table 4 Self-stabilizing matching algorithms. Reference

Output matching

Required topology

System is anonymous

Daemon

Complexity

Hsu and Huang [32] Chattopadhyay et al. [3]-1 Goddard et al. [22] Goddard et al. [19] Goddard et al. [25] Manne et al. [53]

Maximal Maximal Maximal Generalized 1-maximal Maximal

Arbitrary Arbitrary Arbitrary Arbitrary Tree Arbitrary

Yes No No Yes Yes No

Central Distributed Synchronous Central Central Distributed

O(m) steps O(n) rounds O(n) rounds O(m) steps O(n4 ) steps O(m) steps

Karaata and Saleh [45] Chattopadhyay et al. [3]-2

Maximum Maximum

Tree bipartite graph

Yes Yes

Central Central

O(n4 ) steps O(n2 ) rounds

we provide brief definitions of these concepts and we refer the reader to self-stabilizing graph algorithms designed according to these concepts, as well as to ordinary self-stabilizing algorithms for some variants of the domination, coloring, and matching problems. 7.1. Independence and domination The concept of fault containment of self-stabilizing algorithms was introduced by Ghosh et al. [17]. This idea is motivated by the fact that a self-stabilizing system may take a long time to stabilize even when only one node is faulty, due to the spread of the fault in the whole system. Thus, Ghosh et al. proposed to modify selfstabilizing algorithms in order to improve the stabilization time, in the case where the system is subject to only one transient fault. There exists, in the literature, a fault-containing self-stabilizing algorithm for finding an MIS. This algorithm was designed by Lin and Huang [49] by modifying the algorithm of Shukla et al. (presented previously). It has been shown that the stabilization time of the proposed algorithm is O(∆) steps in the single-fault situation, while Shukla et al.’s algorithm stabilizes in O(n) steps. Dolev and Tzachar [14] proposed a self-stabilizing and selforganizing algorithm for the MIS problem in asynchronous message-passing systems. Here, self-organization is defined as a property that guarantees sublinear convergence time and fast reaction to topology changes. It must be noted that self-stabilizing algorithms designed for message-passing systems are uncommon in the literature. In [40], Kakugawa and Masuzawa formally defined the concept of safe convergence. This property extends the concept of selfstabilization by providing the guarantee that a system quickly converges to a safe configuration (in which minimum quality of service is guaranteed), and then, the system moves to a configuration in which the service is optimal. Afterwards, the authors presented a self-stabilizing algorithm for the minimal dominating set (MDS) problem having the safe convergence property. By this algorithm, the system quickly moves to a safe configuration in which a dominating set is computed. Then, the system reaches an optimal configuration in which an MDS is obtained. A connected dominating set (CDS) of a graph G is a dominating set with the additional property that it induces a connected subgraph of G. Jain and Gupta [39] presented the first self-stabilizing algorithm for the CDS problem. The algorithm first finds a minimal dominating set, and then connects it. To find the MDS the authors used the algorithm by Xu et al. [69] presented in Section 4. Note that it is difficult to design a self-stabilizing algorithm for the minimal connected dominating set (MCDS) problem, since an incorrect configuration cannot be locally detected. Thus, no self-stabilizing algorithm is known to compute an MCDS. Kamei and Kakugawa [43] presented a self-stabilizing approximation algorithm for the minimum connected dominating set problem, assuming that a spanning tree is given. By using the same assumption, Srimani and Xu [63] proposed a self-stabilizing algorithm for the minimal weakly connected dominating set problem. Here, a weakly connected dominating set (WCDS) is a dominating set, such that the subgraph induced by the closed neighborhood

of the set is connected (the closed neighborhood of a set of nodes contains the elements of the set as well as their neighbors). Datta et al. [5] investigated the problem of finding a distance-k dominating set in an arbitrary graph. Here, a node that is member of the calculated set dominates all the nodes that are within distance k. Finding such a dominating set obviously produces a khop clustering. The basic idea of this algorithm is to construct some trees of radius k routed at the nodes having the smallest identifiers in the system. Finally, the roots of the trees constitute the distancek dominating set. Although Lin et al. [50] stated that it is hard to design a self-stabilizing algorithm for the minimal distance-k dominating set problem, they managed to design an algorithm for finding a minimal distance-2 dominating set. 7.2. Colorings All of the algorithms presented in Section 5 of this survey calculate a node-coloring of graphs. However, one may consider the coloring of the edges of a graph. The edge-coloring problem consists in assigning colors to the graph edges such that every two adjacent edges have different colors. A self-stabilizing algorithm for this problem has been proposed by Huang and Tzeng [34], and a second one has been proposed recently by Tzeng et al. [68]. This latter algorithm finds a (∆ + 4)-edge coloring in planar graphs, while the former algorithm is designed for bipartite graphs. In [6], Dekar and Kheddouci proposed a uniform algorithm for a special type of coloring called the b-coloring of graphs [47]. This latter is a proper k-coloring such that in each color class there exists a node having neighbors in all the other k − 1 color classes. Also, self-stabilizing algorithms have been proposed for other variants of the coloring problem, namely acyclic coloring [35], distance-2 coloring [4], and minimal sum coloring of graphs [64]. Self-stabilizing algorithms tolerate only transient faults, and no guarantee is given about their behavior against permanent faults. Thus, the study published by Nesterenko and Arora in [57] is oriented toward the design of self-stabilizing algorithms that tolerate permanent Byzantine faults, where a Byzantine node (which is subject to a Byzantine fault) can arbitrarily behave independently from its algorithm and may even behave maliciously. Such algorithms guarantee that the influence of Byzantine nodes will be contained to their neighborhood. The results obtained by Nesterenko and Arora include a self-stabilizing coloring algorithm tolerant to permanent Byzantine faults. Also, in [58] and [55] respectively, the authors presented self-stabilizing algorithms for edge-coloring of trees and arbitrary graphs that cope with Byzantine faults. Dolev and Herman [11] defined a superstabilizing algorithm to be a self-stabilizing algorithm that is guaranteed to satisfy a safety property when the system undergoes a topology change starting from a legitimate state. Afterwards, the authors proposed a superstabilizing coloring algorithm assuming read/write atomicity. 7.3. Matchings Self-stabilizing algorithms for variants of the matching problem have also been published. Goddard et al. [21] proposed an

414

N. Guellati, H. Kheddouci / J. Parallel Distrib. Comput. 70 (2010) 406–415

algorithm to find a maximal strong matching, where a matching is called strong if every matched node is adjacent to only one matched node. Another algorithm has been proposed by Manne and Mjelde [52] for the weighted matching problem. Here, the graph edges are considered to be weighted, and the objective is to find a matching such that the sum of the weights of the edges, in the matching, is as large as possible. Finally, Manne et al. [54] proposed an approximation algorithm for the maximum matching problem in an arbitrary graph. 8. Conclusion In this survey, we have collected references related to the work on self-stabilizing algorithms for independence, domination, coloring, and matching in graphs, trying to be as exhaustive as possible. We have outlined the algorithms and classified them so that works and their extensions will be in the same class. Thus, dominating set algorithms are classified according to the criterion of single or multiple domination, coloring algorithms are classified according to the required topology, and matching algorithms are classified depending on whether they calculate a maximal or a maximum matching. We have summarized the algorithms using the most important features, namely the assumed scheduler, the required topology, the time complexity, and the system anonymity. As we can see, there are numerous distributed self-stabilizing algorithms for the graph theoretic problems discussed in this survey. All of them have polynomial time complexity and a considerable number of them assume a distributed daemon. However, almost all of the algorithms assume composite atomicity and the shared memory model of communication, and very few algorithms work under models that are suitable for implementation. In fact, methods for transforming algorithms using strong assumption to algorithms using weak assumption exist in the literature: for example, from a fair daemon to an unfair daemon [44] and for atomicity refinement [56,2]. Even transformation from the shared memory to the message-passing model of communication has been investigated [12]. The existence of these methods is usually used by the authors to motivate designing self-stabilizing algorithms using strong assumption. However, algorithms working under a specific model are better than transformed algorithms in terms of complexity. Moreover, distributed graph algorithms are mainly used as building blocks in network protocols, and therefore using implementable models will produce algorithms that are efficient and easy to incorporate in network protocols. Finally, it is to be noted that even if we try to complete the reference list of this paper we cannot achieve this goal, since a graph algorithm may be treated as a subtask of a self-stabilizing algorithm and thus it may appear in any paper related to self-stabilization. References [1] S.C. Bruell, S. Ghosh, M.H. Karaata, S.V. Pemmaraju, Self-stabilizing algorithms for finding centers and medians of trees, SIAM Journal on Computing 29 (2) (1999) 600–614. [2] S. Cantarell, A.K. Datta, F. Petit, Self-stabilizing atomicity refinement allowing neighborhood concurrency, in: Proc. 6th International Symposium on SelfStabilizing Systems, 2003, pp. 102–112. [3] S. Chattopadhyay, L. Higham, K. Seyffarth, Dynamic and self-stabilizing distributed matching, in: Proc. 21st ACM Symposium on Principles of Distributed Computing, 2002, pp. 290–297. [4] P. Chaudhuri, H. Thompson, A self-stabilizing algorithm for L(2,1)-labeling trees, in: Proc. IASTED International Conference on Parallel and Distributed Computing and Networks, 2005, pp. 627–632. [5] A.K. Datta, L.L. Larmore, P. Vemula, A self-stabilizing O(k)-time k-clustering algorithm, Computer Journal (2009). [6] L. Dekar, H. Kheddouci, Distance-2 self-stabilizing algorithm for a b-coloring of graphs, in: Proc. 10th International Symposium on Stabilization, Safety, and Security of Distributed Systems, 2008, pp. 19–31. [7] R. Diestel, Graph Theory, third edition, Springer-Verlag, 2005.

[8] E.W. Dijkstra, Self-stabilizing systems in spite of distributed control, Communication of the ACM 17 (11) (1974) 643–644. [9] S. Dolev, Self-stabilization, MIT Press, 2000. [10] S. Dolev, Self-stabilizing routing and related protocols, Journal of Parallel and Distributed Computing 42 (2) (1997) 122–127. [11] S. Dolev, T. Herman, Superstabilizing protocols for dynamic distributed systems, Chicago Journal of Theoretical Computer Science 1997 (1997). [12] S. Dolev, A. Israeli, S. Moran, Resource bounds for self-stabilizing messagedriven protocols, SIAM Journal on Computing 26 (1) (1997) 273–290. [13] S. Dolev, A. Israeli, S. Moran, Self stabilization of dynamic systems assuming only read/write atomicity, Distributed Computing 7 (1) (1993) 3–16. [14] S. Dolev, N. Tzachar, Empire of colonies: Self-stabilizing and self-organizing distributed algorithm, Theoretical Computer Science 410 (6–7) (2009) 514–532. [15] F.C. Gartner, A Survey of Self-Stabilizing Spanning-Tree Construction Algorithms, Swiss Federal Institute of Technology Tech. Rep. IC/2003/38, School of Computer and Communication Sciences, Lausanne, Switzerland, 2003. [16] C. Gavoille, R. Klasing, A. Kosowski, L. Kuszner, A. Navarra, On the complexity of distributed graph coloring with local minimality constraints, Networks 54 (1) (2009) 12–19. [17] S. Ghosh, A. Gupta, T. Herman, S.V. Pemmaraju, Fault-containing selfstabilizing algorithms, in: Proc. 15th ACM Symposium on Principles of Distributed Computing, 1996. [18] S. Ghosh, M.H. Karaata, A self-stabilizing algorithm for coloring planar graphs, Distributed Computing 7 (1993) 55–59. [19] W. Goddard, S.T. Hedetniemi, D.P. Jacobs, P.K. Srimani, A robust distributed generalized matching protocol that stabilizes in linear time, in: Proc. 23rd International Conference on Distributed Computing Systems Workshops, 2003, pp. 461–465. [20] W. Goddard, S.T. Hedetniemi, D.P. Jacobs, P.K. Srimani, A self-stabilizing distributed algorithm for minimal total domination in an arbitrary system graph, in: Proc. 17th International Parallel and Distributed Processing Symposium, 2003. [21] W. Goddard, S.T. Hedetniemi, D.P. Jacobs, P.K. Srimani, Self-stabilizing distributed algorithm for strong matching in a system graph, in: Proc. 10th International Conference on High Performance Computing, 2003. [22] W. Goddard, S.T. Hedetniemi, D.P. Jacobs, P.K. Srimani, Self-stabilizing protocols for maximal matching and maximal independent sets for ad hoc networks, in: Proc. International Parallel and Distributed Processing Symposium, 2003. [23] W. Goddard, S.T. Hedetniemi, D.P. Jacobs, P.K. Srimani, Fault tolerant algorithms for orderings and colorings, in: Proc. 18th International Parallel and Distributed Processing Symposium, 2004, pp. 174–182. [24] W. Goddard, S.T. Hedetniemi, D.P. Jacobs, P.K. Srimani, Z. Xu, Self-stabilizing graph protocols, Parallel Processing Letters 18 (1) (2008) 189–199. [25] W. Goddard, S.T. Hedetniemi, Z. Shi, An anonymous self-stabilizing algorithm for 1-maximal matching in trees, in: Proc. International Conference on Parallel and Distributed Processing Techniques and Applications, 2006, pp. 797–803. [26] M. Gradinariu, S. Tixeuil, Self-stabilizing vertex coloration and arbitrary graphs, in: Proc. 4th International Conference on Principles of Distributed Systems, 2000, pp. 55–70. [27] T.W. Haynes, S.T. Hedetniemi, P.J. Slater, Fundamentals of Domination in Graphs, Marcel Dekker, 1998. [28] S.M. Hedetniemi, S.T. Hedetniemi, D.P. Jacobs, P.K. Srimani, Self-stabilizing algorithms for minimal dominating sets and maximal independent sets, Computer Mathematics and Applications 46 (5–6) (2003) 805–811. [29] S.T. Hedetniemi, D.P. Jacobs, P.K. Srimani, Maximal matching stabilizes in time O(m), Information Processing Letters 80 (5) (2001) 221–223. [30] S.T. Hedetniemi, D.P. Jacobs, P.K. Srimani, Linear time self-stabilizing colorings, Information Processing Letters 87 (2003) 251–255. [31] T. Herman, Self-stabilization bibliography: Access guide, Working Paper WP-1, Chicago Journal of Theoretical Computer Science (2002). [32] S.C. Hsu, S.T. Huang, A self-stabilizing algorithm for maximal matching, Information Processing Letters 43 (2) (1992) 77–81. [33] S.T. Huang, S.S. Hung, C.H. Tzeng, Self-stabilizing coloration in anonymous planar networks, Information Processing Letter 95 (2005) 307–312. [34] S.T. Huang, C.H. Tzeng, Distributed edge coloration for bipartite networks, in: Proc. 8th International Symposium on Stabilization, Safety, and Security of Distributed Systems, SSS’06, 2006, pp. 363–377. [35] S.T. Huang, Y.H. Wang, Self-stabilizing acyclic coloring of graphs, in: Proc. IASTED International Conference on Parallel and Distributed Computing and Networks, 2004. [36] T.C. Huang, C.Y. Chen, C.P. Wang, A linear-time self-stabilizing algorithm for the minimal 2-dominating set problem in general networks, Journal of Information Science and Engineering 24 (1) (2008) 175–187. [37] T.C. Huang, J.C. Lin, C.Y. Chen, C.P. Wang, A self-stabilizing algorithm for finding a minimal 2-dominating set assuming the distributed demon model, Computers & Mathematics with Applications 54 (3) (2007) 350–356. [38] M. Ikeda, S. Kamei, H. Kakugawa, A space-optimal self-stabilizing algorithm for the maximal independent set problem, in: Proc. 3rd International Conference on Parallel and Distributed Computing, Applications and Technologies, 2002. [39] A. Jain, A. Gupta, A distributed self-stabilizing algorithm for finding a connected dominating set in a graph, in: Proc. 6th International Conference on Parallel and Distributed Computing Applications and Technologies, 2005, pp. 615–619.

N. Guellati, H. Kheddouci / J. Parallel Distrib. Comput. 70 (2010) 406–415 [40] H. Kakugawa, T. Masuzawa, A self-stabilizing minimal dominating set algorithm with safe convergence, in: Proc. 20th International Parallel and Distributed Processing Symposium, 2006. [41] S. Kamei, H. Kakugawa, A self-stabilizing algorithm for the distributed minimal k-redundant dominating set problem in tree network, in: Proc. 4th International Conference on Parallel and Distributed Computing, Applications and Technologies, 2003. [42] S. Kamei, H. Kakugawa, A self-stabilizing approximation algorithm for the distributed minimum k-domination, IEICE Transactions on Fundamentals of Electronics Communications and Computer Sciences E88-A (5) (2005) 1109–1116. [43] S. Kamei, H. Kakugawa, A self-stabilizing distributed approximation algorithm for the minimum connected dominating set, in: Proc. 21st International Parallel and Distributed Processing Symposium, 2007, pp. 1–8. [44] M.H. Karaata, Self-stabilizing strong fairness under weak fairness, IEEE Transactions on Parallel and Distributed Systems 12 (4) (2001) 337–345. [45] M.H. Karaata, K.A. Saleh, A distributed self-stabilizing algorithm for finding maximum matching, Computer Systems Science and Engineering 15 (3) (2000) 175–180. [46] A. Kosowski, L. Kuszner, Self-stabilizing algorithms for graph coloring with improved performance guarantees, in: Proc. 8th International Conference on Artificial Intelligence and Soft Computing, 2006, pp. 1150–1159. [47] J. Kratochvil, Z. Tuza, M. Voigt, On the b-chromatic number of graphs, in: Proc. 28th International on Graph-Theoretic Concepts in Computer Science, 2002, pp. 310–320. [48] F. Kuhn, T. Moscibroda, R. Wattenhofer, What cannot be computed locally! in: Proc. 23rd Annual ACM Symposium on Principles of Distributed Computing, 2004, pp. 300–309. [49] J.C. Lin, T.C. Huang, An efficient fault-containing self-stabilizing algorithm for finding a maximal independent set, IEEE Transactions on Parallel and Distributed Systems 14 (8) (2003) 742–754. [50] J.C. Lin, T.C. Huang, C.P. Wang, C.Y. Chen, A self-stabilizing algorithm for finding a minimal distance-2 dominating set in distributed systems, Journal of Information Science and Engineering 24 (6) (2008) 1709–1718. [51] N. Linial, Locality in distributed graph algorithms, SIAM Journal on Computing 21 (1992) 193–201. [52] F. Manne, M. Mjelde, A self-stabilizing weighted matching algorithm, in: Proc. 9th International Symposium on Stabilization, Safety, and Security of Distributed Systems, 2007, pp. 383–393. [53] F. Manne, M. Mjelde, L. Pilard, S. Tixeuil, A new self-stabilizing maximal matching algorithm, in: Proc. 14th International Colloquium on Structural Information and Communication Complexity, 2007, pp. 96–108. [54] F. Manne, M. Mjelde, L. Pilard, S. Tixeuil, A self-stabilizing 2/3-approximation algorithm for the maximum matching problem, in: Proc. 10th International Symposium on Stabilization, Safety, and Security of Distributed Systems, 2008. [55] T. Masuzawa, S. Tixeuil, A self-stabilizing link coloring algorithm resilient to unbounded byzantine faults in arbitrary networks, in: Proc. 9th International Conference on Principles of Distributed Systems, December 2005. [56] M. Nesterenko, A. Arora, Stabilization-preserving atomicity refinement, Journal of Parallel and Distributed Computing 62 (5) (2002) 766–791. [57] M. Nesterenko, A. Arora, Tolerance to unbounded byzantine faults, in: Proc. 21st IEEE Symposium on Reliable Distributed Systems, 2002. [58] Y. Sakurai, F. Ooshita, T. Masuzawa, A self-stabilizing link-coloring protocol resilient to byzantine faults in tree networks, in: Proc. 8th International Conference on Principles of Distributed Systems, 2004.

415

[59] M. Schneider, Self-stabilization, ACM Computing Surveys 25 (1) (1993) 45–67. [60] Z. Shi, W. Goddard, S.T. Hedetniemi, An anonymous self-stabilizing algorithm for 1-maximal independent set in trees, Information Processing Letters 91 (2) (2004) 77–83. [61] S.K. Shukla, D.J. Rosenkrantz, S.S. Ravi, Developing self-stabilizing coloring algorithms via systematic randomization, in: Proc. 1st International Workshop on Parallel Processing, 1994, pp. 668–673. [62] S.K. Shukla, D.J. Rosenkrantz, S.S. Ravi, Observations on self-stabilizing graph algorithms for anonymous networks, in: Proc. 2nd Workshop on SelfStabilizing Systems, 1995. [63] P.K. Srimani, Z. Xu, Self-stabilizing algorithms of constructing spanning tree and weakly connected minimal dominating set, in: Proc. 27th International Conference on Distributed Computing Systems Workshops, 2007. [64] H. Sun, B. Effantin, H. Kheddouci, A self-stabilizing algorithm for the minimum color sum of a graph, in: Proc. 9th International Conference on Distributed Computing and Networking, 2008, pp. 209–214. [65] S. Sur, P.K. Srimani, A self-stabilizing algorithm for coloring bipartite graphs, Information Sciences 69 (1993) 219–227. [66] G. Tel, Maximal matching stabilizes in quadratic time, Information Processing Letters 49 (6) (1994) 271–272. [67] V. Turau, Linear self-stabilizing algorithms for the independent and dominating set problems using an unfair distributed scheduler, Information Processing Letters 103 (3) (2007) 88–93. [68] C.H. Tzeng, J.R. Jiang, S.T. Huang, A self-stabilizing (∆ + 4)-edge-coloring algorithm for planar graphs in anonymous uniform systems, Information Processing Letters 101 (4) (2007) 168–173. [69] Z. Xu, S.T. Hedetniemi, W. Goddard, P.K. Srimani, A synchronous selfstabilizing minimal domination protocol in an arbitrary network graph, in: Proc. 5th International Workshop on Distributed Computing, 2003.

Nabil Guellati received his engineer degree in computer science from the University of Ferhat Abbas (Setif, Algeria) in 2004, and his master’s degree in computer science from the University of Abderrahmane Mira (Bejaia, Algeria) in 2007. He is currently a Ph.D. candidate in the Department of Computer Science, Abderrahmane Mira University. He is working as part-time lecturer at the department of computer science, Ferhat Abbas University. His research interest is self-stabilizing algorithms.

Hamamache Kheddouci is currently a professor in computer science at Claude Bernard University Lyon, France. He spent five years at Burgundy University, Dijon as an associate professor in computer science. He received his Ph.D. degree from Paris-XI University, Orsay, in January 1999. His research involves graphs, algorithms and applications (see http://www710.univ-lyon1.fr/hkheddou).