Distributed Clustering for Ad Hoc Networks Stefano Basagni Center for Advanced Telecommunications Systems and Services (CATSS) Erik Jonsson School of Engineering and Computer Science The University of Texas at Dallas E-mail: basagni@utdallas.edu Abstract A Distributed Clustering Algorithm (DCA) and a Distributed Mobility-Adaptive Clustering (DMAC) algorithm are presented that partition the nodes of a fully mobile network (ad hoc network) into clusters, thus giving the network a hierarchical organization. Nodes are grouped by following a new weight-based criterion that allows the choice of the nodes that coordinate the clustering process based onnode mobility-related parameters. The DCA is suitable for clustering \quasistatic" ad hoc networks. It is easy to implement and its time complexity is proven to be bounded by a network parameter that deps on the topology of the network rather than on its size, i.e., the invariant number of the network nodes. The DMAC algorithm adapts to the changes in the network topology due to the mobility of the nodes, and it is thus suitable for any mobile environment. Both algorithms are executed ateach node with the sole knowledge of the identity of the one hop neighbors, and induce on the network the same clustering structure. 1. Introduction Obtaining a hierarchical organization of a network is a well-known and important problem in the eld of wired networks. In the case of ad hoc networks, i.e., wireless networks in which possibly all nodes can be mobile, partitioning the nodes into groups (clusters ) is similarly important. For example, clustering may be used for controlling the spatial reuse of the shared channel (e.g., in terms of time division or frequency division schemes), for minimizing the amount of data to be exchanged in order to maintain routing and control This work was supported in part by the TxTEC Consortium 1998/1999 Fellowship. The author is also indebted to Marco Monguzzi for collaborating on an earlier version of the paper. information in a mobile environment, as well as for building and maintaining cluster-based virtual network architectures. The notion of cluster organization has been used for ad hoc networks since their appearance. In [1, 2,4, 5], a \fully distributed linked cluster architecture" is introduced mainly for hierarchical routing and to demonstrate the adaptability of the network to connectivity changes. With the advent ofmultimedia communications, the use of the cluster architecture for ad hoc networks has been revisited by Gerla et. al. [6, 7]. In these latter works the emphasis is toward the allocation of resources, namely, bandwidth and channel, to support multimedia trac in an ad hoc environment. In existing solutions for clustering of ad hoc networks, the clustering is performed in two phases: clustering set up and clustering maintenance. The rst phase is accomplished by choosing some nodes that act as coordinators of the clustering process (clusterheads). Then a cluster is formed by associating a clusterhead with some of its neighbors (i.e., nodes within the clusterhead's transmission range) that become the ordinary nodes of the cluster. The existing clustering algorithms dier on the criterion for the selection of the clusterheads. For example, in [2, 5, 7] the choice of the clusterheads is based on the unique identier (ID) associated to each node: the node with the lowest ID is selected as clusterhead, then the cluster is formed by that node and all its neighbors. The same procedure is repeated among the remaining nodes, until each node is assigned to a cluster. When the choice is based on the maximum degree (i.e., the maximum number of neighbors) of the nodes, the algorithm described in [6] is obtained. A common assumption for the clustering set up is that the nodes do not move while the cluster formation is in progress. This is a major drawback, since in real ad hoc situations, no assumptions can be made on the mobility of the nodes. Once the nodes are partitioned into clusters, the non
mobility assumption is released, and techniques are described on how to maintain the cluster organization in the presence of mobility (clustering maintenance). For instance, in [1, 2] a reorganization of the clusters, due to node mobility, is done periodically, just invoking the clustering process again (as at set up time). Of course, during the re-clustering process the network cannot rely on the cluster organization. Thus, this is a feasible solution only when the network does not need too many reorganizations. In [7] cluster maintenance in the presence of mobility is described where each node v decides locally whether to update its cluster or not. This decision is based on the knowledge of the v's one and two hop neighbors and on the knowledge of the local topology of v's neighbor with the largest degree. The resulting mobility-adaptive algorithm is thus dierent from the one used for the cluster formation (based on the nodes' IDs and on the knowledge of their one hop neighbors) and the obtained clustering has dierent properties with respect to the initial one. In this paper we are interested in either phases of the clustering process under the common perspective of some desirable clustering properties. Specically, given the wireless, mobile nature of ad hoc networks, the need arises for each ordinary node 1) to have at least a neighboring clusterhead (this will allow fast communications among any pairs of nodes), and 2) to be aliated with the \best" neighboring clusterhead. Moreover, 3) we do not want tohave neighboring clusterheads, so that the clusterheads are well scattered throughout the network. In the following we describe two algorithms for the set up and the set up/maintenance of a clustering organization of any adhocnetwork that have easy and ecient distributed implementations, and that satisfy the requirements described above. The rst algorithm, the Distributed Clustering Algorithm (DCA), is a common generalization of the algorithms for the (sole) clustering set up presented, e.g., in [1] and [7]. These previous approaches are generalized by allowing the choice of the clusterheads based on a generic weight (a real number 0) associated with each node: The bigger the weight of a node, the better that node for the role of clusterhead. The main advantage of this approach is that, by representing with the weights mobility-related parameters of the nodes, we can choose for the role of clusterhead those nodes that are better suited for that role. An interesting result here, is that the time complexity of the DCA is bounded by a network parameter that deps on the network topology (that may change due to nodes mobility) rather than on the size of the network, i.e., the invariant number of its nodes (as in [7]). Although our algorithm can be used in the presence of nodes' mobility (using, for instance, the periodical re-clustering as described in [1]), the DCA is mainly suitable for ad hoc networks whose nodes do not move ormove \slowly" (\quasi-static" networks). For (possibly highly) mobile networks weintroduce the Distributed Mobility-Adaptive Clustering (DMAC) algorithm. By executing the DMAC routines, each node reacts locally to any variation in the surrounding topology, changing its role (either clusterhead or ordinary node) accordingly. The DMAC is proven to meet the three requirements of ad hoc clustering regardless of the mobility of the nodes, thus creating and maintaining the same clusters produced by the DCA. Moreover, for our algorithm, we obtain the following properties, not available in previous solutions: As for the DCA, the selection of the clusterheads is based on the new weight-based criterion, thus having the possibility to express preferences on which nodes are better suited to be clusterheads. Nodes can move, even during the clustering set up. (DMAC is adaptive to the changes in the topology of the network, due to the mobility of the nodes or to node addition and/or removal.) A node decides its own role (clusterhead or ordinary node) solely knowing its current one hop neighbors (as opposed to the knowledge of one and two hop neighbors as required by previous algorithms). We conclude this section by stipulating some basic denitions and dening the problem of clustering more precisely. We model an ad hoc network by an undirected graph G =(V; E) in which V, jv j = n, is the set of (wireless) nodes and there is an edge fu; vg 2E if and only if u and v can mutually receive each others' transmission (this implies that all the links between the nodes are bidirectional). In this case we say that u and v are neighbors. The set of the neighbors of anodev 2 V will be denoted by,(v). Due to mobility, the graph can change in time. Every node v in the network is assigned a unique identier (ID). For simplicity, here we identify each node with its ID and we denote both with v. Finally, we consider weighted networks, i.e., a weight w v (a real number 0) is assigned to each node v 2 V of the network. For the sake ofsimplicity, in this paper we stipulate that each node has a dierent weight. As an example, the topology of a simple ad hoc network is shown in Figure 1 (a). Clustering an ad hoc network means partitioning its nodes into clusters, each one with a clusterhead and (possibly) some ordinary nodes. The choice of the clusterheads is here based on the weight associated to each
4 (9) 5 (8) 1 (6) 2 (3) (a) 3 (2) 8 (1) 6 (1) 7 (5) Figure 1. (a) An ad hoc network G with nodes v and their weights (w v ), 1 v 8, and(b)a correct clustering for G. node: the bigger the weight of a node, the better that node for the role of clusterhead. In order to meet the requirements imposed by the wireless, mobile nature of these networks, a clustering algorithm is required to partition the nodes of the network so that the following ad hoc clustering properties are satised: 1. Every ordinary node has at least a clusterhead as neighbor (dominance property). 2. Every ordinary node aliates with the neighboring clusterhead that has the bigger weight. 3. No two clusterheads can be neighbors (indepence property). Furthermore, given the possibly frequent changes in the network topology due to nodes' mobility, the algorithm is required to be executed at each node (i.e., the algorithm should be distributed ) with the sole knowledge of the topology local to each node. Figure 1 (b) illustrates a correct clustering for the ad hoc network of Figure 1 (a) (the clusterheads of each cluster are the squared nodes). 2. A Distributed Clustering Algorithm (DCA) The DCA is executed at each node with the sole knowledge of the executing node's unique identier, ID, its weight, and the IDs and the weights of its neighbors (namely, the algorithm is distributed and relies only on local information). We also make the following common operational assumptions: a) A message sent by a node is received correctly within a nite time (a step ) by all its neighbors, and b) Network topology does not change during the algorithm execution. 1 Except for the initial routine, the algorithm is message driven: a specic procedure will be executed at a node deping on the reception of the corresponding 1 A detailed discussion on how to release these assumptions can be found, e.g., in [7]. 4 (9) 5 (8) 1 (6) 2 (3) (b) 3 (2) 8 (1) 6 (1) 7 (5) message. We use only two types of messages: Ch(v), used by anodev to make its neighbors aware that it is going to be a clusterhead, and Join(v; u), with which anodev communicates to its neighbors that it will be part of the cluster whose clusterhead is node u. The main idea is that a node decides which role to assume only when all its neighbors with bigger weights have decided their own roles. Every node starts the execution of the algorithm at the same time, running the procedure Init. Only those nodes that have the biggest weight among all the nodes in their neighborhood will s a Ch message (\init nodes"). Given the nature of the weights (real numbers), there always exists at least a node v that transmits the message Ch(v). All the other nodes just wait to receive a message. Then, we have the following two message triggered procedures: On receiving Ch. On receiving a Ch message from a neighbor u, nodev checks if it has received from all its neighbors z such that w z >w u, a Join(z; x) message. In this case, v will not receiveach message from these z, and u is the node with the biggest weight in v's neighborhood that has sent ach message. Thus, v joins u, and quits the algorithm execution (it already knows the cluster to which it belongs, i.e., its clusterhead). If there is still at least a node z, w z >w u, that has not sent a message yet, node v records that u sent a Ch message, and keeps waiting for a message from z. On receiving Join. On receiving a Join(u; t) message, node v checks if it has previously sent ach message. If this is the case, it checks if node u wants to join v's cluster (v = t). Then, if all v's neighbors z such that w z <w v have communicated their willingness to join a cluster, v quits the execution of the DCA. Notice that, in this case, node v does not care about its neighbors y (if any) such that w y >w v, because these nodes have surely joined a node x such that w x >w v (thus permitting v to be a clusterhead). If node v has not sent ach message, before deciding what its role is going to be, it needs to know what all the nodes z such that w z >w v have decided for themselves. If v has received a message from all such nodes, then it checks the nature of the messages received. If they are all Join messages, this means that all those neighbors z have decided to join a cluster as ordinary nodes. This implies that now v is the node with the biggest weight among the nodes (if any) that have still to decide what to do. In this case, v will be a clusterhead. At this point, v also checks if each neighbor y such that w y <w v has already joined another cluster. If this is the case, v quits the algorithm execution: it will be the clusterhead of a cluster with a single node. Alternatively, ifv has received at least a Ch message from z, then it joins
the cluster of the neighbor with the biggest weight that sentach message, and quits the execution of the DCA (a node always quits the algorithm execution as soon as it ss a Join message). As mentioned earlier, in order to decide whether it is going to be a clusterhead or an ordinary node, each node waits for the decision of all the neighboring nodes with bigger weight. This \waiting time" of each node can be dened as a function of the distance of a node from one of the init nodes. Clearly, this \blocking distance," D b, deps on the current topology of the network rather than on the number n of the nodes of the network. By the total ordering induced on the nodes by their weights, and through a simple inductive argument, we can prove the following result: Theorem 1 Each node of the network ss exactly one message within D b +1 steps. Since every ordinary node quits the execution of the DCA after sing a message, and since each clusterhead quits it as soon as it has received a Join from his neighboring ordinary nodes, it follows that: Corollary 1 The DCA terminates within D b +1 steps. This upper bound on the time complexity of the DCA improves on the O(n) upper bound presented in [7] in all those cases in which D b n. The following corollary states the (optimal, since each node needs to s at least a message) message complexity of the DCA. Corollary 2 The DCA message complexity is n. Detailed proofs, numerical results, and the proofs of correctness and of other properties of DCA-based clustering can be found in [3]. 3. DMAC: Distributed and Mobility- Adaptive Clustering In this section we describe a distributed algorithm for the set up and the maintenance of a cluster organization in the presence of nodes' mobility that satises the three ad hoc clustering properties. The main difference with the DCA outlined in the previous section consists in the fact that here we do not assume that during the clustering process the nodes of the network need not to move. This makes this algorithm suitable for both the clustering set up and its maintenance, which was not available in previous solutions. Adaptation to changes in the network topology is now made possible by letting each node to properly \react" not only to the reception of a message from other nodes, but also to the failure of a link with another node (possibly caused by a node failure, or by nodes' movements) or to the presence of a new link. In the description of the procedures of our Distributed and Mobility-Adaptive Clustering (DMAC) algorithm, we still assume that a message sent byanode is received correctly within a nite time (a step) by all its neighbors. We also assume that each node knows its own ID, its weight, its role (if it has already decided to be a clusterhead or an ordinary node) and the ID, the weight and the role of all its neighbors (if they have already decided their role). When a node has not yet decided what its role is going to be, it is considered as an ordinary node. Except for the procedure that each node executes as soon as it starts the clustering operations, as in the case of DCA, the algorithm is message driven. Here, we use the same two types of messages used in the DCA (namely, Ch(v) and Join(v; u)). In the following we use Cluster (v) and Clusterhead to indicate the set of nodes in the cluster whose clusterhead is v and the clusterhead of a node's cluster, respectively. Finally, v's boolean variable Ch (v) is set to true if v has sent a Ch message. Furthermore, we assume that: Every node is made aware of the failure of a link, or of the presence of a new link by a service of a lower level (this will trigger the execution of the corresponding procedure); The procedures of DMAC (M-procedures, for short) are \atomic," i.e., they are not interruptible; At clustering set up or when a node is added to the network its variables Clusterhead, Ch (,), and Cluster (,) are initialized to nil, false and ;, respectively. The following is the description of the six M-procedures as executed at each node v. Init. At the clustering set up, or when a node v is added to the network, it executes the procedure Init in order to determine its own role. If among its neighbors there is at least a clusterhead with bigger weight, then v will join it. Otherwise it will be a clusterhead. Notice that a neighbor with a bigger weight that has not decided its role yet (this may happen at the clustering set up, or when two or more nodes are added to the network at the same time), will eventually s a message (every node executes the Init procedure). If this message is a Ch message, then v will aliate with the new clusterhead. procedure Init ; if fz 2,(v) :w z >w v ^ Ch (z)g 6= ; then x := max wz>w v fz : Ch (z)g; s Join(v,x);
; Clusterhead := x else s Ch(v); Ch (v) :=true; Clusterhead := v; Cluster (v) :=fvg Link failure. Whenever made aware of the failure of the link with a node u, node v checks if its own role is clusterhead and if u used to belong to its cluster. If this is the case, v removes u from Cluster (v). If v is an ordinary node, and u was its own clusterhead, then it is necessary to determine a new role for v. To this aim, v checks if there exists at least a clusterhead z 2,(v) such that w z >w v. If this is the case, then v joins the clusterhead with the bigger weight, otherwise it becomes a clusterhead. procedure Link failure (u); ; if Ch (v) and (u 2 Cluster (v)) then Cluster (v) :=Cluster (v) nfug else if Clusterhead = u then if fz 2,(v) :w z >w v ^ Ch (z)g 6= ; then else x := max wz>w v fz : Ch (z)g; s Join(v,x); Clusterhead := x s Ch(v); Ch (v) :=true; Clusterhead := v; Cluster (v) :=fvg New link. When node v is made aware of the presence of a new neighbor u, itchecks if u is a clusterhead. If this is the case, and if w u is bigger than the weight ofv's current clusterhead, than, indepently of its own role, v aliates with u. procedure New link (u); ; if Ch (u) then if (w u >w Clusterhead ) then s Join(v,u); Clusterhead := u; if Ch (v) then Ch (v) :=false On receiving Ch(u). When a neighbor u becomes a clusterhead, on receiving the corresponding Ch message, node v checks if it has to aliate with u, i.e., it checks whether w u is bigger than the weight of v's clusterhead or not. In this case, indepently of its current role, v joins u's cluster. On receiving Ch(u); ; if (w u >w Clusterhead s Join(v,u); Clusterhead := u; ) then if Ch (v) then Ch (v) :=false On receiving Join(u,z). On receiving the message Join(u,z), the behavior of node v deps on whether it is a clusterhead or not. In the armative, v has to check if either u is joining its cluster (z = v: in this case, u is added to Cluster (v)) or if u belonged to its cluster and is now joining another cluster (z 6= v: in this case, u is removed from Cluster (v)). If v is not a clusterhead, it has to check ifu was its clusterhead. Only if this is the case, v has to decide its role: It will join the biggest clusterhead x in its neighborhood such that w x >w v if such a node exists. Otherwise, it will be a clusterhead. On receiving Join(u; z); ; if Ch (v) then if z = v then Cluster (v) :=Cluster (v) [fug else if u 2 Cluster (v) then Cluster (v) :=Cluster (v) nfug else if Clusterhead = u then if fz 2,(v) :w z >w v ^ Ch (z)g 6= ; then x := max wz >w v fz : Ch (z)g; s Join(v,x); Clusterhead := x else s Ch(v); Ch (v) :=true; Clusterhead := v; Cluster (v) :=fvg We conclude this section by showing that by using the M-procedures we obtain and maintain for any ad hoc network a clustering that always satises the ad hoc clustering properties listed in the Introduction. Theorem 2 Using the M-procedures, any ad hoc network is (maintained) clustered in such a way that the ad hoc clustering properties are always satised. Proof We start by noticing that it is easy to check from the code of the Init procedure that as soon as a node has executed this procedure, it is always assigned a role which is consistent with the clustering properties. We proceed by showing that by executing the M- procedures in reaction to changes in the network topology, the nodes assume/change their roles so that the ad hoc clustering properties are always satised.
1. That each ordinary node v does not aliate with more that one clusterhead is evident by noticing that anytime it ss a Join(v; u) message its variable Clusterhead is initialized (only) to u. That v aliates with at least a clusterhead derives from the fact that when it has to decide its role, and there are clusterheads with bigger weights among its neighbors, or when a switch to another cluster is required, the ordinary node v always looks for the clusterhead with the biggest weight and aliates with it. This can be easily checked in the codes of: the Init procedure (then branch); the Link Failure and the On receiving Join(u; z) procedures (when the link with its clusterhead u is broken, or the clusterhead u is joining another node, v looks for another clusterhead; of course, if no clusterhead is available, it will be a clusterhead), and the New Link and the On receiving Ch(u) procedures (if u is the new clusterhead on the block, if node v needs to aliate with u, it does so by executing the then branch of the innermost if). Thus, there is no case in which an ordinary node v remains without a clusterhead. 2. At the clustering set up, or when a node is added to the (already clustered) network, or when its current clusterhead moves away, a node always aliates with the clusterhead with the biggest weight (if there is no such clusterhead, it will become a clusterhead itself), so that the second ad hoc clustering property is always satised (see the code of procedures Init, Link Failure and On receiving Join). The other cases to consider are when an ordinary node v switches from a cluster to another, or when v is a clusterhead that resigns to join the cluster of a new neighboring clusterhead. In these cases, the second property is guaranteed by the procedures New Link and On Receiving Ch, where node v switches to u's cluster only if w u >w Clusterhead. 3. Each time a node becomes a clusterhead, i.e., it transmits a Ch message (see the else branch of the if in the Init procedure, the else branch of the innermost if in the Link Failure procedure, and the same branch in the On receiving Join procedure), it does so because there is no other neighboring clusterhead with which it can aliate. The other cases that remain to be checked are when either a clusterhead v has one of its neighbors that becomes a clusterhead, or a clusterhead moves into its neighborhood, and the weight of the new neighbor does not force v to aliate with it. In both these cases, the third ad hoc clustering property is guaranteed by the execution of the else branch. Thus, the three properties for ad hoc clustering are always satised. 4. Conclusions This paper presented two distributed algorithms, DCA and DMAC, for the ecient partitioning of the nodes of an ad hoc wireless network into clusters with a clusterhead and some ordinary nodes. This is a practically important task, especially for all those network algorithms/applications that assume a mobilityadaptive hierarchical organization of the network. A new weight-based criterion is introduced for the cluster formation that allows the choice of the clusterheads based on node mobility-related parameters, not available in previous clustering algorithms. The proposed algorithms need only knowledge of the local topology at each node (one hop neighbors), and allows each ordinary node to have direct access to at least a clusterhead, thus guaranteeing fast inter- and intra-cluster communication between each pair of nodes. The DCA is easy to implement and its time complexity isproven to be bounded by a network parameter that deps on the possibly changing topology of the ad hoc network rather than on n, the invariant size of the network. The DMAC combines easiness of implementation with full adaptation to the mobility of the nodes, even during clustering set up. References [1] D. J. Baker and A. Ephremides. The architectural organization of a mobile radio network via a distributed algorithm. IEEE Transactions on Communications, COM-29(11):1694{1701, November 1981. [2] D. J. Baker, A. Ephremides, and J. A. Flynn. The design and simulation of a mobile radio network with distributed control. IEEE Journal on Selected Areas in Communications, SAC-2(1):226{237, January 1984. [3] S. Basagni. Distributed and mobility-adaptive clustering for ad hoc networks. Technical Report UTD/EE-02-98, Erik Jonsson School of Engineering and Computer Science, The University oftexas at Dallas, July 1998. [4] A. Ephremides. Design concepts for a mobile-user radio network. Computers & Electrical Engineering, 10(3):127{135, 1983. [5] A. Ephremides, J. E. Wieselthier, and D. J. Baker. A design concept for reliable mobile radio networks with frequency hopping signaling. Proceedings of the IEEE, 75(1):56{73, January 1987. [6] M. Gerla and J. T.-C. Tsai. Multicluster, mobile, multimedia radio network. Wireless Networks, 1(3):255{265, 1995. [7] C. R. Lin and M. Gerla. Adaptive clustering for mobile wireless networks. Journal on Selected Areas in Communications, 15(7):1265{1275, September 1997.