Energy Efficient Distributed Algorithms for

Sensor Target Coverage Based on Properties ofan Optimal Schedule

Akshaye Dhawan and Sushil K. Prasad

Georgia State University, Department of Computer Science, Atlanta, Ga 30303akshaye@cs.gsu.edu, sprasad@cs.gsu.edu

Abstract. A major challenge in Wireless Sensor Networks is that ofmaximizing the lifetime while maintaining coverage of a set of targets,a known NP-complete problem. In this paper, we present theoretically-grounded, energy-efficient, distributed algorithms that enable sensors toschedule themselves into sleep-sense cycles. We had earlier introduceda lifetime dependency (LD) graph model that captures the interdepen-dencies between these cover sets by modeling each cover as a node andhaving the edges represent shared sensors. The key motivation behindour approach in this paper has been to start with the question of whatan optimal schedule would do with the lifetime dependency graph. Weprove some basic properties of the optimal schedule that relate to theLD graph. Based on these properties, we have designed algorithms whichchoose the covers that exhibit these optimal schedule like properties. Wepresent three new sophisticated algorithms to prioritize covers in thedependency graph and simulate their performance against state-of-artalgorithms. The net effect of the 1-hop version of these three algorithmsis a lifetime improvement of more than 25-30% over the competing al-gorithms of other groups, and 10-15% over our own; the 2-hop versionshave additional improvements, 30-35% and 20-25%, respectively.

1 Introduction

Wireless Sensor Networks (WSNs) consist of a number of low cost sensors thatare equipped with a radio interface. These devices are deployed in large numbersover an area of interest and they monitor the targets in this region and sendinformation to a base station or a gateway node [1].

Since these sensors are powered by batteries, energy is a key constraint forthese networks. The lifetime of the network is defined as the amount of time thatthe network can cover its area or targets of interest. A standard approach takento maximize the lifetime is to make use of the overlap in the sensing regionsof individual sensors caused by the high density of deployment. Hence, only asubset of all sensors need to be in the “on” state, while the other sensors canenter a low power “sleep” state. The members of this active cover set, are thenperiodically updated. In using such a scheduling scheme, there are two problemsthat need to be addressed. First, we need to determine how long to use a given

P. Sadayappan et al. (Eds.): HiPC 2008, LNCS 5374, pp. 269–281, 2008.c© Springer-Verlag Berlin Heidelberg 2008

270 A. Dhawan and S.K. Prasad

cover set and then we need to decide which set to use next. This problem hasbeen shown to be NP-complete [2, 3].

Existing work on this problem has looked at both centralized and distributedalgorithms to come up with such a schedule. Initial approaches to maximize thelifetime in [2, 3, 4] considered the problem of finding the maximum number ofdisjoint covers. However, [5, 6] and others showed that using non-disjoint coversallows the lifetime to be extended further and this has been adopted since. Acommon approach taken with centralized algorithms is that of formulating theproblem as an optimization problem and using linear programming (LP) to solveit [3, 6, 7, 8]. The distributed algorithms typically operate in rounds. At thebeginning of each round, a sensor exchanges information with its neighbors, andmakes a decision to either switch on or go to sleep. In most greedy algorithms[2, 4, 5, 9, 10, 11], the sensor with some simple greedy criteria like the largestuncovered area [9], maximum uncovered targets [10], etc. is selected to be on.

A key problem here is that since a sensor can be a part of multiple covers,these covers have an impact on each other, as using one cover set reduces thelifetime of another set that has sensors common with it. By making greedychoices, the impact of this dependency is not being considered. In [12], we capturethis dependency between covers by introducing the concept of a local LifetimeDependency (LD) Graph. This consists of the cover sets as nodes with any twonodes connected if the corresponding covers intersect (See Section 2 for a moredetailed description). We also presented a generalized framework based on thisapproach and applied it to the area and k -coverage problems [13].

