Topology Management Ensuring Reliability in Delay Sensitive Sensor Networks with Arbitrary Node Failures

Abstract

The lifetime of a sensor network is influenced by the efficient utilization of the resource constrained sensor nodes. The tree-based data gathering offers good quality of service (QoS) for the running applications. However, data gathering at the sink reduces the network lifetime due to a fast failure of highly loaded nodes. Loss of connectivity and sensing coverage affect the performance of the applications that demand critical QoS. In this paper, a data gathering tree management scheme has been proposed to deal with arbitrary node failures in delay-sensitive sensor networks. A load-balanced distributed BFS tree construction procedure has been introduced for an efficient data gathering. Based on the initial tree construction, a tree maintenance scheme and an application message handler have been designed to ensure the reliable delivery of the application messages. The correctness of the proposed scheme has been verified both theoretically and with the help of simulation. The proposed scheme offers low overhead, enhanced network lifetime and good QoS in terms of delay and reliability of the application messages.

Appendix

1.1 Appendix 1: Proof for Lemma 1

Let for a primary node $u,\, parent(u) = v$. Therefore, $u$ has received a TOKEN message from node $v$ according to Algorithm 2. Let $\exists w \in Neighbor(u)$ such that $level(w) < level(v)$. Now, as node $w$ has established a path to the sink via its parent, it has updated the information to all its neighbors. During the tree construction, a node updates its neighborhood by either broadcasting a TOKEN (on receiving a TOKEN for the first time) or broadcasting an UPDATE message (on receiving a TOKEN with an improved level) according to Algorithms 2 and 3. In any case, node $u \in Neighbor(w)$ receives either a TOKEN or an UPDATE message from node $w$. If $u$ receives a TOKEN from $w$, it changes the parent from $v$ to $w$ according to lines 10–13 of Algorithm 2 and Algorithm 3. Similarly, if $u$ receives an UPDATE from $w$, it changes its parent from $v$ to $w$ according to lines 1-9 of Algorithm 4. Thus, in any case $u$ changes its parent from $v$ to $w$. Hence, if $w = parent(u)$, $level(w)$ is the minimum among all the nodes in $Neighbor(u)$.

1.2 Appendix 2: Proof for Lemma 2

Let there exists a path $\breve{P}_{(u,v)} = \{u, x_1, x_2, ..., x_n, v\}$ in the tree from $u$ to $v$ such that $u = parent(x_1), x_1 = parent(x_2), ..., x_n = parent(v)$. Now to form a cycle, the following two conditions must be satisfied.

• 1. $u \in Neighbor(v)$

• 2. $v = parent(u)$

From the assumption, node $v$ is a descendant of node $u$ in its rooted subtree. Thus $level(u) \,<\, level(v)$, and also, $level(u) < level(x_n)$. Let condition 1 is true, as $level(u) < level(parent(v))$, node $v$ will set $parent(v) = u$ according to Lemma 1. Thus condition 2 fails. Hence, no cycle can be formed in the tree.

1.3 Appendix 3: Proof for Theorem 2

On receiving a TOKEN for the first time, every node broadcast the TOKEN message at least once from Algorithm 2. Due to the level improvement a node may change its parent, which requires the broadcast of an UPDATE message. In the worst case, every node in the tree changes its parent once. Thus, every node in the tree broadcast two messages. Let, $\delta _v$ denote the degree of a node $v$. One broadcast from a single node $v$ costs a $\delta _v$ units of message transmissions. Thus, for the whole network, considering every node broadcast two messages in the worst case, the communication cost for the BFS tree construction is $Cost_{comm} = \sum _{v \in \mathbb {T}_V} 2 \times \delta _v = 4 \times \mathbb {T}_E$, which is essentially $O(\mathbb {T}_E|)$.

1.4 Appendix 4: Proof for Theorem 3

