Ttd 2011010163

8/13/2019 Ttd 2011010163

1/13

A Delay-Efficient Algorithm for DataAggregation in Multihop Wireless

Sensor NetworksXiaohua Xu, Student Member, IEEE, Xiang-Yang Li, Senior Member, IEEE,

Xufei Mao, Student Member, IEEE, Shaojie Tang, Student Member, IEEE, and

Shiguang Wang, Student Member, IEEE

AbstractData aggregation is a key functionality in wireless sensor networks (WSNs). This paper focuses on data aggregationscheduling problem to minimize the delay (or latency). We propose an efficient distributed algorithm that produces a collision-freeschedule for data aggregation in WSNs. We theoretically prove that the delay of the aggregation schedule generated by our algorithmis at most 16R14time slots. Here,R is the network radius and is the maximum node degree in the communication graph ofthe original network. Our algorithm significantly improves the previously known best data aggregation algorithm with an upper bound ofdelay of 24D616 time slots, whereD is the network diameter (note that D can be as large as 2R). We conduct extensivesimulations to study the practical performances of our proposed data aggregation algorithm. Our simulation results corroborate ourtheoretical results and show that our algorithms perform better in practice. We prove that the overall lower bound of delay for data

aggregation under any interference model ismaxflog n; Rg, wherenis the network size. We provide an example to show that the lowerbound is (approximately) tight under the protocol interference model when rIr, whererI is the interference range and r is thetransmission range. We also derive the lower bound of delay under the protocol interference model when r < rI

8/13/2019 Ttd 2011010163

2/13

analysis, we use the protocol interference model andassume that rIr. As an illustration, we first present anefficient centralized algorithm that will build a TDMAschedule of nodes based on the aggregation tree, which isbuild distributively. Our schedule uses a bottom-upapproach: schedule nodes level by level starting from thelowest level. We theoretically prove that the delay of theaggregation schedule generated by our algorithm is at most16R14 time slots. Note that for general rI, ouralgorithm will produce a collision-free schedule for aggre-gation whose delay is at most rIr 2R time slots. Wethen present an efficient distributed algorithm that buildsan aggregation tree and gives a schedule for each node. Forsimplicity, our distributed method assumes that the clocksof all nodes are synchronized. Unlike our centralizedalgorithm, our distributed algorithm will not explicitlyproduce a schedule for nodes in the aggregation tree. Theschedule for nodes is implicitly generated in the process ofdata aggregation. Our distributed scheduling algorithmthus works well in dynamic networks, as long as theconstructed backbone of the network by our algorithmremains unchanged. Obviously, whenrIr, for a networkG with radius R and the maximum node degree , thedelay by any data aggregation algorithm is at least R. Thisimplies that our algorithm is within a small constant factorof the optimum. We then conduct extensive simulations tostudy the practical performance of our proposed dataaggregation method. The simulation results corroborate ourtheoretical results and show that our method performsbetter in practice. We find that data aggregation by ourdistributed method has delay close to R. Besides, we provethat the overall lower bound of delay for data aggregation

under any interference model is maxflog n; Rg. We providean example to show that the lower bound is (approxi-mately) tight under the protocol interference model whenrIr. We also analyze the lower bound of delay under theprotocol interference model when r < rI

8/13/2019 Ttd 2011010163

3/13

the first phase and the second phase is the core of our

algorithm. We will present these two phases in thefollowing two sections. At the end of the section, wepresent a distributed implementation based on our cen-

tralized aggregation scheduling algorithm.

3.1 The Overall ApproachIn this section, we describe our overall approach for dataaggregation. As a prestep, we will construct a CDS as a

backbone for the network. Then, our aggregation schedul-ing algorithm can be divided into two phases as follows:

Phase I.Every dominator aggregates the data from all its

dominatees (as shown in Fig. 1a).Phase II. Dominators aggregate their data to the sink

nodevs level by level (as shown in Fig. 1b).For each level in the second phase, the process can be

further divided into two subphases:

. All the dominators aggregate their data to itscorresponding connectors.

. All the connectors transmit their data to thedominators in the upper level.

3.2 Dominating Set Construction

As our algorithm is aggregation-tree-based, in the firstphase, we construct an aggregation tree in a distributed wayusing an existing method [19]. We employ a CDS in thisphase since it can behave as the virtual backbone of a sensornetwork. A distributed method of constructing a CDS hasbeen proposed by Wan et al. [19]. In their algorithm, a special

dominating set is constructed first and then a CDS isconstructed to connect dominators and the other nodes.This CDS tree can be used as the aggregation tree in ourscheduling algorithm with a small modification as follows:

1. We choose thetopology centerof the UDG as the rootof our BFS tree. Note that previous methods haveused the sink node as the root. Our choice of thetopology center enables us to reduce the delay to afunction of the network radius R, instead of thenetwork diameter D proved by previous methods.Here, a nodev0is called thetopology centerin a graphG if v0arg minvfmaxudGu; vg, where dGu; v isthe hop distance between nodes u and v in graph G.RmaxudGu; v0is called theradiusof the networkG. Note that in most networks, the topology center isdifferent from the sink node.

2. After the topology center gathered the aggregateddata from all nodes, it will then send the aggregationresult to the sink node via the shortest path from thetopology centerv0to the sink nodevs. This will incuran additional delay dGv0; vs of at most R.

Algorithms 1 and2 briefly reviewthe methods forselecting

adominatingsetandaCDSin[19].InAlgorithm1,the rank of a

nodeuislevel;I Du, wherelevelis the hop distance ofutotheroot. Theranks ofnodesarecompared using lexicographicorder. After execution of Algorithm 2, all black nodes form a

dominating set. For each gray node, either it is a leaf or its

children in theaggregation tree areblack nodes. In thesecond

case,agraynodeplaystheroleofconnectingtwoblacknodes.

