slide1 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Kinetic Heaps PowerPoint Presentation
Download Presentation
Kinetic Heaps

Loading in 2 Seconds...

play fullscreen
1 / 64

Kinetic Heaps - PowerPoint PPT Presentation


  • 216 Views
  • Uploaded on

Kinetic Heaps. K, Tarjan, and Tsioutsiouliklis . Outline. Broadcast Scheduling Parametric and Kinetic Heaps Broadcast Scheduling Using a Kinetic Heap The Computational Geometry View What is known Four New Structures Simple Heap Balanced Heap Fibonacci Heap

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Kinetic Heaps' - Lucy


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide1

Kinetic Heaps

K, Tarjan, and Tsioutsiouliklis

slide2

Outline

Broadcast Scheduling

Parametric and Kinetic Heaps

Broadcast Scheduling Using a Kinetic Heap

The Computational Geometry View

What is known

Four New Structures

Simple Heap

Balanced Heap

Fibonacci Heap

Incremental Heap

Open problems

slide3

Broadcast Scheduling

(Lecture by Mike Franklin

research papers)

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)

slide4

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

slide5

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?

_

slide6

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-min( x0)

delete item i : delete(i)

slide7

Kinetic Heap

A parametric heap such that successive x-values of find mins are non-decreasing.

(Think of x as time.)

xc = largest x in a find min so far (current time)

Additional operation:

decrease the key of an item i, replacing it by a key that is no larger for all x > xc : decrease-key(i,a,b)

slide8

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

slide9

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 at+b then increase-key(i, (a+1)t+(b-ts))

To broadcast an item at time ts we perform delete-max(ts)

and broadcast the item returned.

slide10

What is known about parametric and kinetic heaps?

A key is a line _ computational geometry

Equivalent problems:

maintain the lower 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

“kinetic” restriction = “sweep line” query constraint

slide11

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

slide12

Results II

Chan (1999)

Dynamic hulls and envelopes

O( log n) time per query

O(log1+en) time per update, amortized