Our Contributions: The key motivation behind our approach in this paper hasbeen to start with the question of what an optimal schedule (henceforth calledOPT ) would do with the LD graph. We have been able to prove certain basicproperties of the OPT schedule that relate to the LD graph. Based on theseproperties, we have designed algorithms which choose the covers that exhibitthese OPT schedule like properties. We present three new heuristics - Sparse-OPT based on the sparseness of connectivity among covers in OPT , Bottleneck-Target based on selecting covers that optimize the use of sensors covering localbottleneck targets, and Even-Target-Rate based on trying to achieve an evenburning rate for all targets. These heuristics are at a higher level and operateon top of degree-based heuristics to prioritize the local covers. Our experimentsshow an improvement in lifetime of 10-15% over our previous work in [12] and25-30% over competing work in [10, 11] and 35% improvement for a two-hopversion over the two-hop algorithm of [11].

The remainder of this paper is organized as follows. We begin by defining thenotation we use and review the Lifetime Dependency Graph model in Section2. In Section 3 we present and prove some key properties of the OPT sequence.This is followed by Section 4 where we introduce new algorithms based on theseproperties. All the proposed heuristics are then simulated and evaluated in Sec-tion 5. Finally, we conclude in Section 6.

Energy Efficient Distributed Algorithms 271

2 Preliminaries and Background Work

Definitions: Let the sensor network be represented using graph SN where, S ={s1, s2, . . . , sn} is the set of sensors, and an edge between sensor si and sj exists ifthe two sensors are in communication range of each other. Let the set of targetsbe T = {t1, t2, . . . , tm}. In this paper we consider the problem of covering astationary set of targets. This can easily be translated into the area coverageproblem by mapping the area to a set of points which need to be covered [4, 14].In addition to this, we define the following notation:

• b(s): The battery available at a sensor s.• T (s): The set of targets in the sensing range of sensor s.• N(s, k): The closed neighbor set of sensor s at k communication hops.• Cover C: Cover C ⊆ S to monitor targets in T is a minimal set of sensors

s.t. each target t ∈ T has a nearby sensor s ∈ C which can sense t, i.e., t ∈ T (s).• lt(C): Maximum lifetime of a cover C is lt(C) = mins∈Cb(s).• lt(ti): The lifetime of a target ti ∈ T is given by lt(ti) =

∑{s|ti∈T (s)} b(s).

• Bottleneck Sensor: Bottleneck sensor s of cover C is the sensor s ∈ C withminimum battery, i.e., it is the sensor s that upper bounds lt(C).

• Bottleneck Target (tbot): The target with the smallest lifetime lt(tbot).• Lifetime of a schedule of covers: We can view the set of currently active

sensors as a cover Ci that is used for some length of time li.Given a schedule ofcovers of the form, (C1, l1), (C2, l2), ..., (Cr, lr). The lifetime of this schedule isgiven by

∑ri=1 li.

• OPT : The optimal schedule of covers that achieves the maximum lifetime.Note that this includes both the covers and their corresponding time periods.

The Lifetime Dependency (LD) Graph [12]: The Lifetime dependency graphLD = (V, E) where V is the set of all possible covers to monitor targets in Tand two covers C and C′ are joined by an edge in E if and only if C ∩ C′ �= ∅.

The LD graph effectively captures the dependency between two cover sets byrepresenting their intersection by the edge between them. Further, we define,

• w(e): Weight of an edge e between covers C and C′ is w(e) = mins∈C∩C′ b(s).• d(C): Degree of a node or cover C is d(C) = Σe incident to C w(e).

The reasoning behind this definition of the edge weight comes from consideringa simple two-node LD graph with two covers C1 and C2 sharing an edge e. Thelifetime of the graph is upper bounded by min(lt(C1) + lt(C2), w(e)). Similarly,in defining the degree of a cover C by summing the weights of all the edgesincident on the cover, we are getting a measure of the impact it would have onall other covers with which it shares an edge.