For the sake of simplicity, the theorem has been proved for $\xi =3$. Similar logic can be used for any $\xi$ value. Let $\xi =3$ and $|Child(u)| - |Child(v)| = 2$ for two nodes $u$ and $v$, where $level(u) = level(v)$ and $pChild(u) \cap pChild(v) \ne \phi$. Load balancing is required in this case. Therefore, $|Child(u)| > 1$ for node $u$ from the assumption. Thus, node $u$ will broadcast a CH_UPDATE message according to Algorithm 2 or Algorithm 4. Let $w \in Child(u)$ be a node such that it receive a CH_UPDATE from node $u$, and also, $w \in \{pChild(u) \cap pChild(v)\}$. Therefore, according to Algorithm 5, node $w$ sends an ADDME message to node $v$ (where $v \in altpSet(w)$ from the assumption). From the Condition C of load-balancing criteria, $|Child(v)| < \xi$ according to the assumption. On receiving an ADDME from node $w$, node $v$ sends it a POSADD as the condition in line 1 of Algorithm 6 is satisfied. Now, node $w$ calculates the threshold for child size of node $u$ as $\lceil (|Child(u)|/2)\rceil$. The alternate parent child size as received with the POSADD message, is estimated to be $csize = (|Child(u)| - 2) + 1$. Therefore, for $2 \le |Child(u)| \le 4$,

$$\begin{aligned}&(csize - \lceil (bFactor/2)\rceil ) =\\&\qquad \qquad \{(|Child(u)| - 1) - \lceil (|Child(u)|/2)\rceil \} < 1 \end{aligned}$$

If $|Child(u)| > 4,\, |Child(v)| \ge 3$. From the assumption ($\xi = 3$), load-balancing will not be possible according to the Condition C of the load-balancing criteria. Thus, node $w$ sends a REM message to its parent $u$ for final confirmation. Node $u$ sends a positive acknowledgment through a REM_ACK message to node $w$ as $|Child(u)| > csize$. Therefore, node $w$ changes its parent from node $u$ to node $v$ making $|Child(u)| = |Child(v)|$. Hence, proved.

1.5 Appendix 5: Proof for Theorem 4

In distributed message-passing environments, the termination of a set of algorithms is determined on the verification that every node has reached the stable state. A node is said to be reached the stable state at time $t$ if it does not transmit any control messages after time $t$. Let the node $u$ be called in pre-stable state at time $t$, if it does not send any control messages after time $t$. Proving every node in the tree will reach the stable state eventually suffices to prove that the proposed set of tree construction algorithms eventually terminates. Let $u$ be a node such that it receive a TOKEN message, and set its parent. If $u$ has chosen the correct parent, and also, in the balanced state, then it does not send any more control messages, and reaches the pre-stable state. However, it can receive some control messages from its neighbors. Otherwise, $u$ may wish to change its parent due to either an level improvement or the load-balancing requirement.

Case 1. Let node $u$ change the parent due to an level improvement. Thus, it receives either a better TOKEN or an UPDATE message with the improved level. $u$ changes the parent, and broadcast an UPDATE message in either of the cases. Thus, node $u$ reaches the pre-stable state at this point.

Case 2. Let node $u$ change parent due to the load-balancing requirement. On receiving a CH_UPDATE message from the parent, node $u$ sends an ADDME message to its alternate parent. If there is a provision for load-balancing from the alternate parent point of view, $u$ receives an ADDME, which in turn triggers the event of sending a REM message to the $parent(u)$. Finally, if the parent node also acknowledges the parent changing event of node $u$, $u$ receives a REM_ACK message from the parent node. Now, $u$ changes the parent, and finally, updates its neighbors by an UPDATE message broadcast. At this point of time, node $u$ reaches the pre-stable state. $addflag$ and $posflag$ are set to True, and never reset again such that a node can change its parent only once to fulfill the load-balancing criteria.

Let at time $t_i$, all the nodes in the tree reach the pre-stable state. Therefore, at time $t_j > t_i$, all the nodes in the tree will reach the stable state. Hence, proved.