The rootis a nodein the dominating set (a black node) and all

its neighbors inGare its children in BFS.

Algorithm 1.Distributed Dominators Selection [19]1: Determine the topology center of the UDG as v0;2: Construct a BFS (breadth-first-search) tree rooted at

v0 with height R, the radius of the original network;3: Every node colors itself white;4: Root nodev0 changes its color to black and broadcasts

a message;BLACK to its one-hop neighbors in G;5: foreach white node u received a message BLACK do6: ucolors itself gray and broadcasts a message GRAY to

its one-hop neighbors in G;7: if a white node wreceives GRAY from all its lower

ranked neighbors then8: wcolors itself as black and sends message BLACK to

all its one-hop neighbors in G;9: All black nodes form a dominating set.

Algorithm 2.Distributed Construction of AggregationTreeT

1: Select a set of dominators as in Algorithm 1;2: Root nodev0 sends a message GRAY-JOIN to its

one-hop neighbors in G;3: ifan unmarked gray node not in Treceived a message

GRAY-JOINthen4: Join Twith the sender as its parent;5: Send a message BLACK-JOIN to its one-hop

neighbors;6: Mark itself;

7: if an unmarked black node not in T received messageBLACK-JOINthen8: Join Twith the sender as its parent;9: Send a message GRAY-JOIN to its one-hop neighbors;

10: Mark itself;11: ReturnT.

3.3 Centralized Algorithm

The second phase is aggregation scheduling, which is the

core of the whole algorithm. It is based on the aggregationtree constructed in the first phase. As an illustration, we

first present an efficient centralized algorithm. We will then

present our distributed scheduling implementation inSection 3.4.

Algorithm 3 shows how the data from the dominateesare aggregated to the dominators. At every time slot, the set

XU ET AL.: A DELAY-EFFICIENT ALGORITHM FOR DATA AGGREGATION IN MULTIHOP WIRELESS SENSOR NETWORKS 165

Fig. 1. The overall approach: the black nodes are dominators and white

nodes are dominatees. (a) Phase I. (b) Phase II.

8/13/2019 Ttd 2011010163

4/13

of dominators will gather data from as many dominatees(whose data have not been gathered to a dominator yet) aspossible. Note that since the maximum degree of nodes inthe communication graph is, our method guarantees thatafter at most time slots, all the dominatees data can begathered to their corresponding dominators successfullywithout interferences, which will be proved in Lemma 4.The basic idea is as follows: each dominator will randomly

pick a dominatee whose data are not reported to anydominator yet. Clearly, these selected dominatees may notbe able to send their data to corresponding dominators inone time slot due to potential interferences. We thenreconnect these dominatees to the dominators (and maynot schedule some of the selected dominatees in the currenttime slot), using Algorithm 4, such that these new links cancommunicate concurrently.

Algorithm 3.Aggregate Data to Dominators1: fori1; 2; . . . ; do2: Each dominator randomly chooses a neighboring

dominatee, whose data are not gathered yet, astransmitter. The set of such chosen links form a linksetL.

3: Apply Algorithm 4 toL, assume the output link setisS;

4: All the output links inSnow transmitsimultaneously;

5: ii1;

Algorithm 4.Reconnect Dominatees to DominatorsInput:a set of linksL;Output:a set of conflict-free links S;1: S

L;

2: while (exist a pair of conflicting links in S) do3: Letuizi and ujzj be one of the pairs of conflicting links.4: Find the setsDi andDj based on their definitions;5: if (juizjj 1 andjujzij> 1) then6: If Dj ;, remove the link ujzj.7: If Dj6 ;, replaceujzj by a link ujzj0 , for a random

zj02 Dj.8: else if(jujzij 1 andjuizjj> 1) then9: If Di ;, remove link uizi.10: If Di6 ;, replaceuizi with uizi0 , for a random

zi02 Di.

11: else if

(ju

jz

ij 1

andju

iz

jj 1

)then

12: If Di ;, remove the linkuizi; else ifDj ;, removethe linkujzj.

13: If Di6 ; Dj6 ;, replaceuizi andujzj by two newlinksuizi0 ,ujzj0 , for a randomzi02 Di and a randomzj02 Dj.

Suppose that two directed links uizi and ujzj interferewith each other (see Fig. 2a), where the dominatees ui anduj are transmitters in these two links, respectively, and ziandzjare dominators. For each dominateev, letDvbe theset of neighboring dominators. Obviously,jDvj 5 forany node v. Let Dui Dui n fzig, Duj Duj n fzjg.Note that here Dui and Duj may be empty, or Dui \Duj may not be empty.

For every other active transmitterv,v6uiandv6uj, wedelete all dominators from Dui(and also from Duj) that

are within the transmission range of v. Note that we candiscard these dominators since their degrees are alreadydecreased by at least 1 because of the existence of some activetransmitterv. We also delete the dominators that are within

the transmission range of both ui and uj from Dui andDuj. Note that we can do this because these dominatorsdegree will be decreased by 1 since our rescheduling canguarantee at least one transmitter ofuiandujwill remain asan active transmitter, as we will show later.

Let Di (resp. Dj) be the set of remaining dominators inDui (resp. Duj).

Fig. 2b illustrates one possible state after the precedingtwo deletions of dominators from Duiand Duj. Note that

1. The distance between ui and any member of Dj isgreater than 1. The distance between uj and anymember ofDi is greater than 1.

2. It is possible thatDi orDj or both could be empty.

Algorithm 4 shows how to reconnect dominatees todominators to avoid the interference.

After all the data in the dominatees have beenaggregated to dominators, our next step is to aggregate allthe intermediate results in the dominators to the root.

