A Novel Crash-Tolerant Data Gathering in WirelessSensor Networks

Suchetana Chakraborty, Sandip Chakraborty, Sukumar Nandi, Sushanta KarmakarDepartment of Computer Science and Engineering

Indian Institute of Technology Guwahati, Assam 781039, IndiaEmail: {suchetana, c.sandip, sukumar, sushantak}@iitg.ernet.in

Abstract—Event driven data gathering or convergecast throughsensor nodes requires efficient and correct delivery of data atthe sink. A tree rooted at the sink is an ideal topology fordata gathering which utilizes sensor resources properly. Resourceconstrained sensor nodes are highly prone to sudden crash. A setof algorithms, proposed in this paper, builds a data gathering treerooted at the sink. The tree eventually becomes a Breadth FirstSearch(BFS) tree where each node maintains the shortest distancein hop-count to the root to reduce the routing delay and powerconsumption. The data gathering tree is repaired locally within aconstant round of message transmissions after any random nodefails. Simulation result shows that the repairing delay is very lessin average, and the proposed scheme can repair from arbitrarynode failure using constant number of message passing.

I. INTRODUCTION

Sensors with various applicabilities are useful for accessingcritical resources, environment monitoring, battlefield surveil-lance, industrial automation and process control, health andtraffic monitoring and so on [1]. Being a micro electronicdevice sensor nodes are limited with power supply and thussaving the non-renewable battery life through efficient powermanagement is one of the most critical research issues inthis field. Communication through radio channels demandsmore power consumption compared to local computation andsensing. Hence reduction in control message transmissionswould help in saving the battery power and thus improvingthe sensor life.

Quality of Service(QoS) is another important performancemetric which should be offered with assurance for some ofthe applications. Data gathering or convergecast is one suchapplication in which data are accumulated at the sink withoutloss or redundancy. The sink based data gathering is one of themost challenging fields of Wireless Sensor Networks(WSN)that has drawn much research interests in recent days. Lindseyet al. [2] have investigated the energy-delay metric for datagathering and proposed a near-optimal solution to increase thenetwork life through power savings. Yu et al. [3] have alsostudied the energy-latency trade-off for data aggregation. Fora given aggregation tree the proposed algorithm reduces thetotal power consumption under latency constraints.

This work is supported by Microsoft Research India Travel Grant

Topology of the sensor networks playing an effective role,can be modeled like a spanning tree rooted at the sink asrouting through a spanning tree offers minimum duplicatedelivery and also assures ordered delivery. Upadhyaula etal. [4] proposed a heuristic solution to minimize both theenergy dissipation and data latency for convergecast as wellas broadcast. Lu et al. [5] have proposed an energy-efficientscheme for data gathering for large scale system. A Breadth-First Search (BFS) tree is constructed level by level suchthat leaf nodes are more than intermediate nodes and thuspower is saved by turning off the radio of leaf nodes aswell as minimizing the distance to the root. Annamalai et al.[6] have proposed a heuristic algorithm for tree constructionand channel allocation for both broadcast and convergecastin multi-hop radio network. Li et al. [7] have analyzed thecomplexity of data collection in terms of message transmis-sion, power consumption and delay for WSN. They claimedthat the total number of packet relays as well as the delaywill be minimum if forwarded through a BFS tree. In anotherpaper [8], the authors proved that data collection using aBFS tree offers maximum collection capacity. So using aBFS tree would be a good option for data gathering as thehop-count distance between the sink and each sensor node inthe network is minimum for a BFS tree [9]. However, theconstruction of BFS tree in distributed environment usuallyinvolves explosion of control messages due to flooding thatincurs significant overhead of communication cost. So thestudy of efficient distributed BFS tree construction is also aninterest of current research [10], [11]. All the above mentionedworks on convergecast that try to gain low latency and thereduced energy dissipation at sensor nodes are suitable forparticularly stable and static network which is ideal.

A sudden crash of an arbitrary sensor node may lead to theproblem of incorrect tree structure. There are few works whichtried to offer robustness and reliability for the fault tolerantdistributed system that deals with spanning trees [12], [13].Fei et al. [14] have proposed a proactive approach for treerecovery. England et al. [15] have also studied the robustnessof a spanning tree used for data collection or dissemination inWSN. They proposed a centralized as well as an distributedalgorithm to construct the topology that can withstand faultsand also takes power consumption and data loss into account.978-1-4673-0269-2/12/$31.00 c© 2012 IEEE

