06148212

7/28/2019 06148212

1/15

Least-Latency Routing over Time-DependentWireless Sensor Networks

Shouwen Lai, Member, IEEE, and Binoy Ravindran, Senior Member, IEEE

AbstractWe consider the problem of least-latency end-to-end routing over adaptively duty-cycled wireless sensor networks. Such

networks exhibit a time-dependent feature, where the link cost and transmission latency from one node to other nodes vary constantly

in different discrete time moments. We model the problem as the time-dependent Bellman-Ford problem. We show that such networks

satisfy the first-in-first-out (FIFO) property, which makes the time-dependent Bellman-Ford problem solvable in polynomial-time. Using

the -synchronizer, we propose a fast distributed algorithm to construct all-to-one shortest paths with polynomial message complexity

and time complexity. The algorithm determines the shortest paths for all discrete times in a single execution, in contrast with multiple

executions needed by previous solutions. We further propose an efficient distributed algorithm for time-dependent shortest path

(TDSP) maintenance. The proposed algorithm is loop-free with low message complexity and low space complexity of Omaxdeg,

where maxdegis the maximum degree for all nodes. We discuss a suboptimal implementation of our proposed algorithms that reduces

their memory requirement. The performance of our algorithms are experimentally evaluated under diverse network configurations. The

results reveal that our algorithms are more efficient than previous solutions in terms of message cost and space cost.

Index TermsTime dependent, shortest path, wireless sensor networks, routing, routing maintenance, least latency

1 INTRODUCTION

MULTIHOP data routing over wireless sensor networks(WSNs) has attracted extensive attention in the recentyears. Since there is no infrastructure in sensor networks,the routing problem is different from the one in traditionalwired networks or the Internet. Some routing protocols [2],[3] over WSNs presented in the literature are extended fromthe related approaches over wired/wireless ad hoc net-

works. They usually find a path with the minimum hopcount to the destination, which is based on the assumptionthat the link cost (or one-hop transmission latency) isrelatively static for all wired/wireless links. However, forduty-cycled WSNs [4], [5], [6], that assumption may notalways be valid.

Duty-cycled WSNs include sleep-wakeup mechanisms,which can violate the assumption of static link costs.Currently, many MAC protocols support WSNs operatingwith low duty cycle, e.g., B-MAC [5], X-MAC [6]. In suchprotocols, sensor nodes operate in low power listening (orLPL) mode. In the LPL mode, a node periodically switches

between the active and sleep states. The time duration of anactive state and an immediately following sleep state iscalled the LPL checking interval, which can be identical, orcan be adaptively varied for different nodes, referred to asALPL [7]. The duty-cycled mechanism has been shown to

achieve excellent idle energy savings, scalability, andeasiness in implementation. However, they suffer fromtime-varying neighbor discovery latencies (the time be-tween data arrival and discovery of the adjacent receiver),which is also pointed out by Gu and He [8]. As shown inFig. 1, the neighbor discovery latency is varying withdifferent departure times. Even with synchronized duty-

cycling, the neighbor discovery latency is varying atdifferent time moments due to adaptive duty cycle settingas shown in Fig. 1.

To formally define the problem, we first define the linkcost as the time delay between data dispatching time, whichis the earliest time when a sender wakes up for datatransmission, and the data arrival time at the receiver. Thelink cost is time-varying in adaptively duty-cycled WSNsdue to varying neighbor discovery latencies, even thoughthe physical propagation condition does not change withtime. The dispatching time is the time moment when thedata is ready for transmission at the sender side. Thus, this

raises a nontrivial problem: with time-varying link costs,how to find optimal paths with least nodes-to-sink latencyfor all nodes at all discrete dispatching time moments?

A similar problem has been modeled in previous worksas the time-dependent shortest path problem (or TDSP) [9],[10] in the field of traffic networks [11], time-dependentgraphs [12], and GPS navigation [13]. The general time-dependent shortest path problem is at least NP-Hard, sinceit may be used to solve a variety of NP-Hard optimizationproblems such as the knapsack problem. However,depending on how one defines the problem, it may notbe in NP, since its output is not polynomially bounded.

Moreover, there are even continuous-time instances of theTDSP problem in which shortest paths consist of an infinitesequence of arcs, as shown by Orda and Rom [14]. In thispaper, we study a special case where the networks are

IEEE TRANSACTIONS ON COMPUTERS, VOL. 62, NO. 5, MAY 2013 969

. S. Lai is with Qualcomm, Inc., 8410 Summerdale Rd., Unit A, 5775Morehouse Drive, San Diego, CA 92121.E-mail: [email protected].

. B. Ravindran is with the Department of Electrical and ComputerEngineering, Virginia Tech, 302 Whittemore (0111), Blacksburg, VA24061. E-mail: [email protected].

Manuscript received 1 Feb. 2011; revised 29 Aug. 2011; accepted 18 Jan. 2012;

published online 31 Jan. 2012.Recommended for acceptance by V. Leung.For information on obtaining reprints of this article, please send e-mail to:[email protected], and reference IEEECS Log Number TC-2011-02-0073.Digital Object Identifier no. 10.1109/TC.2012.36.

0018-9340/13/$31.00 2013 IEEE Published by the IEEE Computer Society

7/28/2019 06148212

2/15

known as first-in-first-out (FIFO) networks, in whichcommodities travel along links in a First-In-First-Outmanner. Under the FIFO condition, the time-dependentshortest path problem is solvable in polynomial time.

The TDSP problem has also been studied with adistributed approach. The only previous distributed solu-tion [10] computes the shortest paths for a specificdeparture time in each execution. If the whole time periodhas M discrete intervals (M is 1 for infinite time intervals),we have to execute the algorithm in [10] M times, which isinefficient in terms of message complexity and timecomplexity, given the limited power and radio resource in

WSNs. Therefore, the first motivation of our work is todesign a fast distributed algorithm for the problem, whichcan efficiently enumerate all optimal paths with least end-to-sink latency for infinite time intervals.

The second motivation of our work is to proposealgorithms which can dynamically and distributivelymaintain time-dependent least-latency paths. In WSNs, anode may update its duty-cycle configuration (e.g., basedon residual energy), or join or leave the network, therebychanging the network topology. In such situations, theduty-cycle updating node or the joining/leaving node maychange the cost of all the links with its neighbors, whichmeans that a single node update causes multiple link

updates. Previous efforts on this problem [15], [16] areefficient in handling single link updates. However, apply-ing such solutions for multiple link updates would implythat multiple distributed updates execute concurrently for asingle node update, which is not efficient in terms ofmessage cost and memory cost for resource-limited WSNs.

The third motivation is to address practical implementa-tion issues. Our work requires schedule-awareness inneighborhood. One scenario for such requirement is thatall nodes have none information from each other after initialdeployment in field. In this scenario, we would like to getschedule-awareness without global time synchronization.

Local synchronization and light information exchange isdesirable to get duty-cycling information and time differ-ence from neighbors for a sensor node.

One candidate to achieve this is by neighbor discoveryprotocol, just similar as the link layer neighbor discoveryprotocol in the Internet. Nodes without schedules ofneighbors would stay awake and broadcast neighbordiscovery message periodically (i.e., once every multiplepredefined time slots) and neighbors can response backtheir schedule information, which is a kind of local levelsynchronization. Once reaching a stable stage, any nodewould get its neighbors schedule and the time differencefrom its neighbors, and switch back to duty-cycling state.

The update of nodes schedule can be undergoing inbackground either probatively or reactively.

Because our work is not limited to any specified MAC-protocol, we discuss different methods to achieve schedule

awareness over several underlying mechanisms, such asB-MAC, S-MAC, and quorum-based wakeup scheduling inSection 7.1.

Regarding to another practical implementation issues,we also need to understand how to simplify the vectorpresentation so that only smaller vector sizes are required,given the limited memory resource of sensor nodes. Wepresent a suboptimal implementation, which achieves atradeoff between latency and memory usage. Finally, wediscuss the complexities of our algorithms in some specialscenarios, like static link costs and multiple sink nodes.

In this paper, we first propose a distributed algorithm tocompute the time-dependent paths with least latency for allnodes in a duty-cycled WSN. The algorithm has lowmessage and space complexities. The algorithm is basedon the observation that the time-varying link cost functionis periodic, and hence by derivation, the time-varyingdistance function for each node is also periodic. We showthat the link cost function satisfies the FIFO property [9].Therefore, the time-dependent shortest path problem is not

an NP-hard problem, and thus is solvable in polynomialtime. We also propose distributed algorithms for maintain-ing the shortest paths. The proposed algorithms recomputethe routing paths based on previous path information.

The message complexity of our algorithms is O2 pernode update, where is the number of nodes that changeeither the distance or the parents in their shortest paths tothe sink as a consequence of the corresponding nodesupdate. The algorithms space complexity is Omaxdeg.Finally, we propose a suboptimal implementation, whichrequires vectors with smaller sizes to represent link costfunctions and the distance function.

The contributions of the paper are as follows:

1. We model adaptively duty-cycled WSNs as time-dependent networks. We show that such networkssatisfy the FIFO condition and the triangular pathcondition.

2. We present distributed algorithms for finding thetime-dependent shortest paths to the sink node forall nodes. When compared to the previous solution[10], our algorithms find the shortest paths in asingle execution for infinite time intervals.

3. We present distributed shortest path maintenancealgorithms with low message complexity and space