We can see that in each layer of the BFS tree, there aresome dominator(s) and some dominatee(s). For everydominatee, it has at least one dominator neighbor in thesame or upper level. Thus, every dominator (except theroot) has at least one dominator in the upper level withintwo hops. Using this property, we can ensure that all thedata in the dominators can reach the root finally if everydominator transmits its data to some dominator in upperlevel within two hops. From another point of view,considering dominators in the decreasing order of theirlevels, a dominator u in level L aggregates data from alldominators in level L1or L2that are within two hopsofu. This will ensure that all the data will be aggregated tothe root. Algorithm 5 presents our method in detail.

Algorithm 5.Centralized-IASInput:BFS tree with root v0and depthR, and a distributiveaggregation function f (Please see the definition of

aggregation function in [23]), dataAistored at each nodevi.1: Construct the aggregation treeT0 using Algorithm 2.

Remove the redundant connectors to ensure that eachdominator uses at most 12 connectors to connect itself

166 IEEE TRANSACTIONS ON PARALLEL AND DISTRIBUTED SYSTEMS, VOL. 22, NO. 1, JANUARY 2011

Fig. 2. (a) An interference between two links. The dashed line means

that the endpoints are within interference ranges of each other. (b) A

state after rescheduling.

8/13/2019 Ttd 2011010163

5/13

to all dominators in lower level and is within two-hops.Here a connector nodex(a dominatee of a dominatoru)is said to beredundantfor the dominator u, if removingxwillnot disconnect any of the two-hop dominators ofufromu.LetTbe the final data aggregation tree.

2: foriR1; R2; . . . ; 0do3: Choose all dominators, denoted byBi, in leveli of theBFS tree.4: for every dominator u2Bi do5: Find the set D2u of unmarked dominators that

are within two-hops ofu in BFS, and in lower leveli1 or i2.

6: Mark all nodes in D2u.7: Every nodew in D2usendsfAw; X1; X2; . . . ; Xd

to the parent node (a connector node) in T. HereAwis the original data set nodew has, andX1,X2,. . . ,Xdare data that nodewreceived from itsdchildrennodes in T.

8: Every nodezthat is a parent of some nodes inD2u sends fX1; X2; . . . ; Xp to nodeu (which isthe parent ofzin T). HereX1,X2, . . . , Xp are datathat nodezreceived from itsp children nodes inT.

9: ii110: The rootv0 sends the result to the sink using the

shortest path.

In Algorithm 5, we only concentrate on communicationsbetween dominators. The algorithm runs from lower levelto upper level in aggregation tree, every dominator willremain silent until the level where it locates beginsrunning. When it is its turn, the dominator will try to

gather all the data from other dominators in lower levelsthat have not been aggregated. If a dominators data havebeen collected before, then it is unnecessary to be collectedagain. Actually, we have to guarantee that every datumshould be and only be used once. Our algorithm imple-ments this by discarding the dominators after their datahave been gathered to upper levels.

Note that in our algorithm after we process dominatorsBi (all dominators in level i), there may still have somedominators in Bi1 whose data are not aggregated. Thiscould happen because a dominator in Bi1 could be withintwo hops of some dominator in Bi1, but not within twohops ofany dominator from B

i. We conclude that after the

execution of all the dominators in Bi , the data from alldominators in Bi2 have already been aggregated.

3.4 Distributed Implementation

Now we present a distributed implementation for our dataaggregation scheduling. The distributed implementationconsists of three stages:

1. Every dominatee transmits its data to the neighbor-ing dominator with the lowest level.

2. Data are aggregated from dominators in lower levelsto dominators in upper levels, and finally, to the root

of the aggregation tree, which is the topology centerof the network.3. Topology center then transmits the aggregated data

to the original sink via the shortest path.

The distributed implementation differs from the centra-lized one in that the distributed one seeks to transmitgreedily: we will try to allocate a node v a time slot to transmitwhenever v has collected the aggregated data from all itschildren nodes in the data aggregation tree T. Thus, the firsttwo phases may interleave in our distributed implementa-tion. The interleaving will reduce the delay greatly since itincreases the number of simultaneous transmissions. Later,we will provide the simulation result of our distributedmethod, which shows that our distributed implementation isquite close to 1"R1, where " is a small positiveconstant. Therefore, we conjecture that the data aggregationdelay by our distributed implementation indeed has atheoretical performance guarantee of1"R1.It will be interesting if we can prove or disprove thisconjecture, which is left as future work.

To run our algorithm, every node vi should maintainsome local variables, which are as follows:

1. Leaf indicator: Leafi 2 f0; 1g, to indicate whether thenodevi is a leaf node in the data aggregation tree.

2. Competitor Set:CSi, the set of nodes such that foreach j2CSi, nodes vi and vj cannot transmitsimultaneously to their parents due to interference.In other words, ifj2CSi, we have either the parentpTi of node vi in the data aggregation tree T iswithin the interference range of node vj; or theparentpTjof nodevjin the data aggregation treeTis within the interference range of node vi; or both.Note that under the interference model studied inthis paper, each node in CSi is within a smallconstant number of hops ofi.

3. Ready Competitor Set:RdyCSi, which is the set of

nodes that collides withiand it is ready to send datato its parent, i.e., it has received the data from all itschildren nodes.

4. Time Slot to Transmit: TSTi, which is theassigned time slot that node vi indeed sends itsdata to its parent.

5. Number of Children:NoCi, which is the number ofchildren nodes ofvi in the data aggregation tree T.

Observe that here, at some time, if we let Rdy be the setof nodes which are ready to transmit (i.e.,v2Rdy iffv hascollected the aggregated data from all its children nodes inthe data aggregation treeT), and letFdenote all the nodes

which have finished their transmission, then RdyCSi CSi \RdyF. TheTSTof all nodes is initialized to 0. Thedetails of our distributed method are shown in Algorithm 6.