940

In this paper, a novel scheme has been proposed thatconstructs a tree rooted at the sink which gradually becomesa BFS tree through restrained improvement of level at eachnode. Although several works exist to construct a BFS treein distributed way, a new approach has been introduced asduring the tree construction phase each node performs a localcomputation based on prior neighborhood information. A localpre-computation for alternate parent selection helps in findingout an alternate path to the root for quick emergency repairingafter a parent node fails. The local tree repairing scheme isfast and requires only a few control message exchange whichsaves critical battery power of sensor nodes. The proposedscheme supports arbitrary node failure at different locality ofthe network. Simulation results verify that the convergecastmessage loss or redundant delivery due to arbitrary node crashis assured to be minimized, and the repairing delay is foundto be less.

II. CRASH-TOLERANT DATA GATHERING SCHEME

In this work, a set of algorithms has been proposed thatconstructs a spanning tree rooted at the sink such that eventu-ally it becomes a BFS tree maintaining the property of shortestdistance from any node to the root. When a node fails, eachnode in its neighborhood takes immediate decision based onprecomputed plan to repair the tree locally.

A. System Model

Let there be n number of sensor nodes scattered randomlyin the environment to be monitored. The arbitrary distributionof sensors can be represented by the communication graphG(V, E) where V denotes the set of nodes and E be the setof edges between communicating nodes. There exists a specialsink node in which all the data are accumulated. Also thereexists a sufficiently large FIFO buffer at each node to holdthe incoming data. The mode of communication is assumedto be asynchronous and the channel be reliable and FIFO. Thenetwork is assumed to be static and hence links are reliablebut a node may crash suddenly or leave the system becauseof power exhaustion randomly. Furthermore it is assumed thatno simultaneous multiple node crash can occur in the samelocality and no node fails during the initial construction ofthe data gathering tree. These assumptions does not violatethe generosity of sensor network, as the probability of nodefailure at initial setup of the network, as well as the probabilityof simultaneous node failure at same locality is very lowin general. Tbale I shows the system variables used in thealgorithms.

B. Initialization : A Distributed Tree Construction

The initial tree construction and incremental level updatingprocedure have been described pictorially in figure 1 tofigure 4 where each circle represents a sensor node, shadedcircle being the sink. Each arrow represents the tree edgewhere as each dashed line between any two nodes representsthe presence of communication link. Initially the sink node astarts tree construction by forwarding TOKEN(0, Null) to all

Algorithm 1 On receiving TOKEN(mLevel, pid) from v by u

1. grandParent[v] ← pid2. altParentLevel[v] ← mLevel3. if visited = False ∧ timer = False then4. visited ← True /*Received TOKEN for the first time*/

5. minDist ← mLevel + 16. Call bfsParentSelect(v)7. for all w ∈ N(u) \ {p(u)} do8. Send TOKEN(level, p(u)) to w9. end for

10. else11. if mLevel + 1 < minDist then12. minDist ← mLevel + 1 /*minDist is improved level*/

13. altp ← v /*altp is impoved parent*/

14. if timer = False then15. timer ← True /*Reset timer to hold level update*/

16. end if17. end if18. end if

its neighbors as in Fig. 1. Upon receiving TOKEN(mLevel, pid)for the first time from a node v, each node u selects v as itsparent, sets its level = mLevel + 1; updates minDist(whichholds the shortest hop-count to the root node) and sets itsvisited to True. Figure 2 depicts that nodes receive TOKENmessage and assign their levels correctly. On receiving furtherTOKEN, if minDist gets improved then a timer is set forfurther improvement of minDist. Thus the node is refrainedfrom immediate parent update and a significant amount ofmessage explosion can be avoided as a consequence. Oncetimer goes out, the T imeOut procedure as in Algorithm 6is called to change its parent by selecting the node havingminimum level in neighborhood. In Fig. 3, node c calls theprocedure T imeOut after receiving a TOKEN from the rootnode and thus improving its minDist. Then the updatedlevel is advertised through TOKEN messages forwarded toall neighbors except the parent. Node g and node j updatetheir respective levels on timeout. In this way a BFS tree isconstructed as in Fig. 4 where each node eventually selectsthe correct parent having the shortest hop-count to the rootnode.

