Tracking

Murat Demirbas

SUNY Buffalo

A Pursuer-Evader Game for Sensor Networks

Murat Demirbas

Anish Arora

Mohamed Gouda

Pursuer-evader problem

• Evader is omniscient;Strategy of evader is unknown

• Pursuer can only see state of nearest node;Pursuer moves faster than evader ( ratio = f )

• Required is to design a program for nodes and pursuer so that pursuer can catch evader (despite the occurrence of faults)

Model

Connected graph of sensor nodes Transient faults; connectivity still maintained Maximal parallelism in node actions

Two approaches

• Evader-centric program

move is costly, find is for free sensor nodes communicate periodically with neighbors stabilizes and tracks faster

• Pursuer-centric program

find is costly, move is for free sensor nodes communicate with neighbors only upon request minimizes number of messages and energy efficient

• Hybrid program

find & move are both tunable

Outline

• Evader-centric program

• Pursuer-centric program

• Hybrid program

• Extensions

Evader-centric program

• Nodes collectively maintain a tracking tree

ts.j : latest timestamp that j knows about detection of evader p.j : parent of j in tree d.j : distance of j from evader

root is the node where the evader resides

{Evader resides at j} ---> p.j := j; ts.j :=clock.j; d.j :=0

every node sets its parent to be the nbr with maximum ts

ts.k > ts.j ---> p.j :=k ; ts.j := ts.(p.j); d.j:= d.(p.j)+1

• Find is for free: pursuer follows the tracking tree to its root

Evader-centric program (cont.)

• Tracking tree is dynamically rooted at the evader

• Parent of a node is closer to the evader

Evader-centric program (cont.)

• Tracking tree is dynamically rooted at the evader

• Parent of a node is closer to the evader

Evader-centric program (cont.)

• Tracking tree is dynamically rooted at the evader

• Parent of a node is closer to the evader

Evader-centric program (proof of stabilization)

• Tracking tree is rooted at the evader within D steps

soft-state stabilization

• The distance between pursuer and evader does not increase once the constructed tree includes the pursuer

• Starting from an arbitrary state pursuer catches evader in at most D+ 2D * f/(1-f) steps

Pursuer-centric program

• Move is for free: ts.j is maintained locally

{evader detected at j} ---> ts.j := clock.j

• Nodes communicate with nbrs only at the request of pursuer; pursuer is directed to nbring node with highest recorded time

{pursuer detected at j} ---> next.j :in {k | ts.k= max ts.nbr.j }; ts.j :=0

• Pursuer action is to move to next.j

pursuer does a random walk until it reaches a node that evader has visited

Pursuer-centric program (cont.)

• If the pursuer reaches a node j with ts.j>0, pursuer catches evader within N*f/(1-f) steps

Pursuer-centric program (stabilization)

• Since ts.j is reset to 0 when pursuer visits j, bad values disappear

• From random walk result, pursuer reaches a node j, ts.j >0 , within O( N2 * log N ) steps

• Then, pursuer catches evader within N*f/(1-f) steps

Hybrid program

Tracking tree is bounded to a depth R

Pursuer-centric program is executed at nodes outside tracking tree

Hybrid program (stabilization)

• Since tracking tree is bounded to a depth R, soft-state stabilization is not available for nodes outside tree

Cycles are detected and removed by counting to R

• Starting from an arbitrary state pursuer finds the tracking tree in at most O( (N-n)2 * log (N-n) ) steps

n : number of nodes in tracking tree

• Then, pursuer catches evader within R*f/(1-f) steps

• Hybrid program is tunable by assigning R appropriately

Outline

• Evader-centric program

• Pursuer-centric program

• Hybrid program

• Extensions

Extensions

• Asynchronous model :

Readily available

• Faster convergence :

Extended hybrid program

• Better scalability :

Hierarchical tracking program

Asynchronous model

• Evader-centric program

instead of ts.j maintain val.j

val.j denotes the number of detections of the evader that j is aware of