Basic Algorithmic Framework: Our distributed algorithms consist of a initialsetup phase followed by rounds of predetermined duration during which sensorsnegotiate with their neighbors to determine their sense/sleep status.

Setup: In the setup phase, each sensor s communicates with each of its neighbors′ ∈ N(s, 1) exchanging battery levels b(s) and b(s′), and the targets covered T (s)

272 A. Dhawan and S.K. Prasad

and T (s′). Then it finds all the local covers using the sensors in N(s, 1) for thetarget set being considered. It then constructs the local LD graph LD = (V, E)over those covers, and calculates the degree d(C) of each cover C ∈ V in thegraph LD. Note that the maximum number of covers that each sensor constructsis a function of the number of neighbors and the number of local targets ithas. Both of these are relatively small for most graphs (but theoretically isexponential in the number of targets).

Prioritize and Negotiate solutions: Once the LD graph has been constructed byeach sensor, it needs to decide which cover to use. In order to do this, a priorityfunction can be defined to prioritize the local covers. We base the priority ofcover C on its degree d(C). A lower degree is better since this corresponds toa smaller impact on other covers. Note that the priority function is computedat the beginning of every round by exchanging current battery levels amongneighbors since the degrees may have changed from the previous round.

The goal is to try and satisfy the highest priority cover. However, a covercomprises of multiple sensors and if one of these switches off, this cover cannotbe satisfied. Hence, each sensor now uses the automaton in Fig. 1 to decidewhether it can switch off or if it needs to remain on. The automaton starts withevery sensor s in its highest priority cover C. The sensor s keeps trying to satisfythis cover C and eventually if the cover C is satisfied, then s switches on if s ∈ Celse s switches off. If a cover C cannot be satisfied, then the sensor s transitionsto its next best priority cover C′, C′′ and so on, until a cover is satisfied.

We simulated this Degree-Based heuristic along with a few of its variants overa range of sensor networks and compared the lifetime of their schedules withthe current state-of-art algorithms, LBP [10] and DEEPS [11], and showed animprovement of 10-20% in network lifetime. One clear distinction between ouralgorithm and others is that while all previous algorithms work on sensor networkgraph (SN), ours work on dependency graphs (LD), a higher level abstraction.

Fig. 1. The state transitions to decide the sense/sleep status

Energy Efficient Distributed Algorithms 273

3 Properties of the Optimal Sequence

In this paper, our approach to the problem of further extending the lifetime ofthe network has been to turn the argument on its head. Instead of trying to comeup with different schemes of scheduling sensors into cover sets, let us suppose weknow the best schedule. Such a schedule OPT comprises a collection of coversand the time for which each cover is used in the optimal schedule,

OPT = {(Copt1 , l1), (Copt2 , l2), ..., (Coptr , lr)}.The optimal sequence can be viewed as a partition of the space of covers into

those covers that are in OPT and those that are not. Now visualize all possiblecover sets in the LD graph. How would one identify from amongst all these sets,those that are candidates for being in OPT? Our goal is to identify certainproperties of the OPT that can help make this decision.

Lemma 1. OPT burns all the covers.

Proof: Suppose there is a cover C′ that is not burned by OPT, i.e., its weakestsensor has some battery left. Burning this cover would further increase the life-time of the network by an amount lt(C′). This implies that OPT is non-optimal,which gives us a contradiction. �

Lemma 2. If a cover C is not used in OPT, C has at least one neighboringcover in the LD Graph in OPT.

Proof: If a cover C is not used in OPT, then it has at least one sensor s ∈ C thathas exhausted its battery. If this is not true, then C still has some lifetime leftand this gives us a contradiction according to Lemma 1. The fact that sensor shas been completely burned for cover C implies that there is at least one othercover in OPT that contains this sensor s. Otherwise, s would not be burned.This means that there is at least one cover which is a neighbor of C in the LDgraph (because they share the sensor s) and is also in OPT. �

Corollary: If a cover C is not used in OPT , C has one or more neighboringcovers in OPT such that total span of these neighbors in OPT is at least thelife of C.

Lemma 3. The covers in OPT form a dominating set of the LD Graph.

Proof: A dominating set of a graph is a set of vertices such that every vertex iseither in this set or is a neighbor of a node in the dominating set.

Let us consider a cover C. Either it is in OPT , in which case it is a dominatingnode, or it is not in OPT . By Lemma 2, if it is not in OPT , it has to have atleast one neighbor in OPT . Hence it is a dominated node. Hence, the covers inOPT dominate the set of all covers in the LD graph. �

274 A. Dhawan and S.K. Prasad

Lemma 4. All permutations of OPT are optimal.

Proof: This lemma shows that the ordering of individual covers in the OPTsequence is irrelevant. Any permutation OPT ′ of OPT can be obtained by re-peatedly moving (COPTi , li) to its position j in OPT ′ for all eligible i. We provethat each such move preserves optimality.

Moving COPTi to position j changes its relative ordering with its neighboringcovers in the LD graph which lie between position i and j. Let us call theseneighbors N ′(COPTi ). Other neighbors of COPTi do not see any change, nordo other covers which are not neighbors. For each neighboring cover COPTk

∈N ′(COPTi ), w(COPTi ∩ COPTk

) ≥ li + lk, as each edge upper bounds the cu-mulative lifetime. Therefore, if i > j burning COPTi before COPTk

will leavew(COPTi ∩COPTk

)− li ≥ lk of battery in COPTi ∩COPTk. Therefore, COPTk

canbe burnt for a duration of lk, for each COPTk

∈ N ′(COPTi ).On the other hand, if i < j, each COPTk

∈ N ′(COPTi ) will be burnt for lktime, leaving w(COPTk

∩ COPTi) − lk ≥ li of battery in COPTk∩ COPTi . Thus,

COPTi can be burnt for duration of li at position j. �

Corollary: If C occurs more than once in OPT , all its occurrences can bebrought together, thereby burning C all at once for the cumulative duration.

Lemma 5. Due to OPT, all sensors around at least one target are completelyburnt.

Proof: This relates to Lemma 1, because if there is no such bottleneck target,then it is still possible to cover all targets, implying that a cover exists, andhence OPT is not optimal. �

4 Optimal Schedule Based Algorithms

Recall from our discussion on the Lifetime Dependency Graph model in Section 2that we used the degree d(C) of a cover C in order to determine its priority. Thedefinition of the degree as the key prioritization criteria is limited since it onlyconsiders a local property of the LD graph. As we saw in the previous section,there are properties which show how an OPT schedule would choose covers inthe LD graph. Our goal in this section is to design heuristics that utilize theseproperties in the prioritization phase of the algorithm described in Section 2. Weintroduce three heuristics based on the properties of the OPT schedule. Each ofthese heuristics define a different way to prioritize the local covers. Note that ifall remaining covers are tied on the new priority functions, we revert to using thedegree to break ties. Hence, these heuristics can be viewed as defining a higherlevel priority function, that acts on top of the degree d(C) function.

Heuristic 1: Sparse-OPTThis heuristic is based on Lemma 2 and works on the idea that the covers inOPT are sparsely connected. Suppose we have a subsequence of OPT available

Energy Efficient Distributed Algorithms 275

and we were to pick a cover to add to this sequence. Clearly any cover we add tothe OPT sequence should not be a neighbor of a cover that is already in OPT .By Lemma 2, we know that if a cover C is in OPT for time l, then its neighborsin the LD graph can only be in OPT if their shared sensor s has a batteryb(s) > l. This implies that covers in OPT are likely to be sparsely connected.Hence, for any two nodes (covers) in OPT, their degree in the induced subgraphof the LD graph should be low. For a cover C, we define its degree to other coversalready selected (in OPT ) as: dOPT (C) = Σe incident to C and to C′∈OPT w(e).