Algorithm 2 Procedure bfsParentSelect(w) called by u

1. if p(u) �= w then2. halt ← True /*Parent switching holds to clear data from Buffer*/

3. Call switchParent(w)4. else5. Send ADD to p(u)6. end if

C. Contingency Plan for Single Node Crash

Each node u calls the pullInfo procedure to pre-computeits alternate path to the root after all its neighbors have reacheda stable state by selecting the correct parent. Whenever a

2012 IEEE Network Operations and Management Symposium (NOMS): Mini-Conference 941

TABLE ISTATE VARIABLES AT EACH NODE u

Variable Name Type Initial Value Meaning

visited Boolean False True if u selects its parent after receiving first TOKENtimer Boolean False True on start up of the system Timerblock Boolean False When True, stops forwarding data from Bufferhalt Boolean False Controls the flow of application message in Bufferpower Boolean False True if Neighbor(u) − {Child(u) ∪ Sibling(u) ∪ p(u)} �= φp(u) Integer Parent of ulevel Integer Level of u at the BFS treeminDist Integer The shortest distance in hop-count from the rootpowerParent Integer Null The node with minimum level in neighborhood for which power = TrueboostParent Integer Null a node w in neighborhood whose power = TruealtParentLevel[v] Integer ∞ v=level of w, ∀w ∈ Neighbor(u)toServe Integer Null ID of the node to which ReqParentACK has to be sentgrandParent[v] Integer Null v = p(w)∀w ∈ Neighbor(u)bpLevel Integer ∞ Temporary level required to find the node with minimum level for the selection of boostParentSibling(v) Set Null IDs of those w ∈ Neighbor(v) : p(w) = p(v)N(u) Set ID of the nodes directly connected to uChild(u) Set Children of u

a

d

h

j

g

c

i

f

b

e

Fig. 1. Initial graph G

0a

d

1

2

h

j

g

c

i

f

2

b

1

2

e

Fig. 2. a, b, d, e, f, h assignlevel correctly

0a

d

1

2

h

j

g

c

i

f

2

b

1

2

e

3

3

4

Fig. 3. c and g selects wrongparent; j selects right parentwith incorrect level

01

2

3

2

1

1

22

3

a

b

ef

g

c

d

h

j

i

Fig. 4. Final tree: all the nodesselect correct parent

Algorithm 3 Procedure switchParent(w) called by u

1. while halt=True do2. Wait /*Application Message Controller(AMC) will set halt to False

eventually breaking the loop*/

3. end while4. block ← True /*Suspends application data flow in Buffer*/

5. Send REMOVE to p(u)6. p(u) ← w7. level ← mLevel + 18. Send ADD to p(u)9. block ← False /*Resumes application data flow in Buffer*/

Algorithm 4 On receiving ADD from v by u

1. if v �∈ Child(u) then2. Child(u) ← Child(u) ∪ v3. end if

Algorithm 5 On receiving REMOVE from v by u

1. halt ← True /*Parent switching holds to clear data from Buffer*/

2. while halt = True do3. Wait /*AMC will set halt to False eventually breaking the loop*/

4. end while5. Child(u) ← Child(u) \ {v}

Algorithm 6 Procedure T imeOut called by u

1. Call switchParent(altp)2. Send TOKEN(level, p(u)) to w : ∀w ∈ N(u) \ {p(u)}3. timer ← False

change occurs in neighborhood topology, a node recomputesits alternate parent by calling pullInfo procedure. First eachnode calculates its Sibling set which includes all the nodes inneighborhood, whose parents are same with that of p(u) as inAlgorithm 7. A node u is called Power node if there exists atleast one node w ∈ N(u) such that the edge between u andw in the graph G is a cross edge and also w /∈ Sibling(u).Then w is called powerParent of u. u sets power variable toTrue and forwards a Booster(level) message to all neighborsexcept the powerParent. If more than one such w existsthen one with minimum level becomes the powerParent.All remaining nodes in G whose power = False and hasreceived such Booster message are called Booster nodes.If a node u receives Booster message from more than onenodes, then one among them with minimum level becomesboostParent(u). The following Theorems and Lemmas aregiven as a justification for the successful completion of thetree construction, correctness of the all tree properties and theestimation of message complexity. However, thee detail proofsare not reported in this paper due to space constraints.