Brodal and Jacob (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

slide13

Results III

Basch, Guibas, and Hershberger (1997)

“Kinetic” data structure paradigm

slide14

Simple heap (details)

A balanced binary tree, with items in the leaves

in left-right order by decreasing key slope.

The tree is a tournament on items by current key.

slide15

d

c

b

e

a

a

a

c

a

d

e

c

b

a

3

2

5

4

1

7

6

simple kinetic heaps cont
Simple kinetic heaps (Cont)

Add swap times at internal nodes

slide17

d

c

b

e

4.4

a

a

6

a

c

6.8

3

a

d

e

c

b

a

3

2

5

4

1

7

6

simple kinetic heaps cont1
Simple kinetic heaps (Cont)

Add minimum future swap time

slide19

d

c

b

e

4.4

a

3

a

6

6.8

a

c

3

6.8

3

3

a

d

e

c

b

a

3

2

5

4

1

7

6

simple kinetic heaps cont2
Simple kinetic heaps (Cont)

When we do a find-min if the current time moves forward, we act as follows:

Locate all nodes whose winner changes.

The paths from the root to those nodes form a subtree.

Update this subtree

slide21

d

c

b

e

4.4

a

3

a

6

6.8

a

c

3

6.8

3

3

a

d

e

c

b

a

3

2

5

4

1

7

6

slide22

d

c

b

e

4.4

a

3

a

6

6.8

a

c

3

6.8

3

3

a

d

e

c

b

a

3

2

5

4

1

7

6

slide23

d

c

b

e

4.4

a

3

a

6

6.8

a

c

3

6.8

3

b

d

e

c

b

a

3

3

2

2

5

5

4

4

1

1

7

7

6

6

slide24

d

c

b

e

4.4

a

3

a

20

6.8

b

c

20

6.8

3

b

d

e

c

b

a

3

2

5

4

1

7

6

slide25

d

c

b

e

5

b

5

a

20

6.8

b

c

20

6.8

3

b

d

e

c

b

a

3

2

5

4

1

7

6

slide26

d

c

b

e

5

b

5

a

20

6.8

b

c

20

6.8

3

b

d

e

c

b

a

3

2

5

4

1

7

6

slide27

d

c

b

e

5

b

5

a

20

6.8

b

c

20

6.8

3

b

d

e

c

b

a

3

2

5

4

1

7

6

slide28

d

c

b

e

5

20

e

a

20

6.8

b

e

20

3

b

d

e

c

b

a

3

2

5

4

1

7

6

slide29

d

c

b

e

5

20

e

a

20

6.8

b

e

20

3

b

d

e

c

b

a

3

2

5

4

1

7

6

simple kinetic heaps insert delete
Simple kinetic heaps – insert & delete

Use the regular mechanism of (say) red-black trees

slide31

f

3

2

5

4

1

7

6

d

c

b

e

5

20

e

a

20

6.8

b

e

20

3

b

d

e

c

b

a

slide32

3

2

5

4

1

7

6

d

c

b

e

20

5

e

a

f

20

6.8

b

e

20

3

-20

b

e

f

c

f

d

b

a

slide33

3

2

5

4

1

7

6

d

c

b

e

6.9

e

a

f

-10

6.8

f

e

3

-20

b

e

f

c

f

d

b

a

simple kinetic heaps analysis
Simple kinetic heaps (analysis)

Find-min takes O(1) time if we do not advance the current time.

Advancing the current time can be expensive on the worst-case

Amortization:

Assign O(log n) potential to each node whose swap time is in the future.

This potential pays for advancing the time.

So find-min takes O(1) amortized time.

Insert and delete take O(log2n) amortized time

slide36

c

d

b

e

a

d

e

c

b

a

3

2

5

4

1

7

6

looks like we use non linear space
Looks like we use non linear space ?

Each node keeps the chain of segments that are on its envelope but not on its parent envelope.

This makes the space linear.

slide38

c

d

b

e

a

d

e

c

b

a

3

2

5

4

1

7

6

analysis
Analysis

Using search trees to represent the envelopes sorted by slopes then:

Find-min takes O(log n) time

Insert and delete take O(log2 n) time: You split and concatenate O(log n) such envelopes.

balanced kinetic heaps
Balanced kinetic heaps

Plan: first we’ll do only deletions faster and then we’ll add insertions.

Our starting point is the previous data structure.

Def: The level of a line is the depth of the highest node where it is stored.

deletion only data structure
Deletion-only data structure

The level of a line is the depth of the highest node where it is stored.

slide42

c

d

b

e

a

d

d

e

c

b

a

3

2

5

4

1

7

6

deletion only data structure1
Deletion-only data structure

What happens when we delete a line ?

slide44

c

d

b

e

a

d

d

e

c

b

a

3

2

5

4

1

7

6

slide45

c

d

b

e

a

e

d

d

b

a

3

2

5

4

1

7

6

slide46

c

d

b

e

a

e

d

d

b

a

3

2

5

4

1

7

6

slide47

c

d

b

e

d

a

e

d

b

a

3

2

5

4

1

7

6

balanced kinetic heaps1
Balanced kinetic heaps

When we delete a line, lines only decrease their level.

slide49

3

2

5

4

1

7

6

slide50

3

2

5

4

1

7

6

analysis1
Analysis

Key idea: Implement the envelopes using finger search trees

How much time it takes to delete an element ?

O(log n) + log (# lines get on the replacement piece)

+ log (# lines get off the replacement piece)

If in all nodes # lines get on/off the replacement piece < log2n we are ok --- the delete takes O(log n loglog n) time

However it could be that # lines get on/off the replacement piece > log2n

analysis cont
Analysis (Cont)

If a line gets on the replacement piece it changes its level

Since the total number of level changes is nlog(n)

The number of chains of length > log2n is at most n/log(n)

So the total work in moving long chain is O(n) and can be charged to the initialization phase.

slide53

Summary so far

A better deletions only data structure

O(n) init. time and then O(log n loglog n) per delete.

O(1) find-min if we are kinetic.

Now we add insert.

balanced kinetic heaps finalle
Balanced kinetic heaps (finalle)

Balanced heaps (step 2):

Use a well known reduction by Bently and Saxe to add insertions

. . . . . . . . . . . . . .

Maintain a binary counter of deletion only data structures

balanced kinetic heaps2

. . . . . . . . . . . . . .

Balanced kinetic heaps

Delete : O(log n loglog n)

Insert : O(log n)

Find-min : O(log n) (kinetic)

slide56

Fibonacci heap (highlights)

Based one Fibonacci heaps with lazy linking.

We link only when it is safe

We get

O(log2 n) for delete

O(log n) for find-min and insert

O(log n) for decrease-key

fibonacci heaps fredman tarjan 84
Fibonacci heaps (Fredman & Tarjan 84)

Want to do decrease-key(x,h,) faster than delete+insert.

( in O(1) time.)

slide58

5

2

1

5

5

5

6

6

8

9

10

Heap ordered (Fibonacci) trees

linking

5

1

5

5

2

6

6

4

10

6

8

9

9

11

9

10

Linking

Operations are defined via a basic operation, called linking, of Fibonacci trees:

Produce a Fk from two Fk-1, keep heap order.

linking1
Linking

The basic operation is inserting a tree of rank r into Sr,

making the appropriate linking if needed.

This may cascade, but we have one tree less every time we do the linking

Insert(i) : Insert a new node containing i into S0

Decrease-key(i, a’.b’) : Decrease the key of i in the tree containing it making cascading cuts, link the resulting trees back into the structure.

analysis2
Analysis

Similar to the analysis of F-heaps

Multiply the potential by log n

slide63

Incremental heap (highlights)

Assumptions

insertion of i: ai = 1, increase key of i: ai :=ai + 1

Group items by key slope, each group is an ordinary Fibonacci heap

Move items among groups as key slopes change

(“displaced” items because entire subtrees are moved)

We get

find-max, insert : O(1)

The kth increase-key : O(log min{k,n})

delete : O(log n)

slide64

Open problems

Experiments: What is the best structure in practice?

Better bounds: kinetic heaps in ordinary F-heap bounds?

parametric heaps in O(log n) amortized time per operation?

Simple kinetic heaps via splay trees?