complexity.4. We propose suboptimal implementation with vector

compression.

Tothebestof our knowledge,we are not aware ofanyotherefforts that consider duty-cycled WSNs as time-dependentnetworks and solve the problem of finding or updating theshortest paths with efficient message and space costs.

The rest of the paper is organized as follows: we surveypast and related works in Section 2, and outline ourassumptions and define the problem in Section 3. Weformally model the link cost function and the distancefunction in Section 4. The algorithms for route construction

and route maintenance are described in Sections 5 and 6,respectively. We discuss practical implementation issues inSection 7. Simulation results are reported in Section 8. Weconclude in Section 9.

970 IEEE TRANSACTIONS ON COMPUTERS, VOL. 62, NO. 5, MAY 2013

Fig. 1. Varying neighbor discovery latency in heterogenous LPL mode.

7/28/2019 06148212

3/15

2 RELATED WORK

We summarize the literature on LPL scheduling and thetime-dependent shortest path problem as follows.

LPL/ALPL in WSNs. LPL means that a node only wakesup and listens the channel state for a short time period.Examples include B-MAC [5] which is a CSMA-basedtechnique utilizing low power listening and an extended

preamble to achieve low power communication. In B-MAC,nodes have an independent sleep-wakeup schedule. If anode wishes to transmit, it precedes the data packet with apreamble that is slightly longer than the sleep period of thereceiver. During the awake period, a node samples themedium, and if a preamble is detected, it remains awake toreceive the data. With the extended preamble, a sender isassured that at some point during the preamble, thereceiver will wake up, detect the preamble, and remainawake in order to receive the data. The designers of B-MACshow that B-MAC surpasses existing protocols in terms ofthroughput, latency, and for most cases, energy consump-

tion. While B-MAC performs quite well, it suffers from theoverhearing problem, and the long preamble dominates theenergy usage.

To overcome some of B-MACs disadvantages, XMAC[6] and DPS-MAC [17] were proposed, In XMAC or DPS-MAC, short preamble was proposed to replace the longpreamble in B-MAC. Also, receiver information is em-bedded in the short preamble to avoid the overhearingproblem. The main disadvantage of B-MAC, X-MAC, andDPS-MAC is that it is difficult to reconfigure the protocolsafter deployment, thus lacking in flexibility. X-MAC [6] andDPS-MAC [17] are compatible with LPL mechanisms.However, they do not explicitly support adaptive duty

cycling, where nodes choose their duty cycle depending ontheir residual energy.

Raja et al. [7] and Vigorito et al. [4] present adaptive lowpower listening (ALPL) mode based on nodes residualenergy. These works provide the application spaces for ourwork. In ALPL, since nodes have heterogenous duty cyclesetting, it is more difficult for neighbor discovery since anode cannot differentiate whether a neighbor is sleeping orfailing when it does not receive feedback from the neighbor.ALPL also incurs time-dependent link-cost and end-to-endlatency as illustrated in Section 4. Recently, B-MAC [5] wasalso extended to support the ALPL mode in TinyOS.

Delay-efficient routing over adaptively duty-cycledWSNs. Over adaptively duty-cycled WSNs, routing be-comes more difficult due to two reasons: intermittentconnection between two neighbor nodes and changes inthe transmission latency at different times. Some workshave studied the delay-efficient routing problem overadaptively duty-cycled WSNs in recent years.

Su et al. [18] proposed two methods to solve routing overintermittently connected WSNs due to duty cycling. One isby an on-demand approach that uses probe messages todetermine the least-latency route. The other one is aproactive method, where all least-latency routes at differentdeparture times are computed at the beginning. The first

method does not work well for frequent data deliveries. Thesecond method is a centralized approach, and is not flexiblefor distributed construction. Our algorithms also follow theproactive approach, but are distributed.

Gu and He [19] considered the problem with a differentperspective. They studied how to consume a minimumamount of energy while satisfying an end-to-end delaybound specified by the application. In [20], Gu et al. studiedhow to guarantee the end-to-end latency by adjusting dutycycling in individual nodes. There are also some otherworks that have studied the energy-delay tradeoff for duty-cycled WSNs, such as [21] and [22]. These efforts are similar

to our work, but there is a fundamental difference: we studythe least routing latency, given the duty-cycle or energyconfiguration on each node.

Time-dependent shortest path problem. This problemwas first proposed by Cooke and Halsey [9]. It has beenwell studied in the field of traffic networks [11], time-dependent graphs [12], and GPS navigation [13]. Previoussolutions for this problem mostly work offline using acentralized approach [12]. Although these solutions canprovide inspirations, they cannot be applied to WSNswhere the global network topology is not known by acentralized node, given the large-scale size of a WSN.

For the distributed time-dependentshortest pathproblem,

the only previous work [10] computes the shortest paths for aspecific departure time in each execution, which is not time-efficient. If the whole time period has M discrete intervals(M is 1 for infinite time intervals), we have to execute thealgorithm in [10] M times, which is inefficient in terms ofmessage complexity and time complexity. For multipleexecutions, the algorithm in [10] suffers from high messagecost, which is undesirable for resource-limited WSNs.

The work in [10] discusses two policies for the time-dependent shortest path problem: waiting and nonwaiting.Waiting does not mean waiting in the buffer, but meanswaiting for some time after the data has been delivered (i.e.,

the receiver is awake). Nonwaiting means that a sender willimmediately send the data once the receiver is awake. Wedo not consider the waiting policy in our work, since theend-to-end latency does not benefit from waiting.

Dynamic shortest path maintenance. Many works [15],[16], [23] exist for handling link decreases and increases,and node deletions and insertions in static networks. In [24],an algorithm is given for computing all-pairs shortest paths,which requires On2 messages when the network size is n.In [25], an efficient incremental solution has been proposedfor the distributed all-pairs shortest paths problem, requir-ing OnlognW amortized number of messages over asequence of edge insertions and edge weight decreases.

Here, W is the largest positive integer edge weight. In [26],Awerbuch et al. propose a general technique that allows toupdate the all-pairs shortest paths in a distributed networkin On amortized number of messages and On time, byusing On2 space per node.

In [23], Ramarao and Venkatesan give a solution forupdating all-pairs shortest paths that requires On3messages, On3 time, and On space. They also show that,in the worst case, the problem of updating shortest paths isas difficult as computing shortest paths. They suggest twopossible directions toward devising efficient fully dynamicalgorithms for updating all-pairs shortest paths: 1) explore

the tradeoff between the message, time and space complex-ity for each kind of dynamic change, 2) devise algorithmsthat are efficient in different complexity models (withrespect to worst case and amortized analysis).

LAI AND RAVINDRAN: LEAST-LATENCY ROUTING OVER TIME-DEPENDENT WIRELESS SENSOR NETWORKS 971

7/28/2019 06148212

4/15

However, the algorithms in [15] and [23] need Onspace at each node, which is impractical for sensor nodeswith limited memory capacity. In addition, none of theprevious works are efficient for shortest path maintenancein time-dependent networks.

-Synchronizer [27]. As described in [27], the synchroni-zer is a methodology for designing efficient distributedalgorithms in asynchronous networks. Researchers haveused synchronizers to reduce message complexity of someasynchronous algorithms, such as Bellman-Ford. A syn-chronizer works as follows: a synchronizer generatessequences of clock-pulses at each node of a network. Ateach node, a new pulse is generated only after it receives allthe messages which were sent to that node by its neighborsat the previous pulse. Thus, a synchronizer runs in a phase-by-phase manner.

A -synchronizer is a special type of synchronizer, whichhas an initialization phase, in which a leader s is chosen inthe network and a spanning tree rooted at s is constructed(e.g., by a Breadth-First-Search). After the execution of one

phase, the leader s will eventually learn that all the nodes inthe network are safe. At that time, it broadcasts a messagealong the spanning tree, notifying all the nodes that theymay generate a new pulse. The communication pattern forreceiving all acknowledgments is just like convergecast.Therefore, with a -synchronizer, whenever a node learnsthat it is safe and all its descendants in the tree are safe, itsends an acknowledgment to its parent. In each phase, a-synchronizer incurs low message complexity, which isOjVj [27], where jVj is the network size, but at a highertime cost.

For a distributed shortest path algorithm armed with a

-synchronizer, if the number of phases are limited, thetotal message complexity will be bounded.

3 ASSUMPTIONS AND PROBLEM DEFINITION

We model a WSN as a directed graph G V ; E ; C , withjVj nodes and jEj links. C fi;jtji; j 2 Eg is a set oftime-dependent link delays, i.e., i;jt is a strictly positivefunction of time defined for 0; 1, describing the delay of amessage over link i; j at time t. Each node ni only knowsthe identity of the nodes in its neighbor set, defined as Ni.

We assume that time axis are arranged as consecutivenumbered time slots. We denote the duration of one time slotfor node ni as Ti. It is possible that Ti 6 Tj (ALPL) for twonodes ni and nj. The time expansion of each node ni ismodeled as discrete and infinite, where Ti ft

0i ; t

1i ; t

2i ; . . . ;

tMi g, Mis 1, and tki t

k1i Ti. We use the terms checking

interval and time slot interchangeably.The wakeup schedule depends on the underlying MAC