Lemma 1. Each node in G receives TOKEN message at least

942 2012 IEEE Network Operations and Management Symposium (NOMS): Mini-Conference

Algorithm 7 Procedure pullInfo called by u

1. Sibling ← Sibling∪v, ∀v ∈ N(u) : grandParent[v] =p(u)

2. if ∃w ∈ {N(u) \ {Sibling(u)∪Child(u)∪ p(u)}} then3. power ← True4. powerParent ← x : altParentLevel[x] =

min{altParentLevel[w]}5. Send Booster(altParentLevel[w]+1) to N(u)\{x}6. end if

Algorithm 8 On receiving Booster(mLevel) from v by u

1. if power = False∧v �= p(u)∧mLevel < bpLevel then2. boostParent ← v3. bpLevel ← mLevel4. Send Booster(bpLevel+1) to N(u)\{boostParent}5. end if

once.

Theorem 1. The algorithm for tree construction terminateseventually.

Lemma 2. Let u be a Booster node and w be itsboostParent; Then either w ∈ Child(u) is true or p(w) =p(u) is true.

Lemma 3. Let there be a path in the tree P = {x1, x2, ..., xn}such that x1 = p(x2), x2 = p(x3), ..., xn−1 = p(xn). Hence�e ∈ ET where ET is the set of tree edges, EN is the set ofnon-tree edges and ET ∪EN = E; such that if e = {xn, x1},then xn �= p(x1).

Lemma 4. Let h(u) denotes the height of the node u fromthe root. So ∀u ∈ V , h(u) = min{p1, p2, ..., pn} where{p1, p2, ..., pn} is the set of all possible paths from the root tothe node u.

Theorem 2. The algorithm produces a correct BFS tree fordata gathering rooted at the sink node.

Theorem 3. The worst case message complexity for treeconstruction is O(|E|).

D. Handling a Single Node Crash

When a node x fails, lower layer at each node u in theneighborhood is assumed to detect that and inform it to theoverlay crash handler through the DetectCrash(x) signal. Thenu performs necessary actions according to Algorithm 9 torepair the tree locally as per the contingency plan computedearlier. Fig. 5 - Fig. 7 give the pictorial description of anarbitrary node crash repairing mechanism. To reset the parentvariable after the parent fails, a node only need to exchangea pair of messages (ReqParent and ReqParentACK) with itspre-computed alternate parent. The UpdateLevel message isrequired to maintain the BFS properties at every node evenafter the repairing is over. The correctness of the algorithmsto repair the tree from a node crash as well as the computation

Algorithm 9 On receiving DetectCrash(ID) by u from thelower layer on detecting a node failure in neighborhood

1. Neighbor(u) ← Neighbor(u) \ {ID}2. if ID ∈ Child(u) then3. halt ← True /*Switching holds to clear data from Buffer*/

4. while halt = True do5. Wait for AMC to return/*Application Message Controller

will set halt to False eventually breaking the loop*/

6. end while7. Child(u) ← Child(u) \ {ID}8. else if ID = p(u) then9. block ← True

10. Send holdFlow to v ∈ Child(u)11. p(u) ← φ12. if power = True then13. Send ReqParent to powerParent14. else15. Send ReqParent to boostParent16. end if17. end if

Algorithm 10 On receiving ReqParent from v by u

1. if v = p(u) then2. p(u) ← φ3. end if4. if p(u) �= φ then5. Send ReqParentACK(level) to v6. Child(u) ← Child(u) ∪ v7. else8. toServe ← v9. if power = True then

10. Send ReqParent to powerParent11. else12. Send ReqParent to boostParent13. end if14. end if

Algorithm 11 On receiving ReqParentACK(mLevel) from vby u

