Kinetic data structures

1
Kinetic data structures
2
Goal

• Maintain a configuration of moving objects
• Each object has a posted flight plan (this is
  essentially a well behaved function of time)

3
Example 1
Maintain the closest pair among points moving in
the plane
4
Example 2
Maintain the convex hull of points moving in the
plane
5
Elements of a KDS

• An event queue (A heap of discrete times)
• The event queue will contains all times where the
  combinatorial structure of the configuration may
  change
• Like a sweep of the time dimension

6
Example 3
Maintain the topmost among points moving along
the y-axis
7
Look at the ty-plane
y
t
8
We are interested in the upper envelope
y
t
9
Solution

• Calculate this upper envelope !
• Sharir, Hart, Agarwal and others
• The complexity of the envelope is close to linear
  if any pair of function intersect at most s times
• Can compute it in O(n log(n)) time

10
Problem

• If we would like to change a trajectory then we
  need to recompute te envelope
• That takes O(nlog(n)) time
• We want to be able to change a trajectory faster

11
Another solution

• Maintain the points sorted
• For every pair of points put in the event queue
  the time when they switch order

12
Example 3
13
Problem

• We process O(n2) events
• But the configuration changes only linear (or
  close to linear) number of times

14
So what do we want from a KDS to be good

• You maintain a set of certificates that as long
  as they are valid the configuration does not
  change.
• Want The number of times a certificate fails
  (internal events) to be small relative to the
  number of times the configuration changes
  (external events)

? Efficient
15
So what do we want from a KDS to be good (Cont)

• Process a certificate failure fast

? responsive

• Small space

? compact

• Object participates in a small of cetificates
  (can change trajectories easily)

? local
16
Dynamic KDS

• Want also to be able to insert and delete objects
  efficiently

17
So what would be a good solution for this problem
?
Maintain the topmost among points moving along
the y-axis
18
A tournament tree
d
c
b
a
c
a
d
b
19
A tournament tree
d
c
b
d
a
c
d
c
a
d
b
20
A tournament tree
d
c
b
d
a
c
d
c
a
d
b
For each internal node maintain in an event queue
the next time where the children flip order
21
Processing of an event Replace the winner and
replace O(log(n)) events in the event queue
Takes O(log2(n)) time ? responsive
Linear space ? compact
Each point participates in O(log n) events ? local
22
d
r
c
2
1
d
c
a
d
b
What is the total of events ?
Events at r correpond to changes at the upper
envelope, lets say there are O(n)
Events at 1 correponds to change at the upper
envelope of b d ? O(n/2)
In total we get O(nlog(n)) events ? efficient
23
d
r
c
2
1
d
c
a
d
b
Handeling insertions/deletions ?
Use some kind of a balanced binary search tree
Each node charges its events to the upper
envelope of its subtree
Without rotations we get O(nlog(n)) events
24
d
r
c
2
1
d
c
a
d
b
Handeling insertions/deletions
Because of rotations each point participates in
more than O(log n) envelopes
Use a BBalpha tree ? think of each pair of
nodes participating in a rotation as new nodes,
then the total size of envelopes corresponding to
new nodes is O(nlog(n))
25
y
d
r
c
2
1
d
t
c
a
d
b
Well focus now a bit more at the case where the
points move with constant velocity
Can redefine the problem so we do not insist on
maintaining the upper envelope explicitly at all
times
26
Parametic Heap
A collection of items, each with an associated
key.
key (i) ai x bi ai,, bi reals, x a
real-valued parameter ai slope, bi constant
Operations make an empty heap. insert item i
with key ai x bi into the heap
insert(i,ai,bi) find an item i of minimum key
for x x0 find-max( x0) delete item i
delete(i)
27
Kinetic Heap
A parametric heap such that successive x-values
of find maxs are non-decreasing. (Think of x as
time.) xc largest x in a find max so far
(current time) Additional operation increase
the key of an item i, replacing it by a key that
is no larger for all x gt xc
increase-key(i,a,b)
28
What is known about parametric and kinetic heaps?
Equivalent problems maintain the upper
envelope of a collection of lines in 2D
projective duality maintain the
convex hull of a set of points in 2D under
insertion and deletion
29
Results I
Overmars and Van Leeuwen (1981) O( log n) time
per query O(log2n) time per update,
worst-case Chazelle (1985), Hershberger and
Suri (1992) (deletions only) O( log
n) time per query, worst-case O(n log n) for n
deletions
30
Results II
Chan (1999) Dynamic hulls and envelopes
O( log n) time per query O(log1en) time
per update, amortized Brodal and Jacob (2000),
Kaplan, Tarjan, Tsioutsiouliklis (2000)
O( log n) time per query O( log n log log log
n) time per insert, O( log n log log n)
timer per delete, amortized
31
Results III
Basch, Guibas, and Hershberger (1997) Kinetic
data structure paradigm
32
Broadcast Scheduling
requests
Server many data items
Users
Broadcast channel (single-item)
One server, many possible items to send (say, all
the same length) One broadcast channel. Users
submit requests for items. Goal Satisfy users
as well as possible, making decisions
on-line. (say, minimize sum of waiting times)
33
Scheduling policies
Greedy Longest Wait first (LWF) Send item with
largest sum of waiting times. R x W send item
with largest ( requests x longest waiting time)
(vs. number of requests or longest single waiting
time)
-1
-4
34
Results of Mike Franklin and others LWF
schedules well in practice (in simulations) but
too expensive (linear-time) This claim used to
justify approximations to R x W, still
linear-time but with a smaller (parameterized)
constant.
34
35
Questions (for an algorithm guy or gal) LWF does
well compared to what?
Open question 1
Try a competitive analysis
_
Can we improve the cost of LWF?
Will talk about this
What data structure?
_
36
Broadcast scheduling via kinetic heap
Need a max-heap (replace find min by find max,
decrease key by increase key,
etc) Can implement LWF or
R x W or any similar policy Broadcast decision
is find max plus delete Request is insert (if
first) or increase key (if not) Only find max
need be real-time, other ops can proceed
concurrently with broadcasting Slopes are
integers that count requests
37
Broadcast scheduling via kinetic heap (Cont.)
LWF Suppose a request for item i arrives at
time ts If i is inactive then insert(i, t-ts) If
i is active with key atb then increase-key(i,
(a1)t(b-ts)) To broadcast an item at time ts
we perform delete-max(ts) and broadcast the item
returned.