when j detects evader it increments val.j

tracking tree is rooted at evader in 2D steps

we have implemented the asynchronous version for June 2002 DARPA/NEST demo

• Pursuer-centric program

readily available

Extended hybrid program

• Pursuer-centric program can be modified query a radius Rp (instead of 1) s.t. R+ Rp = D

Self-Stabilizing Hierarchical Tracking Service for Sensor Networks

Murat Demirbas ,

Anish Arora ,

Tina Nolte ,

Nancy Lynch

STALK: Scalable tracking

• Maintain tracking structure

over fewer number of nodes

with accuracy inversely proportional to the distance from evader

communication cost of msgj,k= distance(j,k), delay= δ*distance(j,k)

nearby nodes (cheap to update) have recent & accurate info

distant nodes (expensive to update) have stale & rough info

• Local operations :

— Cost of move proportional to the distance the evader moves— Cost of find proportional to the distance from the evader— Cost of healing proportional to the size of the initial perturbation

• To this end we employ a hierarchical partitioning of the network

M. Demirbas, A. Arora, T. Nolte, and N. Lynch. A Hierarchy-based Fault-local Stabilizing Algorithm for Tracking in Sensor Networks. OPODIS, 2004.

Hierarchical clustering

R: dilation factor of clustering to determine size at higher levelsRadius at level L is ≈ RL

M. Demirbas, A. Arora, V. Mittal, and V. Kulathumani. Design and Analysis of a Fast Local Clustering Service for Wireless Sensor Networks. BroadNets 2004.

evader

Hierarchical tracking path

evaderevader

Grow action for building a tracking pathShrink action for cleaning unrooted paths

Local find

• Searching phase:

A find operation at j queries j’s neighbors & j’s clusterhead at

increasingly higher levels to find the tracking path

• Tracing phase:

Once path is found, operation follows the path to its root

evader find find find

Examples of find

A find for an evader d away incurs O(d) work/time cost

guaranteed to hit the tracking path at level logRd of hierarchy

A problem for move

evader dithering between cluster boundaries may lead to nonlocal updates

evader evaderevader

Local move

• Lateral links to avoid nonlocal updates

• When evader moves to new location j:

a new path is started from j

the new path checks neighbors at each level to see whether insertion of a lateral link is possible

• Restricts lateral links to 1 per level in order not to deteriorate the tracking path

otherwise find would not be local since it could not hit the path at level logRd for an evader d away

evader evader evader evaderevader evader evader

Examples of move

A move to distance d away incurs O(d*logRd) work/time cost

a level L pointer is updated at every i

L-1Ri distance; level L is updated d/i

L-1Ri times

update at L incurs O(RL) cost

Local healing

Local healing means work/time for recovery proportional to perturbation size & not the network size

In the presence of faults

• a grow can be mistakenly initiated; shrink should contain grow

• a shrink can be mistakenly initiated; grow should contain shrink

Fault-containment

• Give more priority to the action that has more recent info regarding the validity of the path

• A shrink or grow action is delayed for longer periods as the level of the node executing the action gets higher

j.grow-timer = g * R lvl(j)

j.shrink-timer = s * R lvl(j)

• Catching occurs within a constant number of levels

For g=5δ, s=11δ, b=11δR grow catches shrink in 2 levels:

logR ((bR–b+sR2–gR-δR)/(sR-gR-3δ))

shrink catches grow in 4 levels:

logR ((bR–b+sR+gR-2s+3δR)/(gR-s-δ))

Seamless tracking

• Fault-containment does not affect responsiveness

Total delaying up to l is a constant factor of communication delay up to l, δR l

• Concurrent move operations

move occurs before tracking path is updated a complete path is no longer possible; discontinuity in the path give a bound on evader speed to maintain a reachable path

• Concurrent find operations

when find reaches a dead-end, search phase is re-executed reachability condition guarantees that new path is nearby

• Cost of find & move unaffected

find