1. p(u) ← v2. level ← mLevel + 13. minDist ← level4. block ← False5. if toServe �= NULL then6. Send ReqParentACK(level) to toServe7. Child(u) ← Child(u) ∪ toServe8. end if9. Send UpdateLevel(level) to Child(u)

2012 IEEE Network Operations and Management Symposium (NOMS): Mini-Conference 943

01

2

3

2

1

1

22

3

a

b

ef

g

c

d

h

j

i

Fig. 5. Node c fails. Node a, f and g detectand update neighbor/child accordingly

0

1

22

1

2

a

b d

ef

g

h

ji

3

44

Fig. 6. Node g sends ReqParent to itspowerParent, node f. On receiving Req-ParentACK, node g sends UpdateLevel to itschildren node i and j

0

1

22

1

2

a

b d

ef

g

h

ji

3

43

Fig. 7. Node j changes parentfrom node g to node h due tolevel improvement. Final treeafter repairing

cost of repairing can be established by the following Lemmasand Theorems. However, the detail proofs are not reported inthis paper due to space constraints.

Algorithm 12 On receiving UpdateLevel(mLevel) from v byu

1. level ← mLevel + 12. if ∃w ∈ N(u) : altParentLevel[w] < level then3. Call switchParent(w)4. end if5. minDist ← level6. Send UpdateLevel(level) to Child(u)7. if block = True then8. block ← False9. end if

Theorem 4. Let Up be a set of nodes such that ∀u ∈Up, power = True; and Ub be another set of nodes such that∀u ∈ Ub, power = false. Then Up∪Ub = V and Up∩Ub = φare always true.

Theorem 5. Let there exists a path P = {x1, x2, ..., xn} in thetree such that x1 = p(x2), x2 = p(x3), ..., xn−1 = p(xn). Ifx1 fails, �w ∈ S where S = {x3, x4, ..., xn} such that eitherpower = True at w or there must be at least one node y ∈ Ssuch that either power = True at y or boostParent(y) /∈ S;where w = p(x2) after repairing.

Lemma 5. For a set of nodes S = {x1, x2, ..., xn} with acommon parent w there must be at least one node u ∈ S suchthat power = True at u.

Lemma 6. Each node resets its parent by exchanging a pairof messages (ReqParent and ReqParentACK) with its alternateparent.

Theorem 6. Any arbitrary single node fault can be repairedwithin constant round of message transmission.

Theorem 7. If a parent node fails, during the repair time anynumber of further node, except the alternate parent, failure istolerated and repaired locally.

E. Application Message Controller

Each data packet received is enqueued in a local Buffer. Theflow of application data to and from the Buffer is controlled by

the Application Message Controller(AMC) as in Algorithm 13.During the parent change no redundant data is generated or nodata is lost which is handled by the AMC and two Booleanvariables, block and halt. The data buffered at the crashednode x can not be recovered. However, data packets that areyet to be forwarded to x and buffered at all the children of xare rerouted to the sink after parents are reassigned correctly.At the time of tree repairing each node u for which p(u)became Null, forwards a holdFlow message to its children.This suspends outgoing data flow by setting block = True ateach child of u. The holdFlow messages are forwarded towardsthe leaves through the paths of the subtree rooted at x until aPower node is found. Thus the upward application data flowis suspended at each node in those paths. This reduces theoverhead of redundant path traversal for application data dueto node crash. On receiving UpdateLevel, block becomes false,and data transfer starts again.

Algorithm 13 Application Message Controller: On receivingApplication message M

1. Put M in Buffer2. if halt = True then3. Insert # in Buffer4. end if5. while Buffer �= Full∧ block = False∧ ∗Buffer �= #

do6. Send *Buffer to p(u)7. end while8. if *Buffer = # then9. Adjust Buffer index

10. halt ← False11. end if

III. SIMULATION RESULT

The proposed tree repairing scheme for convergecast hasbeen simulated through the Network Simulator [16]. SMACis considered for MAC layer protocol with 100Mbps data rate.Sensor nodes are deployed randomly in a 1000× 1000 arena.The simulation can be done for any number of nodes organizedin a random topology; however to analyze the behavior ofthe proposed scheme under extreme conditions, two differentscenarios have been considered, one for a ring topology andother for a chain topology. In the worst case scenario, with