protocol. We first assume that a node can be operated in theLPL mode: a node wakes up at the beginning of a time slotto check the channel state. If there is no activity, the nodegoes back to sleep; otherwise, it stays awake. Then, we relaxthe assumption and discuss how our work can be applied toother wakeup schedules, such as quorum schedules [28].

We consider the nonwaiting policy (i.e., the senderimmediately delivers data once the receiver is awake) ateach node, since the node-to-sink delay will not benefit fromwaiting. Thus, once the data arrives at an intermediate node,

the node will attempt to dispatch the data immediately.Dispatching time represents the earliest time when a senderis awake for data transmission. Thus, dispatching times arenot the same as the data departure times, as the data maystill be buffered in the senders memory. For simplicity inmodeling and design, a node dispatches the received data attki 2 Ti.

A nonnegative travel time i;jtki is associated with each

link i; j with the following meaning: if tki is the datadispatching time from node ni along the link i; j, thentki i;jt

ki is the data arrival time at node nj.

The general problem of determining the shortest pathswith the least latency in time-dependent WSNs can bedefined as follows: Find the least-time paths from all nodesto the sink node ns corresponding to the minimumachievable delay di, 8ni 2 V and 8t

ki 2 Ti, where:

di

tki

minnj2Ni

i;j

tki

dj

tki i;jtki

: 1

Equation (1) is an extension of Bellmans equations

[29] for the time-dependent network and is referred to asTD-Bellmans equation hereafter.

We also assume that a message arrives correctly in finitetime from a sender to a receiver, which can be achieved byany reliable MAC-layer transmission mechanism.

We do not assume that the entire network is time-synchronized, i.e., all nodes are not equipped with GPSdevices or are not operated by global time-synchronizationprotocols [30]. However, due to the proactive routingnature in our proposed algorithms, we need to know thelink costs at the beginning of route construction. Therefore,we assume awareness of wakeup schedules of the neigh-

borhood for each node. Such schedule awareness can beachieved by neighbor discovery protocols such as periodicneighbor detection mechanisms. We further assume that allnodes have the same time frequency, and their clocks driftat relatively slow speeds.

4 MODELING ADAPTIVELY DUTY-CYCLED WSNS

In this section, we model adaptively duty-cycled WSNs astime-dependent networks. The algorithms we propose arebased on (1). Basically, tki is infinitely discrete. Note thatsensor nodes have limited memory and exchanging

messages is expensive. Thus, in order to implement (1) inpractice, we must make i;jtki and djt

ki i;jt

ki (where

k 2 0; 1) finite, so that the time-dependent link cost anddistance can be represented by vectors.

We will now show that the link cost function is periodicand establish that the time-varying distance function is alsoperiodic. Having done so, we will show how TD-BellmansEquation can be implemented by vector representations oflink costs and distances.

4.1 Link Cost Function

Without loss of generality, suppose there are two adjacent

nodes ni and nj, where ni is the sender and nj is the receiver.Suppose at time t0i , the neighbor discovery latency is

t0ii;j.

Then at time tki t0i k Ti, the neighbor discovery latency

can be expressed as:


7/28/2019 06148212

5/15

tkii;j Tj

k Ti

t0i

i;j

mod Tj: 2

In an actual deployment, for example with the X-MAC

protocol, we can measure t0

ii;j in the following way: at the

beginning of the time slot which starts at t0i , node ni sends

out a preamble which contains the node ID of nj. njimmediately feeds-back an ACK containing the value of Tjonce it receives the preamble. After receiving the ACK by

ni, the one-hop round trip delay from t0i to the time at which

the ACK is received is set to t0

ii;j. Once we have measured

t0

ii;j,

tkii;j (k ! 0) can be computed by (2).

For data transmission with fixed length data packets, we

define the data propagation time as data. Now, for a

directed link i; j, we can set the link cost function as, for

8tki 2 Ti,

i;j

tki

Tj

k Ti t0

ii;j

mod Tj data: 3

Ifdata is relatively small when compared with Ti and Tj,

we can set data 0. This is especially true for some WSN

applications with small information reports, such as target

tracking and environment monitoring.

Theorem 1. For every link i; j, the time-varying link cost

function is periodic. The minimum period for the function

regarding k is:

Pi;j LCMTi; Tj

Ti; 4

where i;jtki i;jt

kPi;ji (k ! 0) and LCM is the least

common multiple.

4.2 Distance to SinkWe refer to the node-to-sink delay as distance, for

compatible representation with that in the static Bellman-

Ford algorithm [29].Consider node ni and its neighbor nj, where Ti 6 Tj. For

dispatching time t0i at ni, let us suppose that the data

arriving time at nj is tj0j . Then, for the dispatching time t

ki

at ni, with the same time frequency for the two nodes, the

corresponding time instant at nj is tj0j

t0i

i;j k Ti.

Hence, based on the neighbor discovery mechanism (e.g.,

B-MAC [5], X-MAC [6]), nj will be discovered by ni at the

time instant

tj0j k Ti

t0ii;j

Tj

2666

3777 Tj;

with respect to njs time clock. Therefore, the function of

distance from ni to ns through the path through nj is:

di

tki

i;j

tki

dj

tk0j0

j

; 5

for 8tki 2 Ti, where k0

dk Ti t0ii;j=Tje for t

k0

j 2 Tj, and

j0 is the data arriving time slot at nj with respect to

dispatching time t0

i

.

Theorem 2. For a path ni ni1 n1 ns, the distance

function ditki ,8tki 2 Ti, is a periodic function, where the

minimum period for the function regarding k is:

Pdi LCMT0; T1; . . . ; Ti

Ti; 6

for ditki dit

kPdii , where T0; T1; . . . ; Ti are durations of

the LPL checking intervals of nodes ns; n1; . . . ; ni, respectively.

Proof. The proof is by induction. For i 1; d1tk1 1;st

k1 dst

k0

1 . Since ds 0, d1t 1;stk1. According

to Theorem 1, d1tk1 is periodic and its period is

LCMT0; T1=T1. Assume that the claim is true fornode ni1.

Now, for nod e ni, ditki i;i1t

ki di1t

k0j0i1 ,

where k0

dk Ti t0

ii;j=Tje and j0 is the data arrival

time slot at ni1 with respect to tki , based on (5). Let us

define f1 i;i1tki and f2 di1t

k0j0i1 . The minimum

period for function f1 is Pf1 LCMTi; Ti1=Ti. LetQ LCMT0; T1; . . . ; Ti1. Based on the induction step,

for distance function di1tki1, the period isQ

=Ti1. The

period for function f2 is Pf2 Q

=gcdQ

; Ti. Since

gcdY

; Ti

Q Ti

LCMQ

; Ti ;

we have Pf2 LCM

Q;Ti

Ti.

Therefore, the minimum period for ditki is: Pdi LCMPf1; Pf2 LCMT0; T1; . . . ; Ti=Ti. tu

Given a WSN with different LPL checking intervals, theperiod for the distance function of any node is bounded byLCMT0; T1; . . . ; Tn=minfTig, from (6).

In practical implementations, it is recommended thatLCMT0; T1; . . . ; Tn=minfTig is not arbitrarily large. Thus,our mechanism for finding the shortest paths at the routing

layer should be based on cross-layer design. For example,{100 ms, 200 ms, 500 ms, 1,000 ms} is a good configurationset, where there is a bounded period LCM100; 200,500;1;000=minf100; 200; 500; 1;000g 10 for the distancefunction. It means that for any node, its distance to thesink will repeat at most every 10 checking intervals.

4.3 Implementation via Vectors

We implement the discrete, periodic, and infinite link costfunctions and the distance functions as vectors, andimplement the TD-Bellmans equation (Section 3) by vectoroperations. Our goal is to use vectors with limited sizes in

order to implement our algorithm with limited memoryand same message size over the air, although the time axisis infinite.

We implement the link cost function i;jtki (t

ki 2 Ti) with

a vector ~i;j, where j ~i;jj LCMTi; Tj=Ti and i;jkrepresents a set of numbers as follows:

i;jk

i;j

tki

; i;j

tkj ~i;jji

; i;j

t

k2j ~i;jji

; . . .

: 7

For the node ni, its distance function ditk (tki 2 Ti) canbe implemented by ~di, where j~dij Pdit

k. dik repre-sents a set of numbers as follows:

dik fdi

tki

; di

tkj~diji

; di

tk2j~diji

; . . .g: 8

However, there are two difficulties for the implementationof the TD-Bellmans equation by vector operations.


7/28/2019 06148212

6/15

The first one is vector mapping. To implement (5), even ifwe know ~i;j and ~dj, we cannot add up the two vectorsdirectly. We define a new vector ~d

0

j as:

d0

jk djk0

j0 modj~djj; 9

where k0

dk Ti t0ii;j=Tje and j0 is the corresponding

time slot for i;j0 at nj (i.e., t0

i

t0i

i;j t

j0

j ).Only after mapping djk to d0

jk, we can add i;jk to

d0

jk. By vector mapping, the size of the new vector~d

0

j is:

j~d0

jj j~djj Tj

gcdj~djj Tj; Ti: 10

The second difficulty comes from the various sizes ofvectors for link cost and distance. Suppose ~dij is the vectorrepresenting the distance of ni from a path through nj indiscrete time intervals. To implement (5), if ~i;j and

~d0

j havethe same size, we can directly add them up for computing

~dij. Otherwise, we need to expand the two vectors to be ofthe same size, which means expanding ~i;j by LCMj ~i;jj;j~d

