tight bounds for delay-sensitive aggregation

1

Tight Bounds for Delay-Sensitive Aggregation

Yvonne Anne Oswald

Stefan Schmid

Roger Wattenhofer

DistributedComputing

Group

LEA

2 Yvonne Anne Oswald @ PODC 2008

Introduction

Distributed Computing Trade-off:

examples: • gossiping• data gathering• organization theory

time complexity message complexityvs

Dijkstra Prize2008


Introduction

Particularly in sensor networks• limited energy (battery): transmission/reception expensive• goal: be up-to-date without much delay

time complexity message complexityvs

Distributed Computing Trade-off:


Model

• communication network: rooted spanning tree

root


Model

• communication network: rooted spanning tree• transmission cost c• nodes synchronized, time slotted• events occur at nodes (online, worst case)

Goal: forward events to root

Root

, be fast and energy-efficient!


Model

• communication network: rooted spanning tree• transmission cost c• nodes synchronized, time slotted• events occur at nodes (online, worst case)

Goal: forward events to root, be fast and energy-efficient!

minimize (c¢ # transmissions + delay cost)

• messages can be merged

Root

e.g.,1 per event pertime slot

until arrival at

root=> reduce # transmissions


Oblivious Algorithm

DEFINITION: OBLIVIOUS ALGORITHM

decision (transmit/wait) of node v depends on

• # events currently at node v

• when events arrived at node v

decision of node v does NOT depend on

• history (messages forwarded earlier)

• v ’s location in the aggregation network

perfect for sensor nodes!

I’ve got a memory like a

sieve and I don’t know

where I am..


Related Work and our Contributions

Trees • O(min(c,h))• oblivious (min(c,h))

Chains• O(min(c,h1/2))• oblivious (min(c, h1/2))

• WSN model

• log(e c(e))

improvement• higher lower bound

Link:• Dooly et al.[JACM01]: TCP,

offline OPTonline O(1)

• Karlin et al.[STOC01]online randomized e/(e-

1)

Tree:Khanna et al.[ICALP02]• model: edge e -> cost c(e)• distributed bounds

O(h log(e c(e)) (h1/2)


Algorithm AGG ([DGS01],[KNR01])

AGG: node v forwards msg m as soon as delay(m,t) ¸ c

Balance delay cost and total communication cost

ski rental on trees

Details

• m : message at v, containing |m| events

• delay(m,t) : delay associated with m at time t

no transmission:

delay(m,t+1) = delay (m,t) + |m|

transmission:

delay(m,t+1) = delay (m,t) + |m| - c


cost = 17+9

events

v1 v2

t = 1 1 0

t = 2 1 2

delay at v1 v2 v3

t = 1 1 0 0

t = 2 3 2 0

t = 3 0 4 2

t = 4 0 0 7

t = 5 0 0 0V1v2

V3

|m|=1delay = 1

|m| =2delay = 3

|m|=2delay=2

|m| =2delay = 0|m| =2

delay = 2

|m|=2delay=4

|m|=2delay=1

|m|=4delay=7

Example (4 nodes, 4 events, c=3)

root


Related Work and our Contributions

Trees • O(min(c,h))• oblivious (min(c,h))

Chains• O(min(c,h1/2))• oblivious (min(c, h1/2))

• WSN model

• log(e c(e))

improvement• higher lower bound

Link:• Dooly et al.[JACM01]: TCP,

offline OPTonline O(1)

• Karlin et al.[STOC01]online randomized e/(e-

1)

Tree:Khanna et al.[ICALP02]• model: edge e -> cost c(e)• distributed bounds

O(h log(e c(e)) (h1/2)


Lower Bound on Trees

Thm: any oblivious deterministic online algorithm ALG has a competitive ratio of at least (min(c,h)) on the tree.

…

root

t=1 events at nodes v1..vn/2-1

t=w messages leave vi

t=w+1 messages at nodes vn/2..vn-

1

…

ALG:

cost 2 (c+w)h2


Lower Bound on Trees

…

root

ALG: cost 2 (c+w)h2

OPT: cost 2 O(ch+h2)

=> ratio (min(c,h))

Thm: any oblivious deterministic online algorithm ALG has a competitive ratio of at least (min(c,h)) on the tree.


Upper Bound on Chains

…root

Thm: AGG has a competitive ratio of at most

O(min(c,h1/2)) on chains.

proof sketch• assume no messages merged: ratio O(h1/2)• include u merges at depth i:

cost reduction AGG (uci) cost reduction OPT O(uci)

• generalize for many merges at any depth: ratio O(h1/2)• combine with result from trees: ratio O(min(c,h1/2)

assume : #msgOPT = x h1/2 #msgAGG, x 2 (1)

=> costAGG 2 O(x h1/2 hc)

find sequence keeping costopt minimal=> msg size increases with t

yet no merges for AGG => costOPT 2 (xhc)

time difference ensures no merges

before i => bound for reduction cost


Teaser on Value-Sensitive Aggregation

What if urgency of delivery depends on value?

root knows vr(t), value at leaf vl(t)

cost := transmissions + t |vr(t) –vl(t)|

Results (2 nodes): • offline: dynamic programming O(#changes3)• online: competitive ratio 2 O(c/),

where smallest difference between values

Online AGG: forward at (t+1) if

last sent |vr(t) –vl(t)| ¸ c

consider intervalsbetween consecutive

transmissions


Summary

event aggregation• Tree: O(min(c,h))

oblivious (min(c,h))• Chain: O(min(c,h1/2))

oblivious (min(c, h1/2))

value-sensitive event aggregation• model• optimal algorithm for link O(# changes3)• online algorithm for link O(c/min.change)

ski rental on trees


The End!

Thank you!

Questions? Comments?

tight bounds for delay-sensitive aggregation

Documents

t c balance delay cost

t mtransmission

h oblivious minc

ratio minc

events delaym

h12 oblivious minc

node v decision of node

forward events