This leads us to a simple heuristic: When choosing a cover Ci, pick the coverwith the lowest degree to nodes already chosen.

Implementation: When implementing this heuristic, the exchange of messagesduring the setup phase remains unchanged from before. The next step in thealgorithm would be to prioritize the covers in the local LD graph. Instead ofprioritizing a cover C by its degree d(C), the heuristic we defined gives us ahigher level of prioritization. Initially, there are no covers that have been selectedfor use so the heuristic starts off as before. A sensor orders its local covers byd(C) (battery and id’s can be used to break ties), and then enters a negotiationphase with its neighbors in order to decide which cover to use. This would resultin some cover C′ being selected for use.

In the subsequent round the sensor recomputes the priority function for itscovers. Now, in computing the priority of a cover C, we can look at its degreeto the previously used cover C′, given by dOPT (C), and prioritize the covers inthe order of lowest degree first. Note that if dOPT is the same for several covers,we can break ties by using d(C) as before. As the set of previously used coversincreases over time, we compute the priorities at the beginning of each round bylooking at the dOPT of any cover to this set and assigning a higher priority tothe covers with the lowest degree.

Heuristic 2: Bottleneck-TargetThis heuristic is based on the property that covers in OPT should optimize thelocal bottleneck target and makes use of the ideas presented in Lemma 5.

Let us consider the set of all targets T . Some of these targets are more im-portant than others because they represent bottlenecks for the lifetime of thenetwork. Consider a target ti. Then, the total amount of time this target can bemonitored by any schedule is given by: lt(ti) =

∑{s | ti∈T (s)} b(s).

Clearly there is one such target with the smallest lt(ti) value, that is a bot-tleneck for the entire network. Since the network as a whole cannot achieve alifetime better than this bottleneck, it follows that any cover should not usemultiple sensors from the set of sensors that cover this bottleneck. However,without a global picture, it is not possible for any sensor to determine if oneof its local targets is this global bottleneck. However, every sensor is aware ofwhich of its local targets is a local bottleneck. The key thing to realize is thefact that if every sensor optimizes its local bottleneck target, then one of theselocal optimizations is also optimizing the global bottleneck target. Let tbot bethis local bottleneck target. Let Cbot be the set of sensors that can cover thislocal bottleneck target.That is, Cbot = {s | tbot ∈ T (s)}.

276 A. Dhawan and S.K. Prasad

Ideally, we would like to use a cover that has only one sensor in Cbot asa part of this cover. However this may not always be possible. Hence, whileprioritizing the local covers, we can pick a cover that minimizes the cardinalityof its intersection with Cbot. Hence, the cover selected should be the cover C thatminimizes |C ∩ Cbot|.Implementation: The implementation is similar to Heuristic 1. Again, thesetup and LD graph construction phase remain unchanged. Every sensor s nowcomputes its local bottleneck target tbot ∈ T (s) and the set of sensors that coversthis target Cbot. Note that this can be done since at the end of the setup phase,every sensor knows who its neighbors are, which targets they cover, and howmuch battery they have. When calculating the priority of each cover C in theLD graph, the priority function defined by this heuristic calculates the value of|C ∩ Cbot| for each cover, since this gives us the number of sensors in Cbot thatare a part of the cover C. The heuristic then prioritizes covers in descendingorder of this cardinality. Again, if this value is the same for multiple covers, webreak ties by using the degree d(C).