0

jj=j ~i;jj times and~d

0

j by LCMj ~i;jj; j~d

0

jj=j~d

0

jj times. Afterthe expansion, we can directly add up the expandedvectors. We call such an operation, vector expansion.

Vector mapping and expansion do not change the valueof the discrete functions i;j and dj. They just change therepresentation of values of the two discrete functions. Thevector expansion is valid since the time expansion is infinite.

We define the following functions for implementation.

Definition 1. For a vector ~v:

. ror~v;ofs: output ~v0 where 8k 2 0::j~vj 1, v0k vk ofs mod j~vj;

. rol~v;ofs: output ~v0 where 8k 2 0::j~vj 1, v0k v~vj k ofs mod j~vj;

. map~v; a; b; ;ofs: output v0 where 8k 2 0::j~vj 1,v0k vdakb e ofs mod j~vj; and

. exp~v; e ~vk~v:::k~v e times (k presents catenatingoperation).

We utilize these functions to implement the TD-Bellmans equation. Suppose that ni has received thedistance vector ~dj of node nj. Suppose i;j0 is associatedwith the time slot l0i;j at node ni, and the data arriving time

slot for i;j0 is l0j at nj. Then, ~dij, the distance vector ofnito the sink from the path through nj, can be calculated as:

~dj0 mapror~dj; l

0j ; Ti; Tj; i;j0; 0;

~dij0 exp ~i;j; e1 exp~dj

0; e2;

~dij rol

~dij0; l0i;j

vec add

~i;j; ~dj; l

0i;j; l

0j

;

11

where j~dj0j is defined in (10) and by defining A

LCMj ~i;jj; j~d

0

jj, e1 A=j ~i;jj and e2 A=j~d

0

jj.We update ~di and the corresponding parent vector ~pi in

the following way. Suppose the original di0 is associated

with the time slot 0 at ni (i.e., di0 dit0i ). Now

~di; ~pi vminfexpdi; e0

1;exp~dij; e

0

2g; 12

where B LCMj ~dijj; j ~dij, e0

1 B=j~dij, and e

0

2 B=j~dijj.

The function ~di; ~pi vmin~v1; ~v2 compares the corre-sponding elements in the two vectors ~v1 and ~v2, and copiesthe smaller element of each pair into the correspondingelement in ~di and the corresponding vector ID into ~pi.

In addition, we define an operator ~< for comparing twovectors ~v1 and ~v2. Let C LCMj~v1j; j~v2j. If 8k 2 0::C 1exp~v1; C=j~v1jk exp~v2; C=j~v2jk, then ~v1 ~

7/28/2019 06148212

7/15

Proof. From (3), we havetk2i i;jt

k2i t

k1i i;jt

k1i k2 k1 Ti

k1 Ti t0ii;j mod Tj k2 Ti

t0ii;j mod Tj

k2 k1 Ti k1 k2 Ti mod Tj

k2 k1 Ti k2 k1 Ti mod Tj ! 0:

ut

We now give an intuitive explanation for Theorem 3. In astatic network, i;jt

k2i i;jt

k1i 0, because the link cost is

constant. In adaptively duty cycled WSNs, the link cost

i;jt captures the time difference between when node niwakes up at t and when node nj wakes up. Since node ni,which wakes up at tk1i , can always detect the awakeneighbor nj earlier (or at least at the same time) than thecase in which ni wakes up at t

k2i , we have t

k1i i;jt

k1i

tk2i i;jtk2i .

By Theorem 3, the time-dependent shortest path problemin adaptively duty-cycled WSNs is not NP-hard and issolvable in polynomial-time [9].

Theorem 4. Suppose node ni has two neighbors nj and nk, whichare one-hop away from each other. Then, at a time instant ti,we have the triangular property:

i;jti i;kti k;jti i;kti: 14

Proof. Suppose at time ti, the data arriving time slot at nj istj, and the data arriving time at nk is tk.

If tk tj, which means that the data arriving time atnk is earlier than the data arriving time at nj, i;kti k;jti i;kti tk ti tj tk tj ti i;jti.

If tk > tj, which means that the data arriving time atnk is later than the data arriving time at nj, we have:i;kti k;jti i;kti tk ti t

0

j tk > tj ti t0

j tk > tj ti > i;jti. The theorem follows. tu

Theorem 4, as illustrated in Fig. 3a, illustrates that node niwill always directly arrive at its neighbor nj without goingthrough other nodes. We now have the following claim:

Lemma 1 (Triangular Path Condition). For a node ni and itsneighbor nj, at any dispatching time, the one-hop path ni nj always has the least time delay for data transmission.

Proof. We prove this by induction. Suppose there aremultiple nodes along the path from ni to nj. We definethese nodes as nk; nk1; . . . ; nki. If i 0, based onTheorem 4, Lemma 1 is true.

Now, assume that i k and Lemma 1 is true. We

prove that Lemma 1 is true when i k 1. Suppose theadjacent node to ni along the path is nk. Then the directpath nk nj has shorter latency than the path alongnk1; . . . ; nki. Also, based on Theorem 4, ni nj has

shorter latency than the path (ni > nk > nj). There-fore, the direct path ni nj has shorter latency than thepath along nk, nk1; . . . , nki. The lemma follows. tu

An illustration is given in Fig. 3b. Note that thetriangular path condition does not exist in static networks.

5 ALGORITHM FOR INITIAL ROUTE CONSTRUCTIONWe now present an algorithm for initial time-dependentshortest path route construction in duty-cycled WSNs,where the distances from all nodes to the sink node areinitially infinite. The proposed algorithm, referred to as theFTSP algorithm, for Fast Time-Dependent Shortest Pathalgorithm, is inspired by the work in [10].

As described in Section 4, although the time axis isinfinite, the time-varying link costs and distance can beimplemented by vectors. Therefore, our algorithm whichimplements (1) is basically similar to the distributedBellman-Ford algorithm. The difference is that our algo-

rithm is exchanging vectors (i.e., for time-varying link costsand distances), rather than single values of static link costand distance.

FTSP is adapted from the distributed Bellman-Fordalgorithm and is augmented with a -synchronizer [27].We choose a -synchronizer in order to avoid exponentialmessage complexity, as discussed in Section 2. With a-synchronizer, the time cost and message cost are boundedand there is no gain in the best case. However, due to thelimited resource in WSNs, we believe it is more importantto avoid the exponential message complexity of thetraditional Bellman-Ford algorithm.

Equipped with the vector implementation, FTSP com-putes the shortest paths for infinite discrete time intervalsin one execution, in contrast with the solution in [10],which only calculates the shortest paths for a specifieddiscrete time.

Let jDmj denote the diameter of the longest shortest pathfor all nodes. We show that the message complexity of FTSPis OjDmkEj and the time complexity is OjDmkVj. FTSPdoes not suffer from exponential message complexity, likethat in previous works for the static shortest path problemover asynchronous networks (e.g., [31]).

5.1 Distributed Algorithm Description

There are essentially two steps in our algorithm forconstructing routing paths. In the first step, we build aspanning tree. In the second step, we calculate the shortestpaths and send back the acknowledgment to the sink fornodes in the network with a layer-by-layer approach. In ouralgorithm FTSP, we combine the two steps and implementthem through iterations. In the first iteration, FTSPcomputes the shortest paths for nodes in the nearest layerto the sink. In the following iterations, FTSP goes beyondone layer each time, until it reaches the last layer.

We present the data structures and message formats inFTSP:

. ~di: vector of distance from ni to ns, defined in (8);initially all elements are 1;

. ~i;j: link delay from ni to its neighbor nj, defined in(7); i;j0 is obtained by measurement;


Fig. 3. Triangular path condition: the direct path ni nj alwaysachieves the least latency among all paths from ni to nj.

7/28/2019 06148212

8/15

. ~pi: vector of parents for ni in the shortest path ni ns for infinite time intervals; initially all elements arenode ni;

. MSGIDsrc; IDfrom; ~d; updated: control message;IDsrc is the node ID of sink node, or update sourcenode (see Section 6); IDfrom is the senders node ID;~d is the distance vector of the sender; updatedindicates whether there is an update in the currentiteration, which will be explained later; and

. ACKj: boolean indicating whether a node receivesa control message from its neighbor nj.

We assume that ni knows the duration of the checkinginterval Tj of all its neighbors nj 2 Ni after measuring linkdelays. Initially, a directed spanning tree rooted at ns isbuilt upon the network. We assume that ni knows its parentst pi in the spanning tree. We also assume that FTSP isinvoked by higher-level protocols that create STARTimpetuses at ns.

The first iteration of FTSP begins when node ns receivesthe START impetus. Subsequent ones begin whenever nscompletes an iteration and determines whether another oneis necessary by checking whether there is a node whosedistance was minimized in the last iteration.

Each iteration begins at node ns by sending a controlmessage to all its neighbors. When replies from all itsneighbors have been received, node ns concludes that aniteration is completed. Every other node, i.e., ni (ni 6 ns),begins an iteration upon receiving a control message fromits parent st pi in the spanning tree, upon which it sendscontrol messages to all its neighbors except st pi. Whenreplies are received from all these neighbors, a controlmessage is sent to the parent, thereby completing the

current iteration at node ni.The control message from node nj contains the distance

vector ~dj (known thus far during the previous iterations)between nj and ns. When such a message is received atnode ni, node ni checks whether the new informationdecreases the value of any element in the current distancevector. It does so by considering the path that goes throughnj, taking into account the most recent information from nj.

