Finding Multiple Length-Bounded Disjoint Paths in Wireless Sensor Networks

In a wireless sensor network, routing messages between two nodes s and t with multiple disjoint paths will increase the throughput, robustness and load balance of the network. The existing researches focus on finding multiple disjoint paths connecting s and t efficiently, but they do not consider length constraint of the paths. A too long path will be useless because of high latency and high packet loss rate. This paper deals with such a problem: given two nodes s and t in a sensor network, finding as many as possible disjoint paths connecting s and t whose lengths are no more than L, where L is the length bound set by the users. By now, we know that this problem is not only NP hard but also APX complete [1,2], which means that there is no PTAS for this problem. To the best of our knowledge, there is only one heuristic algorithm proposed for this problem [3], and it is not suitable for sensor network because it processes in a centralized way. This paper proposes an efficient distributed algorithm for this problem. By processing in a distributed way, the algorithm is very communication efficient. Simulation results show that our algorithm outperforms the existing algorithm in both aspects of found path number and communication efficiency.


Introduction
A typical Wireless Sensor Network (WSN) comprises of thousands of small sensor nodes deployed in the monitoring area.Since communication range of sensor node is very limited, most of data transmissions in WSN need to be forwarded by many intermediate nodes.Usually, sensor nodes are battery-powered and it is unrealistic to replace their batteries, so saving energy is the main objective of WSN design.Researches [4,5] show that the energy consumption of sending and receiving data is several orders of magnitude higher than the energy consumption of computing.Therefore, how to design efficient routing strategies becomes a key issue in WSN.In recent years, routing with multiple disjoint paths has been more and more widely studied [6][7][8][9][10][11][12][13].For two nodes s and t in the network, a path connecting s and t is a st path.A set of st paths are disjoint paths if any two of them do not any common nodes besides s and t.The problem studied in this paper is: Problem.In a WSN, given two nodes s and t and a user-specified length bound L, find as many as possible disjoint st paths whose length ≤ L.
There are several motivations for routing through multiple disjoint paths in WSNs.Routing several data packets through multiple disjoint paths simultaneously will increase the throughput between the given node pair dramatically.Since link and node failures are very common in WSNs, messages can easily be lost while they are routed through a single path.We can increase reliability by sending messages redundantly through multiple disjoint paths.On the other hand, routing messages often through a single fixed path would use up the energy of the nodes in the path quickly.By routing messages through several disjoint paths alternately, the network can gain a better balanced load.Moreover, in some applications, a sensitive message can easily be captured by eavesdropping nodes while it is routed through a single path.However, if we break the sensitive message into small pieces and send these pieces through multiple disjoint paths, the task of capturing the whole message would be much more difficult.
It is necessary to limit the length of the paths.If two nodes send messages to each other through a too long path, the transmission latency is likely to be unbearable for the users.In addition, since each wireless link has a certain amount of packet loss rate, packets have little chance to reach their destination if they are routed through a too long path.
The problem studied by this paper has been proved not only NP-hard but also APX-complete [1,2], which means that there is no Polynomial Time Approximation Scheme (PTAS) for it.To the best of our knowledge, in addition to a heuristic centralized algorithm [3], no other algorithms have been proposed for this problem by now.The algorithm in [3] is not suitable for WSNs because of high communication cost.This paper proposes a distributed algorithm for this problem.Simulation results show that our algorithm outperforms the existing algorithm in both aspects of found path number and communication efficiency.
The problem we consider uses the simple path length (the number of the links in the path) as the metric of the paths.Sometimes, we have to consider a more complicated path metric.For example, we assume that each link has a delivery ratio and use the product of per-link delivery ratios as the metric of a path, which is the delivery ratio of the path.The algorithm proposed in this paper can be easily extended to this situation by setting each edge a weight and using the product of per-edge weights as path metric.
The remainder of the paper is organized as follows: Some related works are introduced in Section 2. After giving preliminary definitions in Section 3, we describe the proposed distributed algorithm in Section 4. Simulation results which confirm the proposed algorithm's efficiency are given in Section 5. Finally, we conclude the paper in Section 6.