Heuristic 3: Even-Target-RateThis heuristic is based on the idea that OPT should try and burn all targets atthe same rate. Consider a target ti ∈ T . Let lt(ti) be the sum of the batteryof all sensors covering ti. Clearly the network cannot be alive for longer thanlt(tbot) where tbot is the target with the smallest lifetime. Heuristic 2 statedabove tries to maximize the time this bottleneck can be used. However, thedanger in this is that by doing so, a different target may become the bottleneckdue to repeated selection of its covering sensors. To avoid this problem, and atthe same time optimize the bottleneck target, we want to keep an even rateof burning for all targets. In order to arrive at a normalized burning rate foreach target ti, we define the impact of a cover C on a target ti as given by,

Impact(C, ti) = |{ s ∈ C | ti ∈ T (s)}|lt(ti)

.

The Impact should give a measure of how this cover C is reducing the lifetimeof a target ti. Since each round lasts for one time unit, the impact is measuredby the number of sensors covering ti that are in C. Hence, the definition. Thisgives us the heuristic: Any cover chosen should be the best fitting cover in thatit burns all targets at an even rate.

Implementation: After setup and constructing its LD Graph as before, eachsensor s enters the prioritization phase. For every target being considered, scomputes the impact of a cover C on that target, i.e., the sensor s calculatesImpact(C, ti) for all ti ∈ T (s). Let Impactmax(C) be the highest impact ofthis cover C and let Impactmin(C) be the lowest impact of C for all targets.A good cover will have a similar impact on all targets, since it burns them atthe same normalized rate. Hence, we prioritize covers in descending order of thisdifference, given by Impactmax(C) − Impactmin(C). Once again, if the impactis the same, we can break ties using d(C).

Energy Efficient Distributed Algorithms 277

5 Experimental Evaluation

In this section, we first evaluate the performance of the one-hop and two-hop ver-sions of the three heuristics based on OPT schedule as compared to the 1-hopalgorithm LBP [10], the 2-hop algorithm DEEPS [11], and our basic Degree-Based heuristic from our previous work in [12]. Next, we create appropriatehybrids of the three 1-hop heuristics in various combinations, showing that allthree combined together yield around 30% improvement over 1-hop LBP and25% over the 2-hop DEEPS algorithm (Fig. 2 and 3). Even though theoreti-cally our algorithms are exponential in the number of targets, practically theircomputation time was no more than three times the LBP algorithm with samecommunication complexities. We also implement the 2-hop versions of theseheuristics and obtain a 35% improvement in lifetime over DEEPS (Fig. 4). Ascompared to an upper bound on the longest network lifetime (the lifetime of theglobal bottleneck target), our 1-hop algorithms have moved the state of art tono worse than 30-40% on an average (Fig. 5). The 2-hop algorithms are no worsethat 25% on an average.

The load balancing protocol (LBP) [10] is a simple one-hop protocol whichworks by attempting to balance the load between sensors. Sensors can be inone of three states sense, sleep or vulnerable/undecided. Initially all sensors arevulnerable and broadcast their battery levels along with information on which

Fig. 2. Lifetime with 25 Targets

Fig. 3. Comparing LBP [3] against the 1-hop OPT-based heuristics

278 A. Dhawan and S.K. Prasad

Fig. 4. Comparing DEEPS [11] against the 2-hop OPT-based heuristics

Fig. 5. Comparing 1-hop and 2-hop Degree-Based [12] heuristics against OPT-basedheuristics

targets they cover. Based on this, a sensor decides to switch to off state if itstargets are covered by a higher energy sensor in either on or vulnerable state.On the other hand, it remains on if it is the sole sensor covering a target.

The second protocol we consider is a two-hop protocol called DEEPS [11].Themain intuition behind DEEPS is to try to minimize the energy consumption ratearound those targets with smaller lives. A target is defined as a sink if it is theshortest-life target for at least one sensor covering that target. Otherwise, it is ahill. To guard against leaving a target uncovered during a shuffle, each target isassigned an in-charge sensor. For each sink, its in-charge sensor is the one withthe largest battery for which this is the shortest-life target. For a hill target, itsin-charge is that neighboring sensor whose shortest-life target has the longestlife. An in-charge sensor does not switch off unless its targets are covered bysomeone. Apart from this, the rules are identical as those in LBP protocol.