944 2012 IEEE Network Operations and Management Symposium (NOMS): Mini-Conference

1

2

3

4

5

6

7 8

9

10

11

12

13

Fig. 8. BFS tree for a ring

2

4

1

3

5

6

7

8

Fig. 9. BFS tree for a chain

a ring topology only the two extreme leaf nodes are Powernodes; remaining are Booster nodes. Thus for a single nodefailure, a series of nodes become victim as their parentsbecome invalid. The repairing involves more number of nodeswith increased repair time and message exchange. The bestcase scenario is when the subtree rooted at node u, where u isa Power node, form a chain structure after p(u) fails. Thenu sets new parent in constant time. Also its descendants donot need to change parent if the level of u remains same. Therepairing cost that has to bear by all these nodes is only theblocking time in forwarding convergecast messages.

A. Case I : For a ring topology

Figure 8 shows a BFS tree for a ring topology of 13 nodeswhere node 1 is the sink and thus the root of the tree. Node7 and node 8 are the leaf nodes for the initial data gatheringtree. All application data are accumulated at the sink node 1.Now let node 2 suddenly fails. So parent variable for node3 becomes invalid. Likewise, parents for all the nodes in aseries from node 4 to node 7 become invalid as all of themare descendants of node 3 and are Booster nodes. Each nodefixes its parent through exchanging a pair of messages withits alternate parent according to Lemma 6. The repairing time,denoted by Δ, at each node for the series of victim nodes havebeen given in Table II. Δ is the difference between Start-time(when block = True after receiving holdFlow) and End-time(when block = False, after receiving UpdateLevel). It canbe noted that Δ decreases as we proceed from the originalvictim, node 3, towards the leaf node. The tree is repairedas the nodes exchange control messages with their respectivealternate parents at next higher level, starting from node 3 atlevel 2 and ending at node 7 at level 6. So the total numberof control message exchange for repairing is 18, which alsosatisfies the theoretical proposition in Theorem 6. It has beenobserved from the analysis of the simulation trace, that onlyone message is lost as hold by the parent of node 3 whenit fails. Remaining messages are delivered to the sink withoutany loss or redundancy. However, depending on the applicationdata rate some messages might be delivered to the sink out oforder as a series of nodes reverse the parent-child relationshipin this scenario.

TABLE IIREPAIRING TIME(IN SEC) FOR THE VICTIM NODES IN A RING TOPOLOGY

Node Id Start-time End-time Δ

3 250.0435 250.3566 0.31314 250.0537 250.3285 0.27585 250.0773 250.2944 0.21716 250.1130 250.2727 0.10977 250.1346 250.2409 0.1063

TABLE IIIREPAIRING TIME (IN SEC) FOR THE VICTIM NODES IN A CHAIN TOPOLOGY

Node Id Start-time End-time Δ

4 250.026 250.045 0.0195 250.035 250.052 0.0176 250.043 250.060 0.0177 250.047 250.067 0.0208 250.054 250.074 0.020

B. Case II : For a chain topology

Figure 9 shows the BFS tree for a chain topology of 8 nodes.Let node 3 fails. This is the simplest case as node 4 is a Powernode and it sets its parent to node 2, after node 3 fails, throughonly a pair of message exchange from Lemma 6. Each of thenodes from node 5 to node 8 does not change parent; neitherdue to parent invalidation nor due to level improvement. Eachof them receives one holdFlow message and one UpdateLevelmessage. So in total 10 control messages are exchanged torepair the tree which also validates the theoretical propositionin Theorem 6. The repairing time for each node in the chaingiven in the Table III. Depending on the depth of the leaf inthe path starting from node 3 and the link delay for receivingfirst holdFlow and then UpdateLevel message, Δ increases asobserved from node 5 towards the leaf node 8.

The simulation is also executed for complex network topolo-gies, and the result is found to be similar. However, it is notreported in this paper due to space constraints.

IV. CONCLUSION