Related Works
In graph theory, there are several researches that study the problem of finding multiple disjoint st paths with length constraint.Reference [1] proves that this problem is NP-hard when L ≥ 5. Reference [2] further proves that this problem is APX-complete when L ≥ 5, so there is no PTAS for this problem and it will be very hard to give an approximation algorithm with constant approximation ratio.Therefore, in addition to the heuristic algorithm in [3], no other algorithms are proposed for this problem.The algorithm in [3] is a centralized algorithm which can output optimal solution when L ≤ 4. If we use it in WSNs, we have to collect the topology information of the whole network to the sink node.The communication cost of such an operation is unbearable for WSNs.
In network area, there are many researches study the problem of finding multiple disjoint st paths.References [11,14] propose algorithms to find 2 disjoint st paths.
References [6,[8][9][10]12,13,15] give efficient distributed algorithms to find k disjoint s -t paths in the given network, where k is a positive integer set by the users.These algorithms have the same basic idea: find a s -t path and delete the nodes in the path, then find the next s -t path and delete its path nodes, until finding k disjoint paths.These works have a common disadvantage: they do not consider the length constraint of the paths.Some paths they found will be not suitable for transmitting data between s and t because of high latency and high packet loss rate.
Some centralized algorithms [7,[16][17][18][19] are also proposed for finding k disjoint s -t paths.The algorithms in [7,16,19] can find k disjoint paths with minimum total length.However, they can also output some too long paths which are not suitable for routing data.Moreover, since they process in a centralized way, they are not suitable for WSNs.
So far, in addition to the algorithm in [3], all the algorithms for finding disjoint s -t paths do not consider length constraint of paths.The algorithm in [3] is not applicable in WSNs since it is a centralized algorithm.Therefore, this paper propose an efficient distributed algorithm for finding disjoint s -t paths with length constraint.Simulation results show that our algorithm is much better than the algorithm in [3] in both aspects of found path number and communication cost.

Preliminaries
We use a graph G = (V, E) to denote the given sensor network, where V={v | v is a sensor node} and E = {(u, v) there is a wireless link between and v u V  V  }.When the algorithm executes, it constructs a tree T s rooted at s and a tree T t rooted at t.For each node v in T s : its parent in T s is denoted by parent s (v); its s-origin is its ancestor in T s who is child of s, and we use origin s (v) to denote it; dis s (v) is the length of the path from s to v in T s .For each node v in T t : its parent is parent t (v); its t-origin is its ancestor in T t who is child of t, and we use origin t (v) to denote it; dis t (v) is the distance from t to v in T t .Suppose that the algorithm constructs T s and T t as shown in Figure 1.
If v is a node in both T s and T t , we say that v is an intersecting node of T s and T t .In the example of Figure 1,  g, h, i, j, k are intersecting nodes of T s and T t .
For two nodes u and v in T s , we use uT s v to denote the path connecting u and v in T s .For two paths P 1 and P 2 with a common end node, we use P 1 + P 2 to denote their concatenation.

Distributed Algorithm
The proposed algorithm bases on such an observation: In a WSN, whether two nodes can communicate with each other is mainly determined by the physical distance between the two nodes.If the nodes in a WSN distribute evenly, the areas near s and t are usually the bottle necks of the existence of multiple disjoint s -t paths, i.e., the number of disjoint s -t paths is usually constrained by the number of the neighbors of s and t.
There are 3 steps in the algorithm.In Step 1, we construct trees T s and T t rooted at s and t respectively.The construction of the trees ends at their intersecting nodes.In Step 2, some information of the intersecting nodes is collected to s.The information reveals how T s and T t intersect with each other.In Step 3, s computes an optimal solution with the collected intersecting information.According to the solution, multiple disjoint s -t paths are built along the two trees.

Building Trees
In this step, we build trees T s and T t rooted at s and t respectively.The two trees are constructed simultaneously.In the process of tree construction, each node v in T s records the following information: parent s (v), origin s (v) and dis s (v).Similarly, each node v in T t records the following information: parent t (v), origin t (v) and dis t (v).
The construction of T s /T t starts at s/t, then gradually extends outward.Use the construction of T s as an example: At first, s broadcasts an initialization message.Each node receiving the initialization message joins T s as a child of s.Each new node v in T s broadcasts a Build-Tree message including its ID, origin s (v) and dis s (v), so the neighbors of v can join T s as v's children.
The construction of T s ends at: 1) the intersecting nodes of T s and T t ; 2) the node v in T s such that dis s (v) ≥ L. Similarly, the construction of T t ends at: 1) the intersecting nodes of T s and T t ; 2) the node v in T t such that dis t (v) ≥ L.
For finding more paths, we hope that the trees are built evenly.For instance, if s has children a, b, c in T s , we hope that the sets of the nodes whose s-origin is a, b, c respectively have the same size.For this reason, we design a build-tree delaying mechanism.Use the construction of T s as an example: when node v who is not in T s receives a Build-Tree message for the first time (the sender of the message is u), v randomly delays for a while to receive more Build-Tree messages rather than joins T s as u's child immediately.The range of random delay is determined by the current distance from s to v in T s , i.e., dis s (u) + 1.The greater the distance is the greater the maximum delay time is.During the delay, v records every Build-Tree message it receives.Suppose that v receives 4 Build-Tree messages during the delay and the sender of these messages are u 1 , u 2 , u 3 , u 4 respectively.Let the s-origins of u 1 , u 2 , u 3 , u 4 be a, b, b, c respectively.When the delay ends, v randomly chooses one of { u 1 , u 2 , u 3 , u 4 } as its parent so that Pr{origin s (v) = a} = Pr{origin s (v) = b} = Pr{origin s (v) = c}, where Pr{origin s (v) = a} is the probability that v's s-origin is a.
if v receives a Build-Tree message {u, origin s (u), dis s (u)}then 6.
Record u as a potential parent; 7.
if it is v's first time to receive a Build-Tree message then 8.
Randomly delay for a while according to dis s (u) + 1; 9.
if the delay ends then /* Suppose that v' potential parents come from n different s-origins a 1 , …, a n */ 10.
Randomly choose a potential parent w so that if v is not in T t and dis s (v) < L then 13.
Broadcast a Build-Tree message {v, origin s (v), dis s (v)}; The algorithm of building trees is given by Algorithm 1.
In Algorithm 1, we only give the pseudo-codes for building T s .The pseudo-codes for building T t can be gotten from it.The whole process starts by s broadcasting an initialization message.The nodes who receive the initialization message join T s as children of s (Line 1 -3 in Algorithm 1).If node v receives a Build-Tree message for the first time, it randomly delays for a while according its current distance to s in T s (Line 7 -8 in Algorithm 1).During the delay, for each Build-Tree message {u, origin s (u), dis s (u)} received by v, v records the sender u as its potential parent (Line 5 -6 in Algorithm 1).Suppose that the potential parents of v come from n different s-origins a 1 , •••, a n .When the delay ends, v randomly chooses a potential parent as its parent so that in Algorithm 1).The building of T s ends at: 1) the intersecting nodes of T s and T t ; 2) the node v in T s such that dis s (v) ≥ L (Line 13 -14 in Algorithm 1).