Algorithm 6.Distributed Data Aggregation SchedulingInput: A network G, and the data aggregation tree T;Output: TSTi for every node vi

1: The nodevi initializes the value NoCi, and Leafibased on the constructed aggregation treeT.

2: Initializes the set CSi based on the tree T and theoriginal interference relation,

3: RdyCSi CSi \ fjjj is a leaf in Tg.4: TSTi 0; DONEFALSE;5: Nodevi randomly selects an integer ri. Then we say

ri; i

8/13/2019 Ttd 2011010163

6/13

7: if NoCi 0 then8: Send message READYi; ri to all nodes in CSi.9: ifri; i0. At last, we present ageneral lower bound on the delay of data aggregation for

any algorithm.

4.1 Performance of Our Algorithm

First, we show that after every time slot of Algorithm 4, for

each dominator, the number of neighboring dominateeswhose data are not collected is decreased by at least 1.

Claim 1.All the output links in Sin Step 4 of Algorithm 3 areconflict-free. In addition, after all the links transmit, for eachdominator, the number of neighboring dominatees whose data

are not collected is decreased by at least 1.

Proof.We first check the origin of these links. As shown inAlgorithm 3, each dominator u chooses a dominateerandomly from its neighbors and lets the chosendominatee transmit to u. We call all chosen dominateesas active transmitters for later references. Assume thatthere arenddominators, then we have a setLof (at most)ndchosen links. We input L to Algorithm 4 and assume

that the output is the setS

.We define a Loop Invariant for Algorithm 4 as: foreach dominator, the number of neighboring dominateeswhose data are not collected is decreased by at least 1.Initially, since each dominator u chooses a neighboringdominatee to transmit to u, the loop invariant is true.

If these links in L do not conflict with each other,Algorithm 4 will skip the execution of the while loop andoutput a set of links which are the same as the input.Clearly, the output links are conflict-free and the loopinvariant remains true.

Else, there exist interferences among links in L, thenAlgorithm 4 will execute the loop body. In each loop,

Algorithm4 adjusts a pair of conflicting links.By Lemma 2,after one round of adjustment , we solve the interferencescaused by the pair of conflicting links, and the loopinvariant remains true. Algorithm 4 repetitively adjusts apair of conflicting links when interferences exist. Observethat due to the recursive nature of our adjustmentalgorithm, we must prove that Algorithm 4 will terminatein a finite number of rounds. Clearly, when it terminates,there is no pair of conflicting links and the loop invariantremains true.

To show that Algorithm 4 terminates, we define aPotential Function for a schedule as the cardinality of

the setC fx1; x2 jx1; x2 are active transmitters andtheir corresponding links x1y1; x2y2 are conflicting linksg.We call the pair x1; x2 2 C a pair of conflictingtransmitters. Clearly, the initial cardinality of the setCis at mostndnd1=2. After one round of rescheduling,the interferences between at least one pair of conflictingtransmitters are resolved. By Lemma 3, our adjustmentwill not introduce any new pair of conflicting transmit-ters. Thus, the potential function will be decreased by atleast 1 after one round, which means that Algorithm 4will terminate after at most ndnd1

2 rounds of execution

of the while loop in Algorithm 4.Therefore, Algorithm 4 will terminate, which means

that there exists no conflict among the output links inS.In addition, the loop invariant is true after Algorithm 4terminates. Thus, claim 1 holds. tu

Lemma 2. After one round of adjustment (the loop body ofAlgorithm 4), we solve the interferences caused by the pair ofconflicting links, and the loop invariant (every dominatorsdegree will be decreased by at least 1) remains true.

Proof. We prove the claim for each of the complementarycases separately.

In Case 1 (juizjj 1 andjujzij> 1), first, we prove thatthe interferences are solved. IfDj ;, since we removeone link, the interferences are clearly solved. Else,Dj6 ;, by definition, the distance between any dom-inator in Dj andui is greater than 1, thus,juizj0 j> 1. Atthe same time,jujzij> 1, thus, the output adjusted links


8/13/2019 Ttd 2011010163

7/13