We describe the procedures in Algorithms 1 and 2.

The functions vec add, vmin, and operator ~< aredefined in Section 4.3.

5.2 Correctness and Complexity

Let PATHi; tki be a path obtained by node ni, which is

starting at time tki and moving along its parent pik. Letdikm denote the value of dik after the mth iteration inFTSP. We have the following properties:

Theorem 5. 1) After termination, PATHi; tki is loop-free andconcatenated. 2) In the mth (m ! 0) iteration, a node ni whoseshortest path is at most m-hop away from the sink node will bedetermined, for all discrete time intervals tki 2 Ti.

Proof. For part 1, 8tki 2 Ti, after termination, suppose pikis set to the node nj for the shortest path with respect tons. Since nj is the parent of ni at the time slot tki ,PATHi; tki is a path composed ofPATHj; t

ki i;jt

ki ,

which is appended to node ni8tki 2 Ti. Thus, for any

node ni and 8tki 2 Ti, PATHi; t

ki is concatenated.

We prove that PATHi; tki is loop-free by contra-diction. Without loss of generality, assume that there is a

loop: ni0 ni1 ni2 nik ni0 . This means that,there is a shortest path ni0 ni1 . . . ; ; nik, wherenik is one-hop away from ni0 . According to the triangularpath condition in Lemma 1, such a shortest path cannotexist because ni0 nik is always the shortest one amongall paths from ni0 to nik, contradicting the assumption.

We prove part 2 by induction on m. It is easy to findthat the claim is true for m 0. Now, assume that theclaim is true for m 1 (i.e., the inductive hypothesis). Wenow prove for m by induction.

Consider a specific time tki and a node ni such thatthere is a shortest path with at most m hops between niand ns. Let SPi;s;tki ; m be the shortest path, which is atmost m hops from ni to ns at time tki . Let nj be nis parenton SPi;s;tki ; m at t

ki . This means that, there is a path

with at most m 1 hops between nj and ns.By the inductive hypothesis, nj determined its short-

est distance at the m 1th iteration. In the mthiteration, node nj sends its minimized distance vector~djm1 to node ni. Thus, SPi;s;t

ki ; m is determined after

receiving the vector ~djm1 in the mth iteration, whichcompletes the inductive step. Since tki is chosen arbi-trarily, this holds for all values of tki 2 Ti. tu

Part 2 in Theorem 5 implies that, for m ! Dm, all nodesdetermine their minimum delay and the corresponding

parents for all time intervals, since all shortest paths containat most Dm nodes.

Theorem 6. The message and time complexity of FTSP isODmjEj and ODmjVj, respectively.


7/28/2019 06148212

9/15

Proof. Based on the implementation of the -synchronizerin [32], in each iteration, there is exactly one messagetraversing each link in the spanning tree, totally jEjmessages exchanged. By Theorem 5, the number ofiterations is upper bounded by the longest shortest pathslength Dm. Thus, the message complexity is ODmjEj.

Suppose the largest delay for transmitting a messagein the spanning tree is a constant, denoted by jCj. In eachiteration, the time consumed is at most jVj jCj. Sincethere are at most Dm iterations, the time complexity isODmjVj. tu

6 ALGORITHM FOR DYNAMIC ROUTE MAINTENANCE

When compared with static networks, link changes andnode changes are more frequent in duty-cycled WSNs. If anode changes its duty-cycle configuration, or dynamicallyjoins or leaves the network, the links connecting with all itsneighbors will be changed at multiple time intervals. Insuch a situation, a single node update usually causes

multiple link updates.Some previous works in static networks (e.g., [15]) have

proposed solutions that efficiently deal with single linkupdates. They areinefficient for multiple link updates causedby a single node update. The algorithms in [15] are alsomemory-inefficient, since each node stores the route entriesfor all other nodes, incurring the space complexity ofOjVj.

Unlike previous works [15], where each node stores theroute information for all other nodes, we propose a solutionin which a node only stores the route to the sink, which ismore practical in WSNs due to their memory constraints. Inour proposed algorithm, when one node is updated (denoted

as the source node), the algorithm does not update theshortest path for the whole network from scratch, but onlyupdates necessary nodes. Thus, the main idea is first toidentify which nodes need to be updated. After that, thealgorithm updates the shortest path for these identifiednodes. The updating process is similar to the routeconstruction described in Section 5. But the starting point isthe source node, rather than from the sink node, and theupdating scope is just a subset of the whole network.

The proposed distributed algorithms for path mainte-nance are also equipped with the -synchronizer. Again, wechoose the -synchronizer in order to avoid exponentialmessage complexity as discussed in Section 2.

The proposed algorithms, referred to as FTSP-M (Mmeaning maintenance), focus on per-node update and canbe easily extended to node insertion and deletion. If thereare multiple node updates, the algorithms will runconcurrently at multiple nodes.

6.1 Overview and Rational of the DistributedAlgorithms

Suppose the source update node is nu and the correspond-ing input change is . We divide into two parts: inc anddec, where inc includes the increasing links for 8t

ku 2 Tu,

and dec includes the decreasing links for 8tku 2 Tu. Let