In order to compare the algorithm against LBP, DEEPS, and our previouswork, we use the same experimental setup and parameters as employed in [10].We carry out all the simulations using C++. For the simulation environment,a static wireless network of sensors and targets scattered randomly in 100m ×100m area is considered. We conduct the simulation with 25 targets randomlydeployed, and vary the number of sensors between 40 and 120 with an increment

Energy Efficient Distributed Algorithms 279

of 20 and each sensor with a fixed sensing range of 60m. We assume that thecommunication range of each sensor is two times the sensing range [15, 16]. Forthese simulations, we use the linear energy model wherein the power requiredto sense a target at distance d is proportional to d. We also experimented withthe quadratic energy model (power proportional to d2). The results are similarto [12] and the same trends as the linear model apply. Due to space constraints,we only show a snapshot of these results in Fig. 5.

The results are shown in Fig. 2. As can be seen from the figure, among thethree heuristics, the Bottleneck-Target heuristic performs the best giving about10-15% improvement in lifetime over our previous 1-hop Degree-Based heuristicand about 25-30% over LBP and DEEPS. Sparse-OPT and Even-Target-Ratealso improve over the Degree-Based heuristic. We also ran simulations witha combination of the heuristics. (2, 1) denotes the combination of heuristic 2,Bottleneck-Target, followed by heuristic 1, Sparse-OPT, and so on. For theseexperiments, the priority function was modified to implement the priority func-tion of both heuristics in the same algorithm. For example, in (2, 1), we firstoptimize the local bottleneck target (based on heuristic 2) and in case of ties,we break them by checking the degree to previously selected covers (based onheuristic 1). Other implementations follow similarly. The combination of heuris-tics give a better lifetime than the individual heuristics; the best hybrid was(2,3,1) plotted in Fig. 2.

In Fig. 3, we highlight the performance of the three heuristics as comparedto LBP. The simulation is run for 40, 80 and 120 sensors, with 25 targets anda linear energy model. As can be seen, a similar trend in improvements is ob-served. Overall lifetime improvements are in the range of 25-30% over LBP as thebaseline. Since DEEPS is a 2-hop algorithm, we also compared 2-hop versions ofour proposed heuristics, where the target set T (s) of each sensor is expanded toinclude ∪s′∈N(s,1)T (s′) and the neighbor set is expanded to all 2-hop neighbors,i.e., N(s, 2). The results are shown in Fig. 4. As can be seen, the 2-hop versionsgive a further gain in lifetime over DEEPS, with overall improvement of 35% forthe hybrid of the three heuristics.

Finally, we highlight the comparison of the proposed heuristics against ourprevious work [12] in Fig. 5. We show results here for the median value of n = 80sensors. The two series compare the 1-hop version of the Degree-Based heuristicagainst the 1-hop version of the OPT heuristics and then repeat these compar-isons for the 2-hop versions of both. Overall, we achieve gains of 10-15% for the1-hop heuristics and between 20-25% for the 2-hop heuristics. We also show (i)how far these heuristics are compared to the upper bound on network lifetime,and (2) that both linear and quadratic energy models follow similar trends.

6 Conclusion

In this paper, we address the problem of scheduling sensors to extend the life-time of a Wireless Sensor Network. We examine the properties that an optimalschedule would exhibit and use these to design three new heuristics that work

280 A. Dhawan and S.K. Prasad

on the lifetime dependency graph model. Simulations show an improvement of25-30% over the algorithms in [10, 11] and 10-15% over our previous work in [12]for the 1-hop algorithms. Two-hop versions show additional improvements overtheir counterparts. These heuristics are designed to work on higher level proper-ties of the dependency graph. The net effect is a significant improvement in thestate of art, with our algorithms performing no worse than 30-40% compared tothe optimal network lifetime on an average. Future work includes dealing withthe exponential nature of the problem space by designing heuristics that caneffectively sample good quality local covers.

