A Mutual Exclusion Algorithm for Ad Hoc Mobile Networks Jennifer E. Walter, Jennifer L. Welch, and Nitin H. Vaidya

Introduction Ad-Hoc Wireless Network – definition Mobility causes link failures. Unpredictable message delays Previous work – Routing protocols Broadcasting and Multicasting in Ad-Hoc wireless networks Use Ad-Hoc Routing, or take mobility into account.

Critical Section Problem Only one node may be in its critical section at a time. CS may be a block of code, or a resource. There should be no starvation. The CS must be granted only by request. Typical algorithms may be inefficient if run on an Ad-Hoc wireless network.

The General Approach Impose a logical DAG on the network. The token circulates in the network. All nodes in the DAG “point” toward the node that is holding the token. Based on Raymond’s token-based ME algorithm, which was based on a static spanning tree. Here, the DAG is dynamic.

The Approach (Continued) Use a partial reversal technique to maintain DAG. Each node has height, chooses its lowest neighbor as the preferred link to the token holder. Each node keeps a local request queue.

Definitions There are n independent, mobile nodes, uniquely numbered 0, …, n – 1. Nodes are either in REMAINDER, WAITING, or CRITICAL sections. Nodes do not fail. Nodes are aware of link failures and recovery in the network. Communication is reliable on a per-hop basis, and incipient link failures are detectable. The network does not partition. All links are bidirectional.

Input and Output Events Request CS_i Release CS_i Recv_i(j, m) LinkUp_i(l) LinkDown_i(l) EnterCS_i Send_i(j, m) Application vs. Network Events

Constraints C_0 initial configuration C_k is based on C_{k – 1} and in_k, following the transition function’s rules. Times assigned to the steps are nondecreasing. If the execution is infinite, then the times must increase without bound. If there is a requestCS at node i, then the previous application event was a releaseCS. If there is a releaseCS at a node, then the last application event at that node must be an enterCS

Constraints (Con’t) For every EnterCS_i, there is a following ReleaseCS_i. Given link l joins i and j, iff linkUp_i(l) occurs at time t, then so does linkUp_j(l). The same is true of LinkDown. A linkdown event cannot occur while messages are in transit on l.

Variables in the Algorithm status = REMAINDER. N = set of neighboring nodes. myHeight(h1, h2, i) totally orders nodes. The DAG initially points at node 0, which starts with height (0, 0, 0). height(j) is the height of the neighboring nodes. tokenHolder = true if this node holds the token

Variables (Continued) next = i, if i holds the token, otherwise, it is the node on the lowest outgoing link. Q = Queue of requesting neighbors. Q is empty initially. receivedLI[j] = true. Has a linkInfo message been received from j, to which a token was recently sent. forming[j] = true only after LinkUp(j) and before LinkInfo message is received. formHeight[j] is an array of tuples storing the value of myHeight when new link to j is first detected. formHeight = myHeight in the beginning.

When node i requests access to the CS: status := WAITING Enqueue(Q, i) if (!tokenHolder) if (length(Q) = 1) ForwardRequest() else GiveTokenToNext() When node I releases the CS: if (length(Q) > 0) GiveTokenToNext() Status := REMAINDER

When Request(h) received at node i from node j. if (receivedLI[j]) height[j] := h if (myHeight < height[j]) Enqueue(Q, j) if (tokenholder) if (length(Q) > 0) and (status = REMAINDER) GiveTokenToNext() else // not the holder if (myHeight < height[k], for all k in N) RaiseHeight() else if ((Q = [j]) or (length(Q) > 0)and (myheight < height[next])) ForwardRequest() // reroute request

When failure of link to j detected at node i N := N – {j} Delete(Q, j) ReceivedLI[j] = true if (!tokenHolder) if (myHeight < height[k], for all k in N) RaiseHeight() // reroute request else if ((length(Q) > 0) and (next not in N)) ForwardRequest()

When formation of link to j detected at node i Send LinkInfo(myHeight) to j forming[j] := true formheight[j] := myHeight Procedure ForwardRequest() next := l in N, where height[l] <= height[j] for all j in N send Request(myHeight) to next

Procedure GiveTokentoNext() // Called when length(Q) > 0 next = dequeue(Q) if (next != i) tokenHolder := false height[next] = (myHeight.h1, myHeight.h2 – 1, next) ReceivedLI[next] := false Send Token(myHeight) to next if (length(Q) > 0) send Request(myHeight) to next else { status := CRITICAL Enter CS }

Procedure RaiseHeight() myHeight.h1 = 1 + min_{k in N} {height[k].h} s := {the set of l in N, height[l].h1 = myHeight.h1} if (s is not empty) myHeight.h2 = min_{l in s} height[l].h2 – 1 send LinkInfo(myHeight) to all k in set N. for all k in N such that (myHeight > height[k]) Delete(Q, k) if (length(Q) > 0) ForwardRequest()

Simulation Results 30 nodes, exponential rate of link failures and creations due to mobility exponential rate of requests compared only to Raymond’s algorithm no routing overhead taken into consideration did 4 tests, and this algorithm RL outperformed Raymond’s (RR) on only some of them.