uizi; ujzj0 are conflict-free, the interferences are solved.Next, we prove that the loop invariant remains true. Allother dominators in Di are not affected by the adjust-ment, thus, we only need to prove that for thedominators in Di[Dj, the number of their neighboringdominatees whose data are not collected is decreased byat least 1. IfDj ;, we only need to for every dominatorin Di, the number of their neighboring dominateeswhose data are not collected is decreased by at least 1.This is straightforward sinceuitransmits their data. Else,Dj6 ;, since both ui; uj transmit their data, thus, forevery dominator in Di[Dj, the number of theirneighboring dominatees whose data are not collected isdecreased by at least 1. Case 2 (jujzij 1 andjuizjj> 1) issimilar to Case 1.

In Case 3 (jujzij 1 andjuizjj 1), we first prove thatthe interferences are solved. IfDj ;orDj ;, since weremove one link, the interferences are clearly solved. Else,by definition of Di; Dj,juizj0 j> 1; jujzi0 j> 1, thus, theoutput adjusted links uizi0 ; ujzj0 are conflict-free, the

interference are solved. Then we prove that the loopinvariant remains true. Similar to Case 1, we only need toprove that for the dominators in Di[Dj, the number oftheir neighboring dominatees whose data are not col-lected is decreased by at least 1. IfDi ;, we only need tofor every dominator in Dj, the number of their neighbor-ing dominatees whose data are not collected is decreasedby at least 1. This is straightforward since uj transmitstheir data. The proof is similar forDi ;. Else, bothui; ujtransmit their data, thus, for every dominator in Di[Dj,the number of their neighboring dominatees whose dataare not collected is decreased by at least 1. tu

Lemma 3.The adjustment in one round of Algorithm 4 will notintroduce any new pair of conflicting transmitters.

Proof. We prove by contradiction. Suppose after anadjustment for a pair of linksuizi; ujzj touizi0 ; ujzj0,Algorithm 4 introduces a new pair of conflictingtransmittersu; v. Since our adjustment only reconnectseither ui or uj to a new dominators while does notchange the links for other transmitters, one transmitter inu; v must be ui or uj. Assume that u is ui, and thecorresponding receiver ofv is zk. Sinceui andv conflict,either1juizkj 1 or2jvzi0 j

8/13/2019 Ttd 2011010163

8/13

ensures that every dominators data can be aggregated atthe root finally. For each level of the BFS tree, everydominatoruincluding the root of data aggregation treeTcan collect aggregated data from all dominators in D2u

within at most 16 time slots by Lemma 7. Since there isno dominator in Level 1, after at most 16R1 timeslots, every dominators data can be aggregated to theroot. The root then uses at most R time slots to transmitdata to the original sink node via the shortest path.Therefore, within 17R16 time slots, all the datacan be aggregated to the sink node. tu

Next, we provide a revised schedule that only needs15 time slots for dominators in level i (i2) to aggregatedata from some dominators within two hops, which canalso ensure that data will be aggregated to the root finally.This means that we can reduce our delay by R

2 time

slots totally.For a dominator u other than the root, we denote all

dominators within two hops ofu by B2u. Note thatB2uincludes at least one dominatorvlocated in upper level ofu.By Lemma 6, u needs at most 12 connectors to connect toB2u, we denote the set of at most 12 connectors by Cu.There must exist a connectorw2Cu, which connectsu tov. Then all dominators in B2uthat are connected tow arealso two-hop neighbors of the dominator v, we denote the setof these dominators by B02u, thus, B02u B2v. Clearly,all data inB02ucan be collected byv, it is not necessary forthem to be collected byu. So we letuonly collect the data in

B2u nB02u. It requires at most 11 connectors (all theconnectors in Cu n fwg) to connect to the dominators inB2u nB02u. S o a t mo st 1 5 (411) time slots arerequired for u to aggregate the data from B2u nB02u. Ifevery dominator u other than the root aggregates the datafrom B2u nB02u, all the data can be aggregated to the root.Theorem 9. By using Algorithm 5, the sink can receive all the

aggregated data in at most 16R14 time slots.Proof.Similar to the proof of Theorem 8, we need time slots

for dominators to aggregate data from dominatees. Afterthat, for each level of theBFS tree, every dominatoru, other

than the root of the data aggregation tree T, can collectaggregated data from all dominators in B2u nB02u in atmost 15 time slots as stated above. Thus, it costs at most15R2for data to be aggregated to the dominators in

level 2. The root rTcan collect the aggregated data fromdominators in level 2 within 16 time slots. Thus, within15R2 16 time slots, every dominators data can beaggregated to theroot. Theroot then transmitstheresultto

theoriginalsinknodein R time slots.In total,within16

R14 time slots, all the data can be aggregated to the sinknode. tu

Observe that although our analysis is based on thecentralized method, it is easy to show that all results carryto the distributed implementation (Algorithm 6). Thus, wehave the following theorem:

Theorem 10.By using Algorithm 6, the sink can receive all theaggregated data in at most 16R14 time slots.

4.2 Lower Bound of Our Algorithm

The lower bound of our algorithm is the delay for dataaggregation in the worst input case. It is an importantmeasurement to estimate the tightness of the upper boundof our algorithm derived in Section 4.1. In the followingcontext, we present a network example, and show thatwhen applying our algorithm to it, the delay can be as badas 4R3.

In Fig. 3, the root v0 (which is the topology center) hastwo children, which means that there are two symmetricbranches, each branch is symmetric with respect to thehorizontal axis. For some nodes in the left branch, we marktheir corresponding levels beside them. We use black nodesto denote dominators and white nodes to denote connec-tors. For each black node on the horizontal axis, we drawtwo cocentric circles with radii r and 2r, respectively; all itsthree neighboring connectors are located on the inner circle.We omit all leaf nodes in the figure. The original sink vs islocated in the rightmost of the right branch.

Lemma 11. When applying a centralized algorithm to theexample shown in Fig. 3, the delay is 4R3 time slots.

Proof.First, aggregating data from dominatees to domina-tors costs time slots by Lemma 4.

Second, both branches aggregate data from lower toupper levels. Between level i and leveli2as shown inFig. 3, it costs three time slots to aggregate data from theseven dominators in level i2 to three connectors in leveli1and costs another three time slots to aggregate datafrom three connectors in Level i1 to a dominator in


Fig. 3. A network example to show the lower bound of our algorithm.

8/13/2019 Ttd 2011010163

9/13

level i.Soitcosts 33 R22

time slots to gatherdata fromdominators in levelRtoward dominators in level 2. Afterthat,itcostsonetimeslottogatherdatafromdominatorsinlevel 2 to connectors in Level 1 and then two time slots tothe topology center v0. Finally, v0transmits the aggregateddata to the sink node, which will cost another R time slots.Therefore, we need 33 R2

2 12R4R

3time slots in total.

tu4.3 Overall Lower Bound

In this section, we give the overall lower bound on the delayfor data aggregation. Here, overall lower bound refers to theminimum time slots needed to finish the data aggregationby any possible algorithm.

Theorem 12. Under any interference model, the overall lowerbound of delay for data aggregation by any method ismaxfR; log ng time slots, where Ris the network radius andn is the number of nodes in the network.

Proof. The lower bound R immediately follows from the

fact that no matter what algorithm is implemented andno matter what interference model we will use, it costs atleast R time slots for the farthest node v to transmit itsdata to the sink node vs.

Next, we prove that log n is a lower bound for any

valid schedule under any interference model. Here, a

valid schedule is defined in Section 2.1, which is denoted

by a sequence of sender setsS1; S2; . . . ; Sl. Then for any

set of senders Sli, its receivers must be insidefvsg [

Si1j0Slj. Consequently, jSlij< 1

Pi1j0jSljj

since different senders in Sli must have differentreceivers. Thus, we have

jSlj 120jSl1j< 1 jSlj 221jSl2j< 1 jSlj jSl1j 422 jSlij< 1

Xi1j0

jSljj 2i jS1j 2l1:

8>>>>>>>>>>>>>>>>>>>:

Therefore, we havePl

i1jSij 2l 1. From the precon-dition for a valid schedule that[li1SiVn fvsg, we getn

1

Pli

1

jSi

j 2l

1. Therefore, l

log n, which

means that we need at least log n time slots for anyschedule. Thus, log n time slots are a general overalllower bound, which finishes the proof. tuUnder the protocol interference model when rIr, the

communicationgraphisaUDG.Usingareaargument,wecangetnOR, where is the maximum degree in UDG.Thus, maxfR; log ng maxfR; log ORg maxfR;logg. By Theorem 12,maxfR; loggis also a lower boundunder the protocol interference model when rIr. InTheorem 13, we will construct an example to show that thelower bound of both maxfR; logg and maxfR; log ng can be

(approximately) achievable.Theorem 13.Under the protocol interference model whenrIr,

there is a placement of nodes such that the delay of dataaggregation is only 2log2 log n1

2. In other words, the

overall lower bound provided in Theorem 12 is (approxi-mately) tight in this model.

Proof.We prove by construction. In Fig. 4, we construct anetwork example like a complete binary tree. There are Rlevels and level i has 2i nodes. The distance between allnodes in level R is at most r. Thus, the degrees of all

nodes in level R reach . We order all nodes in level ifrom the highest to the lowest, it means that a node withorder j is the j-highest among all nodes in level i (wenote the node byvi;j). The sink node is located on level0, which is the root of the binary tree. The distancebetween any corresponding pair of nodes located in twoconsecutive levels is r, such as the pair of vi;2j1 andvi1;j or the pair ofvi;2j and vi1;j. The distance of anyother pair of nodes located in two different levels isgreater than r, such as vi;k and vi1;j when k62j1andk62j.

We produce a valid schedule for the network example

as follows: For iR; R1; . . . ; 11. All links of vi;2j1vi1;j1j2i1 transmit

simultaneously.2. All links of vi;2jvi1;j1j2i1 transmit

simultaneously.

From the schedule, we can see that we only need twotime slots to aggregate data from level i to leveli1.This implies that totally we need 2R time slots toaggregate data from all nodes to the sink. SinceRloglogn1=2, this finishes the proof. tuNow we provide the overall lower bound under the

protocol interference model when r < rI

8/13/2019 Ttd 2011010163

10/13

Whenr < rI

8/13/2019 Ttd 2011010163

11/13

6.2 Evaluating the Average Performances

Now we compare the average performances of threealgorithms (Algorithm 6, Yu et al. [3], and Huang et al.

[11]). We randomly deploy nodes (representing sensors)

into a region of200 m200 m. All nodes have the sametransmission radius.

In Fig. 6a, the transmission radius of each sensor is fixed

to 25 m. The figure shows the delay for aggregating data

from all nodes to the sink by running three algorithms

while the number of deployed nodes increases.Fig. 6b compares the latencies for aggregating data using

three algorithms when the maximum node degree varies.

Here, the maximum node degree is fixed to 25. It can be

seen in the figure that our algorithm (nearly the same withYu et al.s) outperforms Huang et al.s algorithm with much

lower latencies.

6.3 Evaluations on TOSSIM of TinyOS 2.0.2

We implemented IAS on TOSSIM of TinyOS 2.0.2. Werandomly deploy a number of sensor nodes in a two-dimensional square region, all nodes have the sametransmission range. Each node will generate a random 16-bit nonnegative number as its own datum. The objective of

the sink node is to report the aggregation result of all data(totallyn data, n is the network size) correctly.

In order to evaluate the efficiency of IAS, we alsoimplemented another data aggregation algorithm by com-bining BFS tree and Collection Tree Protocol (CTP, which isprovided by TinyOS 2.0.2) using TOSSIM. We call thismethod BFS+CTP method for simplicity. The main idea ofBFS+CTP method is to construct a BFS tree rooted at thesink node based on the link quality. In other words, duringthe procedure of constructing BFS, the link qualitycomputed by CTP will be considered as the link weight.Note that the original CTP method (components) providedin TinyOS 2.0.2 is used to collect data to the sink node. To

enable CTP to support data aggregation rather than tocollect all data to the sink, we modified CTP in the upperlayer such that each node will not send data to its parent (onthe BFS tree) until it aggregates all necessary data from allchildren (on the BFS tree).

We tested and compared the latencies for IAS methodand BFS+CTP method in two different cases. For the firstcase, we randomly generated the network topology (con-nected) with different network size (increasing from 30 to210 with step 30) while ensuring the network densityunchanged, i.e., the network deployment area increaseswith the increment of the network size. Actually, by doing

this, we fixed the maximum degree (in our simulation, is around 22) for each case; thus, the radius of communica-tion graph increases with the increment of network size.The delay performance of two methods, IAS and BFS+CTP,is illustrated in Fig. 7a. Note that here the definition of delayis the time duration from the time the first datum istransmitted heading for the sink node to the time the sinknode reports the result finally. From Fig. 7a, we can see thatwhen the network density is not big, the delay differencebetween two methods is not so big. In most cases, our IASmethod has better performance than that of BFS+CTP. Theradius R for each case is indicated by the value in the

brackets right after the network size on x-coordinate.For the second case, we fix the deployment area as

(300300) and continue to increase the network size from50 to 200 with step 30 while keeping the network connected.


Fig. 5. Comparisons of worst-case performances for two methods.

(a) Fixed R. (b) Fixed .

Fig. 6. Comparisons of average performances for three methods.

(a) Fixed R. (b) Fixed .

Fig. 7. Simulation results for our algorithm and BFS+CTP. (a) Fixed R.

(b) Fixed.

8/13/2019 Ttd 2011010163

12/13

By doing this, we can fix the radius R and test theperformance of both algorithms with the increment ofnetwork density (maximum degree ).

As we can see in Fig. 7b, there is a big gap between thesetwo methods when the density (maximum degree )continues increasing. This is because the interference willbe greatly decreased after IAS gathers all data to dominators.Hence, the total delay decreases significantly. However, forBFS+CTP method, thenumber of relay nodes will continue toincrease with the increment of network size such that thedelay increases greatly due to the interference. From thesimulation results, we can see that in most cases, IAS hasbetter performance than BFS+CTP method. Especially, thedenser the network is, themore efficient our IAS algorithmis.

7 RELATEDWORK

Data aggregation in sensor networks has been well studiedrecently [2], [12], [15], [25]. In-network aggregation meanscomputing and transmitting partially aggregated data

rather than transmitting raw data in networks, thus,reducing the energy consumption [16].

There are a lot of existing researches on in-networkaggregation in the literature [6], [17]. Suppression schemeand model-driven methods were proposed in [5], [7]toward reducing communication cost. The trade-off be-tween energy consumption and time delay was consideredin [25]. A heuristic algorithm for both broadcast and dataaggregation was designed in [1]. Another heuristic algo-rithm for data aggregation was proposed [18], aiming atreducing time delay and energy consumption. Kesselmanand Kowalski [13] proposed a randomized and distributed

algorithm for aggregation in WSNs with an expected delayofOlog n. Their method is based on two assumptions: Oneis that sensor nodes can adjust their transmission rangewithout any limitation. The other is that each sensor nodehas the capability of detecting whether a collision occursafter transmitting data. Both assumptions pose somechallenges for hardware design and are impractical whenthe network scales. A collision-free scheduling method fordata collection is proposed in [14], aiming at optimizingenergy consumption and reliability. All these works did notdiscuss the minimal delay aggregation scheduling problem.

In addition, the minimum delay of data aggregationproblem was proved NP-hard and a

1

-approximation

algorithm was proposed in [4], where is the maximumdegree of the network graph. Another aggregation schedul-ing algorithm was proposed in [11], which has a delay boundof23R18, whereRis the network radius and is themaximum degree. Recently, Wan et al. [21] proposed threenovel centralized data aggregation methods for networkswhen nodes have the same transmission radius andinterference radius, which achieve schedules of latency15R4, 2ROlog R , and 1Olog Rffiffiffi

R3p R,

respectively. Recently, Xu et al. [24] studied aggregationwith multiple queries in WSNs. All the algorithms men-tioned above are centralized. In many cases, centralized

algorithms are not practical, especially when the networktopology changes often in a large sensor network.

The distributed algorithms for convergecast schedulingwere proposed in [3], [8], [13]. [8], [13] focused on the

scheduling problem for data collection in sensor networks.In data collection, since data cannot be merged, the sinkmust receive Npackets from all the nodes, where N is thenumber of sensor nodes in the network. Thus, the lowerbound of delay isN. The upper bound of the time delay ofthis algorithm ismax3nk1; N, wherenkis the number ofnodes in the largest one-hop subtree. Bo Yu and Li [3]

proposed a distributed scheduling algorithm generatingcollision-free schedules that has a delay bound of24D616, whereD is the network diameter.

8 CONCLUSIONS

Data aggregation is critical to the network performance inWSNs and aggregation scheduling is a feasible way ofimproving the quality. In this paper, we study the problemof distributed aggregation scheduling in WSNs andpropose a distributed scheduling method with an upperbound on delay of16R14time slots. This is a nearlyconstant approximate algorithm, which significantly re-duces the aggregation delay. The theoretical analysis andthe simulation results show that our method outperformsthe previous methods.

In addition, we provide the overall lower bound ondelay for data aggregation under any interference modelwith formal proofs and give an example to show that thelower bound is (approximately) tight under the protocolinterference model whenrIr, whereris the transmissionrange and rI is the interference range. We also derive thelower bound on delay under the protocol interferencemodel whenr < rI

8/13/2019 Ttd 2011010163

13/13

[7] A. Deshpande, C. Guestrin, W. Hong, and S. Madden, ExploitingCorrelated Attributes in Acquisitional Query Processing, Proc.Intl Conf. Data Eng. (ICDE),2005.

[8] S. Gandham, Y. Zhang, and Q. Huang, Distributed Minimal TimeConvergecast Scheduling in Wireless Sensor Networks, Proc.IEEE Intl Conf. Distributed Computing Systems (ICDCS), 2006.

[9] P. Gupta and P.R. Kumar, The Capacity of Wireless Networks,Proc. IEEE Trans. Information Theory, vol. 46, no. 2, pp. 388-404,Mar. 2000.

[10] G. Wegner, Uber Endliche Kreispackungen in Der Ebene,Studia

Scientiarium Mathematicarium Hungarica, vol. 21, pp. 1-28, 1986.[11] S. Huang, P. Wan, C. Vu, Y. Li, and F. Yao, Nearly Constant

Approximation for Data Aggregation Scheduling in WirelessSensor Networks,Proc. IEEE INFOCOM,pp. 366-372, 2007.

[12] C. Intanagonwiwat, D. Estrin, R. Govindan, and J. Heidemann,Impact of Network Density on Data Aggregation in WirelessSensor Networks, Proc. IEEE Intl Conf. Distributed ComputingSystems (ICDCS), vol. 22, pp. 457-458, 2002.

[13] A. Kesselman and D. Kowalski, Fast Distributed Algorithm forConvergecast in Ad Hoc Geometric Radio Networks, J. Paralleland Distributed Computing, vol. 66, no. 4, pp. 578-585, 2006.

[14] H. Lee and A. Keshavarzian, Towards Energy-Optimal andReliable Data Collection via Collision-Free Scheduling in WirelessSensor Networks,Proc. IEEE INFOCOM,pp. 2029-2037, 2008.

[15] S. Madden, M. Franklin, J. Hellerstein, and W. Hong, TAG: ATiny AGgregation Service for Ad-Hoc Sensor Networks, Proc.

USENIX Symp. Operating Systems Design and Implementation, 2002.[16] M. Sharaf, J. Beaver, A. Labrinidis, and P. Chrysanthis, TiNA: A

Scheme for Temporal Coherency-Aware In-Network Aggrega-tion, Proc. Third ACM Intl Workshop Data Eng. for Wireless and

Mobile Access, pp. 69-76, 2003.[17] N. Shrivastava, C. Buragohain, D. Agrawal, and S. Suri, Medians

and Beyond: New Aggregation Techniques for Sensor Networks,Proc. ACM Conf. Embedded Networked Sensor Systems (SenSys),pp. 239-249, 2004.

[18] S. Upadhyayula, V. Annamalai, and S. Gupta, A Low-Latencyand Energy-Efficient Algorithm for Convergecast in WirelessSensor Networks, Proc. IEEE Global Comm. Conf. (GlobeCom),vol. 6, 2003.

[19] P.-J. Wan, K. Alzoubi, and O. Frieder, Distributed Constructionof Connected Dominating Set in Wireless Ad Hoc Networks,

Mobile Networks and Applications,vol. 9, pp. 141-149, 2004.[20] P.J. Wan, C.W. Yi, X. Jia, and D. Kim, Approximation Algorithms

for Conflict-Free Channel Assignment in Wireless Ad HocNetworks, Wiley Wireless Comm. and Mobile Computing, vol. 6,pp. 201-211, 2006.

[21] P.J. Wan, S.C.-H. Huang, L.X. Wang, Z.Y. Wan, and X.H. Jia,Minimum-Latency Aggregation Scheduling in Multihop Wire-less Networks,Proc. ACM MobiHoc, pp. 185-194, 2009.

[22] W. Wang, Y. Wang, X.Y. Li, W.Z. Song, and O. Frieder, EfficientInterference-Aware TDMA Link Scheduling for Static WirelessNetworks, Proc. ACM MobiCom, pp. 262-273, 2006.

[23] X.-H. Xu, S.-G. Wang, X.-F. Mao, S.-J. Tang, and X.-Y. Li, AnImproved Approximation Algorithm for Data Aggregation inMulti-Hop Wireless Sensor Networks, Proc. ACM MobiHocFOWANC Workshop, 2009.

[24] X.-H. Xu, S.-G. Wang, X.-F. Mao, S.-J. Tang, P. Xu, and X.-Y. Li,

Efficient Data Aggregation in Multi-Hop WSNs, Proc. IEEEGlobal Comm. Conf. (GlobeCom), 2009.[25] Y. Yu, B. Krishnamachari, and V. Prasanna, Energy-Latency

Tradeoffs for Data Gathering in Wireless Sensor Networks, Proc.IEEE INFOCOM, vol. 1, 2004.

Xiaohua Xu received the BS degree fromChuKochen Honors College at Zhejiang Uni-versity, P.R. China, in 2007. He is currentlyworking toward the PhD degree in computerscience at Illinois Institute of Technology. Hisresearch interests include algorithm design andanalysis, optimization in mesh network, andenergy efficiency and security in wireless net-work. He is a student member of the IEEE.

Xiang-Yang Li received the BEng degree incomputer science and the bachelors degree inbusiness management from Tsinghua Univer-sity, P.R. China, in 1995, and the MS and PhDdegrees in computer science from the Universityof Illinois at Urbana-Champaign in 2000 and2001, respectively. He has been an associateprofessor since 2006 and assistant professor ofcomputer science at Illinois Institute of Technol-ogy from 2000 to 2006. He was a visiting

professor at Microsoft Research Asia from May 2007 to August 2008.His research interests include wireless ad hoc and sensor networks,noncooperative computing, computational geometry, and algorithms. Hewas a guest editor of special issues for the ACM Mobile Networks and

Applications, the IEEE Journal on Selected Areas in Communications,and editor of the Networksjournal. He is a member of the ACM and asenior member of the IEEE.

Xufei Mao received the BS degree fromShenyang University of Technology, China, in1999, and the MS degree from NortheasternUniversity, China, in 2003. He is currentlyworking toward the PhD degree in computerscience at Illinois Institute of Technology. Hisresearch interests include design and analysis ofalgorithms concerning wireless networks, net-work security, etc. Topics include navigationproblem in sensor network, Top-k query, capa-

city (throughput) study, channel assignment, link scheduling and TinyOSprogramming, etc. He is a student member of the IEEE.

Shaojie Tangreceived the BS degree in radioengineering from Southeast University, P.R.China, in 2006. He is currently working towardthe PhD degree in computer science at IllinoisInstitute of Technology. His current researchinterests include algorithm design and analysisfor wireless ad hoc network and online socialnetwork. He is a student member of the IEEE.

Shiguang Wang received the BS degree fromNanjing University, P.R. China, in 2008. He iscurrently working toward the PhD degree incomputer science at Illinois Institute of Technol-ogy. His research interests include algorithmand system design for wireless ad hoc andsensor networks, game theoretical study ofnetworks, and RFID system. He is a studentmember of the IEEE.

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


Ttd 2011010163

Documents

Transcript of Ttd 2011010163