Luigi Palopoli University of Trento

Roberto Passerone, G. P. Picco, A.L. Murphy, D. Fontanelli …

2

•  A very important application for WSN is surveillance •  Prominent issues:

–  detect targets with a good probability –  preserve the lifetime of the network

•  We can extend the lifetime of the network by alternating short awake intervals with long sleeping intervals

•  ….how can do this without compromising the probability of detecting targets?

time sensor

epoch awake interval

wake-up time

By finding an appropriate schedule for the wakeup times of the nodes�

Input: –  a set of nodes deployed on an area –  the sensing range of the nodes –  a desired lifetime (which maps on the duty-cycle)

5

Output: –  A schedule that maximises the total area covered

throughout the epoch

6

n1

n2

n3 S1

S2

S3

S12

S13

S123 S23

n1 n2 n3

Schedule 1

0 E Coverage

w

7

n1

n2

n3 S1

S2

S3

S12

S13

S123 S23

n1 n2

n3

Schedule 2

0 E Coverage

w

•  We can cast the problem into the framework of MILP optimisation

9

•  …we assume to: – Know position and range of each node – Operate in a “centralized” way – Re-compute the schedule every time a node

exhausts its battery

Palopoli, Passerone, Murphy, Picco, Giusti. EWSN09 for an efficient solution

1.  Discretize the target area into a finite number of regions

–  Points in the same region are covered by the same nodes

2.  Setup a boolean linear program enforcing the constraints of the wake-up scattering problem

•  Assume a rectangular sensing area – Can be generalized to arbitrary shapes, using

unions of rectangles

{3} {2,3}

{1,2,3}

{1,2} {2} 1 2

3

•  Enables a discretization of the problem –  the time line in each epoch is divided into L=E/I slots

•  Given an optimal schedule, always possible to find an equivalent one w/ wake-up times aligned on slots

•  Enables pruning of a large portion of the solution space remarkable computation speed-up

•  Proof in the paper

Let the epoch duration E be an integer multiple of the awake interval I. Then there exists a schedule such that every node wakes up at

some integer multiple of I ���(within E) which maximizes the average coverage

•  Goal: maximize coverage area S #slots per epoch

Coverage of region ρ is 1 if there is a node active during slot k

Area of region ρ

  Coverage depends on the schedule, modeled by boolean variables

Coverage is 0 when there are no nodes in the region

Coverage is 1 when there is at least one node in the region

A node wakes up at most once per epoch

•  Formal modeling of the problem enables offline analysis of tradeoffs

•  Extensive pre-deployment evaluation can be performed at little cost –  Particularly useful in cases where it is possible to use a

pre-computed schedule

•  For a few dozens of nodes, we come up to an acceptable solution in a few minutes

•  Despite this remarkable simplification, this technique remains Np-hard

•  Several days (weeks) required for an open source solver (GLPK) when we overcome the threshold of 100 nodes

•  We can reduce this time switching to a commercial solver, but

•  …we do have an issue of scalability 16

•  Inspired by VLSI design, we have developed a suboptimal algorithm

17

Palopoli, Passerone. Toldo, Disi Tech report 2009, conference paper in preparation

•  The idea is a classical divide-and-conquer approach

•  We break down the problem into simpler one, we solve them and then we combine the results

18

We break down the topology into smaller topologies of

manageable size

We solve the Scheduling problem

producing partial schedules of the

nodes

We increase the coverage shifting

appropriately the partial schedules

We are able to Compute how far off we are

from the optimal

•  The partitioning problem is itself a ILP …

19

•  Much smaller in size but still NP-HARD :=(

•  However, we can save the day using very effective linear heuristics for VLSI design

Fiduccia, Mathesis, DAC 1982

•  The post-processing phase can be carried out using a gradient descent approach

•  We shift the partial schedules looking at the coverage of areas neglected in the partitioning phase

20

21

We can compute a nearly optimal schedule

even for very large topologies

In a few minutes

•  To tackle this problem we can use an interesting heuristic, the wakeup scattering algorithm

23

•  The idea is that nearby nodes should have “scattered” wakeup intervals)

•  We can do this by an iterative algorithm

See Giusti. Murphy, Picco EWSN07

Wakeup Time of the i-th node

Midpoint Of the wakeup

time of the nodes seen

•  All nodes discover –  Their wake up time, WC –  Wake up time of the node

before them, Wprev –  Wake up time of the node

after them, Wnext

•  Calculate their new target wake up time –  Wc’=(Wprev+Wnext)/2 * α –  Move toward this new wakeup

time in the next epoch

•  Key Properties –  Process is entirely localized –  All nodes execute in parallel –  No central coordination

A B C

WC Wnext Wprev

WC’

Schedule

25

Coverage

26

Deployment Coverage

(optimal 53%)

Typically, the algorithm produces a suboptimal solution 10-5% away from the optimal one

Does the wakeup scattering algorithm converge?

27

•  It is convenient to choose an appropriate subset of the distances between the wakeup times as state variables

29

Forward Distance

Backward Distance

•  The update rule of the algorithm yields

30

•  where

Nodes Seen by i

Induces a linear switching

dynamics

•  Collecting the forward distances (of nodes that see each other) in a vector we get an evolution for the system given by:

31

Switching function

32

If two nodes see each other, they do not

overtake each other

•  As a first step we study convergence when the dynamics does not switch

34

Positive distances remain positive

The system is marginally stable

35

•  Equilibrium points that are not on a switching surface are locally stable

•  If each node sees its nearest neighbour the system never switches. Therefore, the algorithm converges globally

36

•  This result was already found for deployment of agents on the boundary of an area (which cannot overtake each other “structurally”)

See Martinez, Bullo et al. TAC07

•  Suppose we remove one link to nearest neighbour

37

j and p do not see each other

The distance remains positive:

No switching •  Dynamics of j and p

•  The two nodes converge to coincident wakeup times

38

a = 0.2 a = 0.9

•  What if we remove two links?

39

•  Dynamics of nodes that do not see each other

Eigenvalues

•  If the two eigenvalues are positive, we can have switching but from some point in time the system does not switch any more

Positive eigenvalues

•  If one of the eigenvalues is negative, we can have an infinite switching number, but the two nodes eventually collapse onto each other behaving as a single node

Negative eigenvalue

•  Optimal solution computed using GLPK •  Distributed solution simulated as in [EWSN07] •  Experiments:

–  500x500 area, 15 to 50 nodes, density ~3 to ~9 •  Averaged over 100 topologies, and 10 random initializations

for each topology –  1000x1000 area, 200 nodes, similar density

•  Metrics: – Fixed #slots per epoch (duty-cycle), varied sensing

range – Fixed sensing range, varied #slots per epoch

Very few nodes overlap��� in space and time

The distributed solution does not know the node location, and cannot change the order of

nodes in a schedule

The schedule “saturates”

•  Performance is similar to the 500x500 case

•  Offline – Consider Multihop topologies and latency

constraints •  The cases reported above can be used

a guideline for a general convergence proof

•  Submitted to CDC09

•  Other directions – Different applications of the approach

(e.g., target tracking) 47