Collecting Intersecting Information
At the end of Step 1, every intersecting node v checks whether dis s (v)+dis t (v)≤ L. If so, we can get a path meeting the length constraint by concatenating path sT s v and path vT t t, so v sends the intersecting information {origin s (v), origin t (v)} to s along T s .The intersecting information indicates that the path we found goes through s's neighbor origin s (v) and t's neighbor origin t (v).When relaying the intersecting information, each ancestor of v records the information and its sender.The whole process of this step is given by Algorithm 2.
Algorithm 2: Collecting Intersecting Information Send the intersecting information {origin s (v), origin t (v)} to parent s (v); 4. for each node v in T s do 5.
Records the information and its sender; 7.
Send the information to parent s (v); In an example, the users set the length bound as L = 8.The algorithm builds T s and T t in the given network as shown in Figure 1.In Step 2, the intersecting node g sends the intersecting information {a, d} to s along T s .In the same way, h, i, j, k respectively send the intersecting information {b, d}, {b, e}, {b, f}, {c, f} to s along T s .

Finding Disjoint Paths
Before introducing Step 3, we give a proposition, which can easily be gotten by the nature of T s and T t .
Proposition 1.For two intersecting nodes v 1 and v 2 , if origin s (v 1 ) ≠ origin s (v 2 ) and origin t (v 1 ) ≠ origin t (v 2 ), then Send a Build-Path message to v to build path; This step is given by Algorithm 3. At first, s builds a bipartite graph G * with empty edge set (Line 1 in Algorithm 3).One partite set of G * contains all the neighbors of s.The other partite set of G * contains all the neighbors of t.If s receives an intersecting information {origin s (v), origin t (v)}, it adds an edge in G * connecting origin s (v) and origin t (v) (Line 2 -3 in Algorithm 3).According to Proposition 1, we know that each matching in G * denotes a set of disjoint s -t paths in the network.After receiving all the intersecting information, s searches for the maximum matching in G * with existing algorithm (Line 4 in Algorithm 3), like the algorithm in [20].For each edge (origin s (v), origin t (v)) in the maximum matching, s sends a Build-Path message to v to construct a path from s to t (Line 5-6 in Algorithm 3).The Build-Path message is forwarded to v along T s .Meanwhile, sT s v is added to the path.After receiving this message, v sends a Build-Path message to t along T t .In this process, vT t t is added to the path.
In the example shown by Figure 1, after receiving the intersecting information, s builds a bipartite graph G * as shown in Figure 2(a).In G * , s finds the maximum matching as shown in Copyright © 2011 SciRes.WSN (a, d), (b, e), (c, f), s sends Build-Path messages to g, i, k along T s .After receiving these messages, g, i, k send Build-Path messages to t along T t .At the end, 3 disjoint s -t paths as shown in Figure 3 are built in the network.
the network; find the shortest s -t path in the remaining network and delete its path nodes.The iteration is executed until the length of the found path is greater than L. The efficiency of an algorithm is measured in two aspects: 1) the number of the paths found by the algorithm; 2) the communication cost of the algorithm, i.e., the average bytes sent and received per node.To get each data in the simulation results, we did 10 groups of experiments.In each group of experiments: the node locations are regenerated; the ID of s and t are 1 and 1000 respectively; we compare the 3 algorithms with the changes of L (L = 10, 20, 30, 40, 50).The simulation results are given by Figures 4(a) and (b).Each data in the figures is the average of the results of the 10 groups.