inc be the set of nodes that change either the distance orthe parents for all infinite discrete time intervals, as aconsequence ofinc. Similarly, let dec be the set of nodesaffected by dec. Apparently, inc [ dec.

We identify the input change as inc and dec,because dec is easy to handle given the sufficient loop-freecondition claimed in [33], which is referred to as the distanceincrease condition (DIC). With DIC, at time t, if node ni detectsa link-cost decrease or a decrease in the distance reportedby a neighbor, node ni is free to choose its new parents.Therefore, the node in dec can safely select a new parent.

However, things become more complicated for nodes in

inc, since a loop can be formed if they directly choose anew parent [33]. In order to address this issue, we adopttwo phases. In the first phase, we increase the node-to-sinkdistance for all nodes, which are descendants of nu. In thesecond phase, those nodes will reselect their parents basedon the Bellman-Ford approach.

We use the -synchronizer in phases 1 and 2, in order tobound the message complexity, though it will introduceadditional time cost. For WSNs, which have limited energyresource, less communication is usually more important forsome applications, which is the motivation for using the-synchronizer.

6.2 Algorithm DescriptionsWe use similar data structures and message formats as thatin Section 5.1. FTSP-M consists of two phases for node nuand all nodes ni 2 . We describe our algorithms inAlgorithms 3 and 5.

In phase 1, an initial spanning tree is built up gradually tocontain all nodes in inc. The purpose of phase 1 is to let

all nodes in inc increase their distances to the sink nodeas a consequence of inc, along the time-expanded shortestpath trees rooted at nu. After the termination of phase 1, allnodes in will never increase their distance again.


7/28/2019 06148212

10/15

In each iteration, node nu sends a control message to allneighbors. Every other node, i.e., ni (ni 6 nu) will sendcontrol messages to all its neighbors if it is in the spanningtree and receives a message from its parent. If ni is not in thespanning tree in the current iteration, it checks whether nj isits parent in its shortest path after receiving a controlmessage from nj, which can be done by checking whether

nj 2 ~pi. If true, nv will join the spanning tree and setnewspi nj. By doing so, the spanning tree will increase atmost one level in each iteration.

A control message will traverse from the root (nu) to allother nodes in the spanning tree just like that in FTSP.When node ni receives a control message from nj, it onlyupdates the element to be increased in its distance vector, asillustrated in Algorithm 4.

When replies from all its neighbors have been received,node nu concludes that an iteration is completed. Whenreplies are received from all neighbors by a node, a controlmessage is sent to the parent, thereby completing the

iteration at the node. When there is no distance increase forall nodes in inc, phase 1 will be terminated and node nuwill start phase 2.

In phase 2, the initial spanning tree built up in phase 1 iscontinuously growing until it contains all nodes in .Phase 2 is also running by iterations. In each iteration, whena node ni not in the spanning tree receives a control messagefrom nj, if the value of any elements in its distance vector isdecreased, it will join the spanning tree by setting its parentnewspi to nj. The distance update and message traversing inphase 2 of FTSP-M are just similar to that in FTSP.

6.3 Correctness and Complexity

In phase 1, all nodes in inc do not change their parents,but increase their distances as a consequence of inc. Thus,there is no loop in phase 1. In phase 2, all nodes in willnever increase their distances, thereby satisfying the distanceincrease condition [33]. All paths are therefore loop-free.

Theorem 7. In phase 1, each node in inc with at most m hopsaway from nu along the time-dependent shortest path will notincrease its distance after m iterations.

Proof. The proof is by induction on m. It is easy to find thatthe claim is true for m 0. Now, assume that the claim istrue for m 1 (i.e., the inductive hypothesis). We nowprove for m by induction.

Consider a specific time tki and a node ni 2 incsuch that there is a shortest path with at most m 1 hopsbetween ni and ns after node update. Let SPi;u;t

ki ; m

1 be the shortest path which is at most m 1 hops fromni to nu at time tki . Let nj be nis neighbor which is notupdated yet due to inc. Then nj is at most m hops awayfrom nu.

By the inductive hypothesis, ni will not increase itsdistance after m 1th iteration. In the mth iteration,node ni sends its updated distance vector ~djm1 to nodenj, and nj will determine its updated distance in theiteration ifnj 2 inc. Thus, SPj; u; t

ki ; m is determined

after receiving the vector ~dim1 in the mth iteration, whichcompletes the inductive step. Since tki is chosen arbitra-rily, this holds for all values of tki 2 Ti. tu

By Theorem 7, after jincj iterations, all nodes in incwill not increase their distance anymore.

Definition 2 (Updated-Subpath). For any node ni 2 , theupdated-subpath is from ni to the first node ne not in alongthe shortest path from ni to nu.

Theorem 8. In phase 2, all generated updated-subpaths are loop-free, and updated-subpaths with at most m hops long aredetermined in the mth iteration.

Proof. After phase 1, the DIC loop-free condition [33] issatisfied. Thus, all updated-subpaths are loop free inphase 2.

The proof for at most m hops-long updated-subpathsbeing determined in the mth iteration can be done byinduction. It is easy to find that the claim is true for m 0.

Now, assume that the claim is true for m 1 (i.e., theinductive hypothesis). We now prove for m by induction.

Consider a specific time tki and a node ni 2 such thatthere is an updated-subpath which contains m hops


7/28/2019 06148212

11/15

between ni and nu. Let UPi;u;tki ; m be the updated-

subpath which is at most m hops long at time tki . Let njbe nis parent on UPi;u;tki ; m at t

ki . This means that

there is an updated-subpath with at most m 1 hopsbetween nj and ns.

By the inductive hypothesis, the updated subpath fromnj to nu is determined at the m 1th iteration. In the mthiteration, node nj sends its minimized distance vector~djm1 to node ni. Thus, UPi;u;t

ki ; m is determined after

receiving the vector ~djm1 in the mth iteration, whichcompletes the inductive step. Since we choose tkiarbitrarily, the theorem holds for 8tki 2 Ti. tu

Theorem 9. The message complexity for per node update with output change is Ojj2 maxdeg. The time com-plexity is Ojj2, and space complexity is Omaxdeg.

Proof. In phase 1, the number of iterations is inc .In phase 2, there are at most iterations before allupdated-subpaths are decided. Thus totally, there areOjj2 maxdeg messages. In each iteration, the

consumed time is at most jj C (C is the largesttransmission delay for all links). Thus, the messagecomplexity is Ojj2. Since a node only stores theinformation of all its neighbors, the space complexity isOmaxdeg. tu

7 PRACTICAL IMPLEMENTATION

We now discuss some practical implementation issues. Inparticular, we discuss how to achieve awareness ofschedules of neighborhood and how to reduce the vectorsize given a large LCM in (6).

7.1 Schedule Awareness

FTSP and FTSP-M require awareness of wakeup schedulesof the neighborhood. Achieving this requirement dependson the specific underlying MAC protocol. We discuss threescenarios for achieving schedule awareness over differentMAC protocols.

Active neighbor discovery. This means that a nodeneeds to probe the schedules of its neighbors actively. Weconsider two scenarios which need active neighbor dis-covery. One is the LPL mode as adopted by B-MAC [5] andX-MAC [6]. The other is the low duty-cycling mode, where

time axis are arranged as consecutive short time slots, andall slots have the same duration.For either scenario, we assume that beacon messages

are sent out at the beginning of wakeup slots, similar to[28], [34]. In order to discover neighbors, a node has tostay awake in order to detect the beacon message of itsneighborhood. The node should wait until beacons arereceived from its neighbors. The frequency with which anode should detect its neighbors schedule depends onimplementation considerations.

Quorum-based duty-cycling. Active neighbor discoverymechanisms requires a node to stay awake actively. Now we

introduce quorum-based duty-cycling which does not havethat requirement. Here, the wakeup schedule follows aquorum system design [35]. In quorum-based duty cycling,two neighbor nodes can hear each other at least once within

bounded time slots via the nonempty intersection property.We choose cyclic quorum systems (cqs) [28] for presentation.

We use the following definitions for briefly reviewingquorum systems (used for wakeup scheduling). Consider acycle length n and U f0; . . . ; n 1g.

Definition 3. A quorum system Q under U is a superset ofnon-empty subsets of U, each called a quorum, which satisfies

the intersection property: 8G; H 2 Q : G \ H 6 ;. If 8G;H 2 Q; i 2 f0; 1; . . . n 1g : G \ H i 6 ;, where Hi fx i mod n : x 2 Hg; Q is said to have the rotationclosure property.

Cyclic quorum systems satisfy the rotation closureproperty, and are denoted as CA; n, where A is a quorumand n is the cycle length. For example, the cqs ff1; 2; 4g;f2; 3; 5g ; f7; 1; 3gg can be denoted as Cf1; 2; 4g; 7.

Given two different cyclic quorum systems CA1; n1 andCA2; n2, if two quorums from them, respectively, havenonempty intersections, then, even with clock drift, they

can be used for heterogenous wakeup scheduling in WSNs.For example, given Cf1;2;4g; 7 and Cf1;2;4;10g; 13,two quorums from them, respectively, have non-emptyintersection for every 13 time slots. Therefore, two nodesthat wake up with schedules complying with any twoquorums from these two cyclic quorum systems can heareach other.

By embedding the wakeup schedule information in thebeacon message, a node can always detect the wakeupschedules of its neighborhood through the nonemptyintersection property of the quorum design.

Synchronization. MAC protocols with synchronizationrequire that all neighboring nodes wake up at the same

time. The simplest method for doing this is to use a fullysynchronized pattern, like that in the S-MAC protocol [36].In this case, all nodes in the network wakeup at the sametime according to a periodic pattern. A further improve-ment can be achieved by allowing nodes to switch off theirradio when no activity is detected for a timeout value, likethat in the TMAC protocol [37]. In this scheme, neighboringnodes form virtual clusters to set up a common sleepschedule. The main disadvantages of such scheduledrendezvous schemes are the complexity of implementationand the overhead for synchronization. Through synchroni-zation, a node can conveniently know the schedules of itsneighbors. Schedule awareness can be achieved by periodicmessage exchange between a node and its neighbors.

7.2 Suboptimal Implementation with VectorCompression

The key implementation aspect of our proposed algorithmsis the vector representation of link cost functions anddistance functions. However, if the vector size is too large(i.e., the LCM in (6) is too large), the proposed algorithms,FTSP and FTSP-M, may not be feasible given the limitedmemory resource of embedded sensor nodes, and ineffi-cient due to distributed message exchanging. Based onTheorem 2, the vector size is depending on LCMT0; T1; . . . ;

Ti=Ti. The worst case is that all nodes have different cycles,and the size of the distance vector can be very large.

In a real implementation, to avoid arbitrarily long vectors,there are two possible solutions: 1) use a predefined duty


7/28/2019 06148212

12/15

cycle set, so that theLCMT0;T1;...;Ti

Ti can be bounded bycarefully selecting a duty cycle set, as discussed inSections 4.1 and 4.2; 2) adopt vector compression to achievea tradeoff, i.e., adopt a low-accurate distance vector, whichtakes less memory space, to represent the end-to-end latency.Hence, the output path is suboptimal in terms of latency.

The first solution can be applied to small-scale networks,where the node number is not large and predefining a dutycycle set is not difficult. For a large-scale network, we mightneed the second solution in which a bounded, globalLCMT0;T1;...;Ti

Tiis not necessary.

The basic idea of vector compression in the secondsolution is to smooth all values in a vector and represent the

vector with less information. For example, for a vector1 2 3 4 5 6 with six elements, we can approximatelyrepresent the vectors by a vector with two elements, suchas 2; 3; 5; 3 (where 2 1 2 3= and 5 4 5 6 = 3). Each tuple v; s in the vector represents the averagevalue of s elements in the original vector.

Theformal description of vectorcompressionis as follows.Vector compression. Suppose the source vector is vs

v1; v2; . . . ; vn and the target vector size is m (n > m). Wecompress vs by:

vt v1 v2 vlen

len;len

h;

v1len v2len v2lenlen

;len

; . . . ;

v1m1len v2m1len vnn m 1 len

; n m 1 len

!;

where len d nme.We choose the average value

v1ilenv2lenvi1lenlen as the

value of vti, because the expected deviation can beminimized by P

Plenj1

1len jvti vjj.

In addition to the averaging filter used in the aboveequation, other filters, such as the Wavelet transform filter[38] can also be applied for vector compression, as typicallyused in image compression.

7.3 Remarks

The FTSP algorithm described in Section 5 is a proactiverouting protocol. Although its time complexity is ODm jVj for initial route construction, it is affordable in the initialstage of WSNs. The low space complexity (Ojmaxdegj) forroute maintenance makes the algorithm scalable for large-scale WSNs.

Note that FTSP and FTSP-M target the ALPL mode [7]with various checking intervals. When all nodes havehomogenous LPL checking intervals (like that in thestandard B-MAC), according to (3) and (5), the link costfunction and the distance function will become constants. In

such a case, our algorithms will default to the static shortestpath algorithm. However, FTSP and FTSP-M will yield thesame message complexities and time complexities for thestatic situation.

Our work focuses on the scenario of a single sink node.However, it can be extended to multiple destinations. InWSNs, there is usually no end-to-end communication

between two arbitrary nodes. We only consider the general-ization of communication between one node and multiple

sink nodes, rather than the communication between twoarbitrary nodes.

8 EXPERIMENTAL RESULTS

We evaluated the performance of FTSP, FTSP-M, and thesub-optimal implementation through extensive simulations