In this paper, a scheme has been proposed to construct aBFS tree for data gathering where each node computes itsalternate path to the sink, based on neighborhood informationcollected during the tree construction. Thus when a node fails,all its neighbors can take actions in constant time to repairthe tree locally. This approach makes the repairing fast andof low cost which in turn improves QoS and saves batterypower. Simultaneous single node failures (excluding alternateparent failure) can be repaired by the proposed scheme. Let thecommunication graph G is k-connected. The crash of a seriesof (k−1) nodes adjacent to each other may partition G. Hencefor any k-connected graph G, at most (k−1) node crashes thatare adjacent to each other can be tolerated before G becomespartitioned. However, more than (k − 1) non-adjacent nodecrash can be tolerated by the proposed scheme. Simulationresults confirms the theoretical proposition with the assuranceof correct delivery of convergecast messages without any lossor redundancy even for a series of arbitrary node crash.

2012 IEEE Network Operations and Management Symposium (NOMS): Mini-Conference 945

REFERENCES

[1] I. F. Akyildiz, W. Su, Y. Sankarasubramaniam, and E. Cayirci, “Wire-less sensor networks: A survey,” Computer Network Elsevier Journal,vol. 38, pp. 393–422, March 2002.

[2] S. Lindsey and C. Raghavendra, “PEGASIS: Power-efficient gatheringin sensor information systems,” in IEEE Aerospace Conference Proceed-ings, vol. 3, 2002, pp. 1125–1130.

[3] Y. Yu., B. Krishnamachari, and V. Prasanna, “Energy-latency tradeoffsfor data gathering in wireless sensor networks,” in INFOCOM, vol. 1,2004.

[4] S. Upadhayayula, V. Annamalai, and S. Gupta, “A low-latency andenergy-efficient algorithm for convergecast in wireless sensor networks,”in Global Telecommunications Conference, IEEE, vol. 6, 2003, pp.3525–3530.

[5] K. Lu, L. Huang, Y. Wan, and H. Xu, “Energy-efficient data gatheringin large wireless sensor networks,” in Proceedings of the SecondInternational Conference on Embedded Software and Systems, 2005,pp. 327–331.

[6] V.Annamalai, S. Gupta, and L.Schwiebert, “On tree-based converge-casting in wireless sensor networks,” in Proceedings of IEEE WirelessCommunication and Networking Conference, 2003, pp. 1942–1947.

[7] X.-Y. Li, Y. Wang, and Y. Wang, “Complexity of data collection,aggregation, and selection for wireless sensor networks,” IEEE Trans.on Computers, vol. 60, pp. 386–399, 2011.

[8] S. Chen, S. Tang, M. Huang, and Y. Wang, “Capacity of data collectionin arbitrary wireless sensor networks,” in Proceedings of IEEE INFO-COM, 2010, pp. 1–5.

[9] T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein, “Introductionto algorithms, second edition,” 2001.

[10] C. Johnen, “Memory efficient, self-stabilizing algorithm to construct bfsspanning trees,” in Proceedings of the sixteenth annual ACM symposiumon Principles of distributed computing, 1997.

[11] C. Boulinier, A. K. Datta, L. L. Larmore, and F. Petit, “Space efficientand time optimal distributed bfs tree construction,” Inf. Process. Lett.,vol. 108, pp. 273–278, 2008.

[12] S. Zou, I. Nikolaidis, and J. J. Harms, “Encast: Energy-critical nodeaware spanning tree for sensor networks,” in Proceedings of the 3rdAnnual Communication Networks and Services Research Conference,2005, pp. 249–254.

[13] T. Herault, P. Lemarinier, O. Peres, L. Pilard, and J. Beauquier, “Briefannouncement: self-stabilizing spanning tree algorithm for large scalesystems,” in Proceedings of the 8th international conference on Stabi-lization, safety, and security of distributed systems, 2006, pp. 574–575.

[14] Z. Fei and M. Yang, “A proactive tree recovery mechanism for resilientoverlay multicast,” in IEEE Trans. on Networking, vol. 15, 2007, pp.173–186.

[15] D. England, B. Veeravalli, and J. B. Weissman, “A robust spanning treetopology for data collection and dissemination in distributed environ-ments,” IEEE Trans. on Parallel Distrib. Syst., vol. 18, pp. 608–620,2007.

[16] Ns-2 network simulator, version 2.34. [Online]. Available:http://www.isi.edu/nsnam/ns/

946 2012 IEEE Network Operations and Management Symposium (NOMS): Mini-Conference