Simulation Results
We use a simulator written in C++ codes to evaluate the efficiency of the algorithm.In the simulation, we deploy 1000 nodes in a 1000 m × 1000 m area.The locations of the nodes are generated randomly.The transmitting radius of each node is set to 50 m.In MAC layer, we apply CSMA/CA mechanism to avoid signal conflicts.In application layer, the header of each data packet contains 4 bytes to denote the destination's ID, the sender's ID, the length and the type of the packet.Each receiving and timer-fire event is added a time stamp and put into a heap.The events in the heap are executed in the order of their time stamps.In this way, we can simulate the parallel processing of the nodes.
With the changes of L, the numbers of the paths found by the 3 algorithms are as shown in Figure 4(a).We can see that EDA has the best performance among these 3 algorithms in the aspect of found path number.Naive has the poorest performance because it searches for paths in a greedy way and does not consider the possibility of finding multiple paths.EDA finds more paths because it builds tree in a balanced way and adopts an optimal searching strategy.
We compare our Efficient Distributed Algorithm (denoted by EDA) with the Heuristic Centralized Algorithm in [13] (denoted by HCA) and a Naive algorithm.The basic idea of the Naive algorithm is: find the shortest s -t path in the network; remove the nodes in the path from With the changes of L, the communication costs of the 3 algorithms are as shown in Figure 4(b).We can see that EDA are much better in the aspect of communication cost compared to HCA and Naive.The communication cost of HCA is great and steady because HCA collects the topology information of the whole network no matter what value L is.Naive searches for path repeatedly.In each searching, all the nodes in the network exchange messages to find the shortest path, so the communication cost of Naive rises with finding more paths.Since EDA processes in a distributed way and exchange message once, it is the most efficient one in the 3 algorithms.

Conclusions
In this paper, we study the following problem: in a sensor network, given two nodes s and t; a user-specified length bound L, find as many as possible disjoint s -t paths whose lengths are no more than L. The existing algorithms for finding multiple disjoint paths rarely consider the length constraint of the paths.For finding multiple length-bounded disjoint paths, there is only one heuristic centralized algorithm.In this paper, we propose an efficient distributed algorithm for this problem.The simulation results show that our algorithm outperforms the existing algorithm in both aspects of found path number and communication cost.

Figure 1 .
Figure 1.T s and T t constructed by the algorithm (the solid lines denote the edges in T s and the dashed lines denote the edges in T t ).

Figure 2 (Figure 2 .
Figure 2. The constructed G * and the maximum matching in it.
algorithm EDA is better than the algorithm HCA and the Naïve algorithm in both aspects of found path number and communication cost.

Figure 3 .
Figure 3.The 3 disjoint paths built by the algorithm.
t t and P 2 = sT s v 2 + v 2 T t t are two disjoint paths in the network.