using the OMNET++ discrete event simulator [39]. Wecompared our algorithms with other related algorithms forthe TDSP problem, including the distributed Bellman-Fordalgorithm [31] adapted to the time-dependent model

(Section 4), referred to here as TD-Bellman, and DSPP1[10]. The following three major metrics were measured inthe evaluation: 1) message count, 2) time cost, and3) average memory cost.

We examined two main factors that affect the perfor-mance of our algorithms, including network size and theunderlying duty cycle setting. Our experimental settingswere compatible with typical configurations, as in [3], [7],

and [8]. The wireless communication range in our simula-tion was set to 10 m. We adopt the wireless loss model usedin [40], which considers the oscillation of radio links.

We generated eight network size sets with varying sizes,

G1; . . . ; G8, which are listed in Table 1. For each networksize, we randomly generated 10 topologies. Each data point

presented in our simulation results in this section is theaverage of 10 topologies, with 10 runs on each topology.

We chose two MAC protocols: ALPL and quorum-based

duty-cycling. In the ALPL mode, a node just wakes up for ashort time during a checking interval to check the channelactivities. The duration of the checking interval varies for

different nodes. We changed the duration of the checkinginterval in our simulation experiments with four sets, C1, C2,

C3, and C4, as listed in Table 2. With each set, we randomlychose one element as the value of the LPL checking interval

for each node. With different time slot sets, the size of amessage (changed with vector size) is changing. Thus, weused a flexible packet size in our simulation. Each element in

a vector occupied 1 byte in all experiments.For quorum-based duty-cycling, we choose the 7; 3; 1,

and 21; 5; 1 difference sets for the heterogenous wakeupschedule settings. The duration of one time slot was set to

100 ms in quorum-based duty-cycling. Since FTSP, FTSP-M,TD-Bellman, and DSPP1 are independent of wakeup

scheduling, we argue that the comparison is fair even whenwe choose quorum-based duty-cycling.


TABLE 1Network Size Sets

TABLE 2Time Slot Sets

7/28/2019 06148212

13/15

8.1 Least-Latency Path Construction

In the first set of simulation experiments, we measured theALPL mode and chose C4 as the time slot setting, whichindicates that the largest distance vector size is 10 by (6),

and varied the network size. With the number of nodesincreasing from 50 to 2000 in G1,. . . ,G8, the average timeconsumed and the message count are shown in Fig. 4.

The average execution time of DSPP1 is about 10 timeslarger than that of FTSP, since DSPP1 has to be executed 10times to compute the shortest paths for all time intervals.FD-Bellman is better than FTSP when the network size issmall, since FD-Bellman does not have a distributedsynchronizer in its execution. When the network sizebecomes large (i.e., !1K), FTSP outperforms FD-Bellmandue to the exponential worst case message complexity ofthe Bellman-Ford algorithm. We observed similar trends fortime cost for the three algorithms, as shown in Fig. 4.

We also varied the time slot sets with a fixed networksize of G6, which represents medium-sized WSNs. Theresults are shown in Fig. 5. We observe that FTSP and FD-Bellman do not change their message count significantlysince they only depend on the network size. The time cost ofall algorithms become worse when the average value of allelements in the selected time slot set becomes larger, sincethe average link delay is correspondingly increasing.

Finally, we measured the performance for quorum-basedduty-cycling by fixing the network size of G6. Each noderandomly chose the 7; 3; 1 and 21; 5; 1 difference sets forits heterogenous schedule settings. As shown in Fig. 6, we

observe similar trends for execution time and message count.The average execution time of DSPP1 is about three timeslarger than that of FTSP, since DSPP1 has to be executed threetimes to compute the shortest paths for all time intervals

given the 7; 3; 1 and 21; 5; 1 difference sets. The time costsfor all algorithms become worse for larger sized networks,which is consistent with the conclusion in Theorem 6.

8.2 Least-Latency Path Maintenance

For evaluating the path maintenance performance of FTSP-M, we return to static networks by selecting the time slot setof C1 in Table 2 for the ALPL mode. We do so for thepurpose of a fair comparison with the previous work in[15], referred to here as Full-Dynamic and DSDV [41] withunicast support.

We first evaluate the effect of input changes on allalgorithms for medium-sized networks by choosing G6. As

shown in Fig. 7, FTSP-M achieves the median message costand time cost when input changes become large. The reasonis that, DSDV suffers from exponential message complexity.In addition, FTSP-M uses the synchronizer, which con-sumes additional time and messages, which is not asefficient as that in Full-Dynamic.

We also measured the average memory cost by varyingthe network size for the two underlying duty-cyclingmechanisms. We first chose the ALPL mode and set thetime slot set ofC1 in Table 2 for all nodes. The results shownin Fig. 8 indicate that FTSP-M achieves the best memory cost,which does not depend on the network size. The memory

costs of DSDV and Full-Dynamic increase with the networksize, since each node stores an entry for all other nodes.Finally, we measured the average memory cost for the

quorum-based duty-cycling mechanism. Each nodes ran-domly chose the 7; 3; 1 difference sets for the hetero-genous schedule settings. As shown in Fig. 8, we observesimilar trends for the quorum-based duty-cycling mechan-ism. The only difference is that with 7; 3; 1 difference sets,each node maintains three entries in the routing table forall neighbors.

8.3 Performance of Suboptimal Implementation

For suboptimal implementation with vector compression,

the performance is a tradeoff between path latency andmessage size. We evaluated this tradeoff for both initialroute construction and route maintenance. We first fixedthe duty cycle setting by choosing C4 and compared the


Fig. 4. Comparison of time efficiency and message efficiency byvarying jVj.

Fig. 5. Comparison of time efficiency and message efficiency by varyingtime slots in ALPL mode.

Fig. 7. Performance comparison for route maintenance by varying inputchange: ALPL mode.

Fig. 8. Performance comparison for route maintenance on memoryrequired in each node.

Fig. 6. Comparison of time efficiency and message efficiency forquorum-based duty-cycle setting.

7/28/2019 06148212

14/15

performance between FTSP and its suboptimal implemen-tation. Since the message count does not rely on vectorimplementation, we compared the vector size (in terms ofthe number of elements in a vector). Since each elementtook one byte in a message packet, the packet size (in bytes)represents the vector size.

Fig. 9 shows the results. We observe that the suboptimalimplementation achieves less message size with vector

compression. To understand the end-to-end latency of thetwo techniques, we compared the maximum value of the

least latency achieved by all nodes (defined as max-minlatency). As shown in Fig. 9, the suboptimal implementa-

tion has higher max-min latency than FTSP. However, thesuboptimal implementation has a smaller average messagesize than FTSP.

We then fixed the duty cycle setting by choosing the

7; 3; 1 and 21; 5; 1 difference sets as the wakeup schedulefor all nodes. We observed similar trends, as shown in

Fig. 10. We observe that the suboptimal implementation hashigher max-min latency than FTSP, but has a smaller vectorsize. The simulation results show the performance tradeoff

after introducing the suboptimal implementation, whichhas smaller message size but higher latency.

9 CONCLUSIONS

In this paper, we addressed the distributed shortest pathrouting problem in duty-cycled WSNs. Our contributionsare four-fold. First, we modeled duty-cycled WSNs as time-

dependent networks, which satisfy the FIFO condition.Second, we presented the FTSP algorithm for finding

shortest paths in such networks. FTSP has polynomialmessage complexity and is more time-efficient thanprevious solutions. Third, we presented FTSP-M for

distributed route maintenance with node insertion, updat-ing, and deletion. FTSP-M is memory efficient and has

polynomial message complexity. Finally, we proposed asuboptimal implementation on vector representations to

reduce memory requirements. The vector size of thesuboptimal solution does not depend on the largest LCM

value as shown in (6). Simulation results validated the

effectiveness and efficiency of our solutions.We envision several directions for future work. One is to

investigate the time-dependent minimum spanning tree

problem, which is NP-Hard in duty-cycled WSNs. Another

direction is to study time-dependent multicast routing in

duty-cycled WSNs, which is a required service for many

applications and is the reverse direction of all-to-one least-latency routing.

REFERENCES[1] S. Lai and B. Ravindran, On Distributed Time-Dependent

Shortest Paths over Duty-Cycled Wireless Sensor Networks,Proc. IEEE INFOCOM, 2010.

[2] C. Schurgers and M.B. Srivastava, Energy Efficient Routing inWireless Sensor Networks, Proc. Military Comm. Conf. (MILCOM01), vol. 1, pp. 357-361, 2001.

[3] A. Woo, T. Tong, and D. Culler, Taming the UnderlyingChallenges of Reliable Multihop Routing in Sensor Networks,Proc. First Intl Conf. Embedded Networked Sensor Systems (Sensys),pp. 14-27, 2003.

[4] C.M. Vigorito, D. Ganesan, and A.G. Barto, Adaptive Control ofDuty Cycling in Energy-Harvesting Wireless Sensor Networks,Proc. IEEE Comm. Soc. Conf. Sensor, Mesh and Ad Hoc Comm. andNetworks (SECON), pp. 21-30, June 2007.

[5] J. Polastre, J. Hill, and D. Culler, Versatile Low Power MediaAccess for Wireless Sensor Networks, Proc. Intl Conf. EmbeddedNetworked Sensor Systems (Sensys 04), pp. 95-107, 2004.