References

1. Akyildiz, I., Su, W., Sankarasubramaniam, Y., Cayirci, E.: A survey on sensornetworks. IEEE Commun. Mag., 102–114 (2002)

2. Abrams, Z., Goel, A., Plotkin, S.: Set k-cover algorithms for energy efficient mon-itoring in wireless sensor networks. In: Third International Symposium on Infor-mation Processing in Sensor Networks, pp. 424–432 (2004)

3. Cardei, M., Du, D.Z.: Improving wireless sensor network lifetime through poweraware organization. Wireless Networks 11(8), 333–340 (2005)

4. Slijepcevic, S., Potkonjak, M.: Power efficient organization of wireless sensor net-works. In: IEEE International Conference on Communications (ICC), vol. 2, pp.472–476 (2001)

5. Cardei, M., Thai, M., Li, Y., Wu, W.: Energy-efficient target coverage in wirelesssensor networks. In: INFOCOM 2005, vol. 3 (March 2005)

6. Berman, P., Calinescu, G., Shah, C., Zelikovsky, A.: Power efficient monitoringmanagement in sensor networks. In: Wireless Communications and NetworkingConference (WCNC), vol. 4, pp. 2329–2334 (2004)

7. Miodrag, S.M.: Low power 0/1 coverage and scheduling techniques in sensor net-works. UCLA Technical Reports 030001 (2003)

8. Dhawan, A., Vu, C.T., Zelikovsky, A., Li, Y., Prasad, S.K.: Maximum lifetime ofsensor networks with adjustable sensing range. In: Proceedings of the InternationalWorkshop on Self-Assembling Wireless Networks (SAWN), pp. 285–289 (2006)

9. Lu, J., Suda, T.: Coverage-aware self-scheduling in sensor networks. In: 18th An-nual Workshop on Computer Communications (CCW), pp. 117–123 (2003)

10. Berman, P., Calinescu, G., Shah, C., Zelikovsky, A.: Efficient energy managementin sensor networks. In: Ad Hoc and Sensor Networks, Wireless Networks and MobileComputing (2005)

11. Brinza, D., Zelikovsky, A.: Deeps: Deterministic energy-efficient protocol for sen-sor networks. In: Proceedings of the International Workshop on Self-AssemblingWireless Networks (SAWN), pp. 261–266 (2006)

12. Prasad, S.K., Dhawan, A.: Distributed algorithms for lifetime of wireless sensornetworks based on dependencies among cover sets. In: Aluru, S., Parashar, M.,Badrinath, R., Prasanna, V.K. (eds.) HiPC 2007. LNCS, vol. 4873, pp. 381–392.Springer, Heidelberg (2007)

13. Dhawan, A., Prasad, S.K.: A distributed algorithmic framework for coverage prob-lems in wireless sensor networks. In: Procs. Intl. Parallel and Dist. ProcessingSymp. Workshops (IPDPS), Workshop on Advances in Parallel and DistributedComputational Models (APDCM), pp. 1–8 (2008)

Energy Efficient Distributed Algorithms 281

14. Tian, D., Georganas, N.D.: A coverage-preserving node scheduling scheme for largewireless sensor networks. In: WSNA: Proceedings of the 1st ACM internationalworkshop on Wireless sensor networks and applications, pp. 32–41. ACM, NewYork (2002)

15. Zhang, H., Hou, J.: Maintaining sensing coverage and connectivity in large sensornetworks. In: Ad Hoc and Sensor Wireless Networks, AHSWN (2005)

16. Xing, G., Wang, X., Zhang, Y., Lu, C., Pless, R., Gill, C.: Integrated coverage andconnectivity configuration for energy conservation in sensor networks. ACM Trans.Sen. Netw. 1(1), 36–72 (2005)