1.6 Appendix 6: Proof for Theorem 5

Let $u$ be a node such that it change its parent due to the load-balancing requirement. Now, $u$ receives a $\xi -1$ number of CH_UPDATE messages according to Algorithm 2 and Algorithm 4, where $\xi$ is the average number of children for any intermediate node. On receiving a CH_UPDATE, $u$ sends a maximum $a$ number of ADDME messages, where $a = |altpSet(u)| \le |\{Neighbor(u) \setminus Child(u)\}|-1$. $u$ also receives an $a$ number of POSADD messages in response, in the worst case. However, $u$ sends only one REM to the parent, and receives only one REM_ACK as an acknowledgment. Finally, $u$ broadcast an UPDATE message. Therefore, the transmission of total messages at every node that changes the parent due to the load-balancing requirement is estimated to be $(\xi -1)_{CH\_UPDATE} + a_{ADDME} + a_{POSADD} + 1_{REM} + 1_{REM\_ACK} + \delta _{UPDATE}$ or $2 + 2\delta$ ($\delta$ denotes the degree of any node), assuming $2a = \delta$ and $\xi = 3$. If it is assumed that a $C$ number of nodes change their parents due to the load-balancing requirement, where $C < \frac{1}{2}\mathbb {T}_V$, then the total cost of load-balancing can be estimated as $Cost_{comm,lb} = C \times (\xi + 1 + 2\delta )$, which is essentially $O(|\mathbb {T}_V|)$.

1.7 Appendix 7: Proof for Theorem 6

Let node $x$ fail at time $t_i$, and node $u \in \mathbb {R}(x)$ would come up to substitute node $x$. In the worst case, $u$ will come up at time $t_i + f(\Gamma )$, in case of the failure due to a node crash introducing an extra $\Gamma$ amount of delay, where $\Gamma$ is the delay that the application can tolerate. Let $v \in Child(x)$ such that $v$ receive the LEAVE message from node $x$ at time $t_j > t_i$. As the LEAVE is a broadcast message, node $u$ also receives the same LEAVE at time $t_j\pm \epsilon$, where $\epsilon \rightarrow 0$. Finally, $x$ receives a JOIN message at time $t_k>t_j$ from node $u$. The interval $(t_j-t_i)$ or $(t_k-t_j)$, assumed to be $\Omega$, is equal to the one-hop propagation delay and is very small. Therefore, if due to the ageing or crash the parent node fails, the child can fix its parent in $\varGamma + 2\varOmega$ in the worst case. The delay is same for the parent of the failed node also. The newly added node $u$ receives a JOIN_ACK from each of the nodes in $Child(x)$ and the $parent(x)$. Every JOIN_ACK is sent as a response to the JOIN message, however, is sent independently. As the LEAVE message is broadcast, it can be assumed that an exchange of JOIN and JOIN_ACK messages between every pair of nodes with respect to node $u$ is in parallel, and thus, cumulatively they can introduce a $2\varOmega$ amount of delay in the worst case. Overall, for a single node failure, the cost of tree maintenance in terms of delay can be estimated as $\varGamma + 2\varOmega$ in the worst case, which is essentially $O(max\{\varGamma , \varOmega \})$.

A child node as well as the parent of the failed node transmits $3$ messages $(1_{LEAVE} + 1_{JOIN} + 1_{JOIN\_ACK})$, in total, to fix the connectivity due to a node failure. The newly added node $u$ receives a JOIN_ACK from each of the nodes in $Child(x)$ as well as from $parent(x)$, and thus, transmits $\delta _{JOIN} + (\xi +1)_{JOIN\_ACK} + 1 _{LEAVE}$, where $\xi = |Child(x)|$ and $\delta$ denotes the degree of any node. Therefore, for a single node failure, the total cost of control message communication can be estimated as $3 + \delta + \xi + 2 = \delta + \xi + 5$, which is essentially a constant.