[6] M. Buettner, G.V. Yee, E. Anderson, and R. Han, X-mac: A ShortPreamble MAC Protocol for Duty-Cycled Wireless Sensor Net-works, Proc. ACM Fourth Intl Conf. Embedded Networked SensorSystems (Sensys), pp. 307-320, 2006.

[7] J. Raja, B. Pierre, and V. Cristina, Adaptive Low Power Listeningfor Wireless Sensor Networks, IEEE Trans. Mobile Computing,vol. 6, no. 8, pp. 988-1004, Aug. 2007.

[8] Y. Gu and T. He, Data Forwarding in Extremely Low Duty-CycleSensor Networks with Unreliable Communication Links, Proc.Sixth ACM Conf. Embedded Network Sensor Systems (Sensys), pp. 32-38, 2007.

[9] K.L. Cooke and E. Halsey, The Shortest Route Through aNetwork with Time-Dependent Internodal Transit Times,

J. Math. Analysis Application, vol. 14, pp. 493-498, 1966.[10] A. Orda and R. Rom, Distributed Shortest-Path Protocols for

Time-Dependent Networks, Distributed Computing, vol. 10, no. 1,pp. 49-62, 1996.

[11] I. Chabini, Discrete Dynamic Shortest Path Problems in Trans-portation Applications: Complexity and Algorithms with OptimalRun Time, Transportation Research Records, vol. 1645, pp. 170-175,1998.

[12] B. Ding, J.X. Yu, and L. Qin, Finding Time-Dependent ShortestPaths over Large Graphs, Proc. 11th Intl Conf. Extending DatabaseTechnology (EDBT 08), pp. 205-216, 2008.

[13] H. Chon, D. Agrawa, and A. Abbadi, Fates: Finding a TimeDependent Shortest Path, Mobile Data Management, vol. 2574,pp. 165-180, 2003.

[14] A. Orda and R. Rom, Minimum Weight Paths in Time-Dependent Networks, Networks, vol. 21, pp. 295-319, 1991.

[15] C. Serafino, D. Gabriele, F. Daniele, and N. Umberto, A FullyDynamic Algorithm for Distributed Shortest Paths, TheoreticalComputer Science, vol. 297, nos. 1-3, pp. 83-102, 2003.

[16] G. DAngelo, S. Cicerone, G.D. Stefano, and D. Frigioni, PartiallyDynamic Concurrent Update of Distributed Shortest Paths, Proc.Intl Conf. Computing: Theory and Applications, pp. 32-38, 2007.

[17] H. Wang, X. Zhang, F. Abdesselam, and A. Khokhar, DPS-MAC:An Asynchronous MAC Protocol for Wireless Sensor Networks,Proc. 14th Intl Conf. High Performance Computing, vol. 7, pp. 393-404, June 2007.

[18] L. Su, C. Liu, H. Song, and G. Cao, Routing in Intermittently

Connected Sensor Networks, Proc. IEEE Intl Conf. NetworkProtocols, pp. 278-287, 2008.[19] Y. Gu and T. He, Bounding Communication Delay in Energy

Harvesting Sensor Networks, Proc. IEEE 30th Intl Conf. Dis-tributed Computing Systems, pp. 837-847, 2010.


Fig. 10. Performance comparison for route construction: latency andmessage size over quorum-based duty-cycling mode.

Fig. 9. Performance comparison for route construction: latency andvector size (in bytes) over ALPL mode.

7/28/2019 06148212

15/15

[20] Y. Gu, T. He, M. Lin, and J. Xu, Spatiotemporal Delay Control forLow-Duty-Cycle Sensor Networks, Proc. IEEE 30th Real-TimeSystems Symp. (RTSS), pp. 127-137, 2009.

[21] X. Yang and N.H. Vaidya, A Wakeup Scheme for SensorNetworks: Achieving Balance between Energy Saving and End-to-End Delay, Proc. IEEE 10th Real-Time and Embedded Technologyand Applications Symp., 2004.

[22] G. Lu, N. Sadagopan, B. Krishnamachari, and A. Goel, DelayEfficient Sleep Scheduling in Wireless Sensor Networks, Proc.IEEE INFOCOM, pp. 2470-2481, 2005.

[23] K.V.S. Ramarao and S. Venkatesan, On Finding and UpdatingShortest Paths Distributively, J. Algorithms, vol. 13, no. 2, pp. 235-257, 1992.

[24] S. Haldar, An All Pairs Shortest Paths Distributed AlgorithmUsing 2n2 Messages, J. Algorithms, vol. 24, no. 1, pp. 20-36, 1997.

[25] G.F. Italiano, Distributed Algorithms for Updating Shortest Paths(Extended Abstract), Proc. Fifth Intl Workshop Distributed Algo-rithms (WDAG), pp. 200-211, 1992.

[26] B. Awerbuch, I. Cidon, and S. Kutten, Communication-OptimalMaintenance of Replicated Information, Proc. 31st Ann. Symp.Foundations of Computer Science (SFCS), pp. 492-502, 1990.

[27] B. Awerbuch, Complexity of Network Synchronization, J. ACM,vol. 32, no. 4, pp. 804-823, 1985.

[28] S. Lai, B. Zhang, B. Ravindran, and H. Cho, CQS-Pair: CyclicQuorum System Pair for Wakeup Scheduling in Wireless SensorNetworks, Proc. Intl Conf. Principles of Distributed Systems

(OPODIS). pp. 295-310, 2008.[29] R. Bellman, On a Routing Problem, Quarterly of Applied Math.,

vol. 16, no. 1, pp. 87-90, 1958.[30] P. Sommer and R. Wattenhofer, Gradient Clock Synchronization

in Wireless Sensor Networks, Proc. ACM Intl Conf. InformationProcessing in Sensor Networks (IPSN), pp. 37-48, 2009.

[31] K.M. Chandy and J. Misra, Distributed Computation on Graphs:Shortest Path Algorithms, Comm. ACM, vol. 25, no. 11, pp. 833-837, 1982.

[32] A. Segall, Distributed Network Protocols, IEEE Trans. Informa-tion Theory, vol. 29, no. 1, pp. 23-35, Jan. 1983.

[33] J.J. Garcia-Lunes-Aceves, Loop-Free Routing Using DiffusingComputations, IEEE/ACM Trans. Networking, no. 1, pp. 130-141,Feb. 1993.

[34] Y. Sun, O. Gurewitz, and D.B. Johnson, RI-MAC: A Receiver-Initiated Asynchronous Duty Cycle MAC Protocol for DynamicTraffic Loads in Wireless Sensor Networks, Proc. ACM Conf.Embedded Network Sensor Systems (Sensys), pp. 1-14, 2008.

[35] W.S. Luk and T.T. Huang, Two New Quorum Based Algorithmsfor Distributed Mutual Exclusion, Proc. Intl Conf. DistributedComputing Systems (ICDCS), pp. 100-106, 1997.

[36] W. Ye, J. Heidemann, and D. Estrin, Medium Access Controlwith Coordinated Adaptive Sleeping for Wireless Sensor Net-works, IEEE/ACM Trans. Networking, vol. 12, no. 3, pp. 493-506,

June 2004.[37] T.V. Dam and K. Langendoen, An Adaptive Energy-Efficient

Mac Protocol for Wireless Sensor Networks, The First ACM Conf.Embedded Networked Sensor Systems (Sensys), 2003.

[38] S. Mallat, A Wavelet Tour of Signal Processing: The Sparse Way,third ed. Academic Press, 2008.

[39] OMNET++, http://www.omnetpp.org/, 2012.

[40] M. Zuniga and B. Krishnamachari, Analyzing the TransitionalRegion in Low Power Wireless Links, Proc. IEEE Comm. Soc. Conf.Sensor, Mesh and Ad Hoc Comm. and Networks (SECON), pp. 517-526, 2004.

[41] C.E. Perkins and P. Bhagwat, Highly Dynamic Destination-Sequenced Distance-Vector Routing (DSDV) for Mobile Compu-ters, ACM SIGCOMM Computer Comm. Rev., vol. 24, no. 4,pp. 234-244, 1994.

Shouwen Lai received the PhD degree in theDepartment of Electrical and Computer Engi-neering in Virginia Polytechnic Institute andState University (Virginia Tech) in 2010. He isa senior engineer in Qualcomm Inc where he isworking on CDMA software development. Hisresearch topics include wireless sensor net-works, real-time systems and mobile computing.He is also interested in system development andimplementations for wireless networking, em-

bedded systems and distributed systems. Before coming to VirginiaTech, he worked for two years as a research engineer in Hitachi (China)R&D corporation where he conducted research and development worksfor network mobility, security provision, multimedia applications over 3Gand WLAN networks. He is a member of the IEEE.

Binoy Ravindran is an associate professor inthe ECE Department at Virginia Tech. Hisresearch interests include real-time, embedded,and networked systems, with a particular focuson resource management at various levels ofabstraction from OSes to virtual machines toruntimes to middleware. He and his studentshave published more than 170 papers in thisspace, and some of his groups results havebeen transitioned to US DoD programs. He is a

US Office of Naval Research senior faculty fellow, an ACM distinguishedspeaker, and an associate editor of the ACM Transactions onEmbedded Computing Systems. He is a senior member of the IEEE.

. For more information on this or any other computing topic,please visit our Digital Library at www.computer.org/publications/dlib.


06148212

Documents