1. Equivalence Between Priority Queues and Sorting in External Memory
Zhewei Wei
Renmin University of China
MADALGO, Aarhus University
Ke Yi
The Hong Kong University of Science and Technology h

2. Priority Queue Maintain a set of keys
Support insertions, deletions and findmin (deletemin)
Fundamental data structure
Used as subroutines in greedy algorithms
Dijkstra’s single source shortest path algorithm
Prim’s minimum spanning tree algorithm

3. Sorting to Priority Queue
Priority queue can do sorting
Given N unsorted keys
Insert the keys to the priority queue
Perform N deletemin operations (find minimum and delete it)
If a priority queue can support insertion, deletion, findmin in S(N) time, then the sorting algorithm runs in O(NS(N)) time.

4. Priority Queue to Sorting
Thorup [2007]: sorting can do priority queue!
A sorting algorithm sorts N keys in N*S(N) time in RAM model
A priority queue support all operations in O(S(N)) time
Use sorting algorithm
as a black box
O(Nloglog N) sorting -> O(loglog N) priority queue
O(N loglog N ) sorting -> O( loglog N ) priority queue

5. The I/O Model [Aggarwal and Vitter 1988]
Size: M
Unlimited size
Size: B
Disk
Memory
CPU
Block
Complexity: # of block transfers (I/Os)
CPU computations and memory accesses are free

6. Cache-Oblivious Model
Size: ?
Unlimited size
Size: ?
Memory
Block
Disk
CPU
Optimal without knowledge of M and B
Optimal for all M and B

7. Sorting in the I/O Model
Sorting bound:
Upper bound: external merge sort
Lower bound: holds for comparison model or indivisibility assumption
Conjecture: lower bound holds for B not too small, even without indivisibility assumption
Sort(N)= Θ(N/B * logM/BN ) I/Os
Treat keys as atoms
N/B is the # of I/Os to make one pass of scanning, # of passes needed

8. Priority Queue in External Memory
I/O model
Buffer tree [Arge 1995]
M/B-ary heaps [Fadel et. al. 1999]
Array heaps[Brodal and Katajainen 1998]
O(1/B*logM/BN ) amortized cost
Tree-based: do not give any priority queue-to-sorting reduction

9. Priority Queue in External Memory
Cache-oblivious priority queue [Arge et.al. 2002]
Keys are moving around in loglog N levels
M>B2
O(1/B*logM/BN) with tall cache assumption
Reduction: Given an external sorting algorithm that sorts N keys in NS(N)/B I/Os, there is an external priority queue that support all operations in O(S(N)loglog N/B) amortized I/Os

10. Our Results S(N)/B for S(N) = Ω(2log*N), or M = Ω(B*log(c)N)
A sorting algorithm sorts N keys in N*S(N)/B time in the I/O model
Use sorting algorithm
as a black box
S(N) + S(B*log N) + S(B*loglog N)) + …
A priority queue support all operations in 1/B*Σi≥0S(Blog(i)(N/B)) amortized I/Os
S(N)/B for S(N) = Ω(2log*N), or M = Ω(B*log(c)N)
Other wise O((S(N) log*N) /B)
No new bounds for external priority queue
External priority queue lower bound -> external sorting lower bound

11. Outline How Thorup did it (on a high level)
How we extend it in external memory (on a high level)
Open problems

12. Thorup’s Reduction Word RAM model:
each word consists of w ≥ log N bits
constant number of registers, each with capacity for one word
Atomic heap [Han 2004]: support insertions, deletions, and predecessor queries in set of O(log2 N) size in constant time
So it serves as a priority queue that supports all operations in constant time

13. Thorup’s Reduction – O(S(N)*log N)
O(log N)
levels
N keys
N/2 keys
c keys
2c keys
N/4 keys
Invariant: Keys in higher level are larger than keys in Lower level …
First I will present a S(N)*log N reduction. Result-wise it does make any sense to consider such a reduction, since even if we can sort in linear time, this reduction only gives us a priority queue with cost log N, no better than binary tree
Keys in higher levels are larger than keys in lower levels
When a level gets unbalanced, that is, it expand or shrink by a constant factor
Rebalance it by taking its neighbouring levels, sort and merge them, and redistribute keys
Keep min in the head

14. Thorup’s Reduction – O(S(N)*log N)
N keys
N/2 keys
c keys
2c keys
N/4 keys
O(log N)
levels
Rebalance cost for level 2j: 2j*S(N)
# of sorts in N updates: N/2j
Amortized cost in level 2j: S(N)
log N levels …
Cost: O(S(N)*logN)

15. O(S(N)) Amortized cost
Thorup’s Reduction
N/log N
base sets
N/2log N
1 base sets
2 base sets
N/4log N
Base sets
log N
O(log N)
levels
Split/merge base sets: S(N) amortized
Rebalancing level 2j: 2jS(N)/log N
# of rebalance in N updates: N/2j
Amortized cost for level 2j: S(N)/log N …
The base sets are sorted relative to each other, but we don’t sort keys inside a base set. We use the maximum key in a base set to represent it.
O(S(N)) Amortized cost

16. O(S(N)) Amortized cost
Thorup’s Reduction
O(1) cost
N/log N
base sets
N/2log N
1 base sets
2 base sets
N/4log N
Base sets
log N
Split/merge base sets: S(N) amortized
Rebalancing level 2j: 2jS(N)/log N
# of rebalance in N updates: N/2j
Amortized cost for level 2j: S(N)/log N …
The base sets are sorted relative to each other, but we don’t sort keys inside a base set. We use the maximum key in a base set to represent it.
Atomic
heap
of size
log N
O(S(N)) Amortized cost

17. Thorup’s Reduction O(S(N)) Amortized cost … Atomic
Buffer size: N/log N
Buffer size: N/2log N
Buffer size: N/4log N
N/log N
base sets
N/2log N
base sets
O(S(N)) Amortized cost
N/4log N
Base sets …
Atomic
heap
of size
log N
Amortized Cost: O(S(N))
O(1) cost
2 base sets
Atomic heap of size
log N
1 base sets

18. Externalize Thorup’s Reduction
Where does B come in?
How to replace atomic heap?
How to handle deletions in external memory?

19. Where does B come in? B*log N … Buffer of size B*log N
Buffer size: N/log N
Buffer size: N/2log N
Buffer size: N/4log N
N/Blog N
base sets
N/2Blog N
1 base sets
2 base sets
N/4Blog N
Base sets
B*log N …
Buffer
of size
B*log N

20. I/O-efficient Flush Operation
Buffer size |R|
k substructures
Sort keys in buffer: O(R*S(R)/B)
Distribute keys to k substructures: O(R/B+k)
Total I/O cost: O(RS(N)/B + k)
If k =O(R/B), total flush cost is O(RS(N)/B), amortized cost is O(S(N)/B)

21. Amortized I/O cost for flushing level buffers: O(S(N)/B)
Where does B come in?
Base sets: 2j/(Blog N)
Buffer size: 2j/log N
B*log N …
Amortized I/O cost for flushing level buffers: O(S(N)/B)
If a level holds 2j keys
Largest buffer size: 2j/log N
Largest # of base sets: 2j/Blog N
Smallest base set (head) size: B*log N

22. Replacing Atomic Heap
R = B*log N
k = log N …
Buffer
of size
B*log N

23. Replacing Atomic Heap Amortized I/O cost: O(S(N)/B) …
Recursively build the structure in the head …
Buffer
of size
B*log N
Head of size O(Blog N)

24. Recursively Build Layers
O(log* N)
Layers
N keys
B*log (N/B) keys
cB keys
2^c*B keys
B*loglog(N/B) keys
Levels rebalancing
- Move base sets around
- Redistribute buffer
- S(N)/(Blog N) for one level
- S(N)/B for one layer
- S(N)log* N/B amortized I/O cost …
# of logs to take on N/B before it gets to constant,

25. Recursively Build Layers
O(log* N)
Layers
N keys
B*log (N/B) keys
cB keys
2^c*B keys
B*loglog(N/B) keys …
Layers Rebalancing
- Rebuild the first (last) level
- S(N)/B for one layer
- S (N)log* N/B amortized I/O cost

26. Recursively Build Layers
N keys
B*log (N/B) keys
cB keys
2^c*B keys
B*loglog(N/B) keys
O(log* N)
Layers …

27. Recursively Build Layers
R = B
k = log* N
N keys
B*log (N/B) keys
B*loglog(N/B) keys …
Memory
buffer
of size
O(B)
2^c*B keys
cB keys

28. Recursively Build Layers
Amortized cost: log* N/B
N keys
B*log (N/B) keys
B*loglog(N/B) keys …
I/O cost per update:
O(S(N)log* N/B)
Memory
buffer
of size
O(B)
2^c*B keys
cB keys

29. Delete x -> Insert (-, x)
Handle Deletions
Follow a pointer to perform deletion takes 1 I/O per deletion
Deleting signals:
Delete x -> Insert (-, x)
Perform actual deletion afterwards
Unlike buffer tree, we don’t have access to the “leaves”(base sets)
Invariant: Only process deleting signals in the head

30. Schedule Avoid repeated sorting If head or memory buffer unbalanced:
Flush stage: flush all overflowed buffers and rebalance all unbalanced base sets
Push stage: rebalance all overflowed layers and levels (expand)
Pull stage: deal with delete signals and rebalance all underflowed layers and levels (shrink)

31. Open problems Optimal reduction?
Priority queue that support insertions/deletions in O(1/B) I/O cost for set of size O(B*log(c) N)
New reduction framework
Better (than loglog N) reduction in Cache-oblivious model?
Hard to do I/O-efficient flushing and rebalancing without knowing B

32. Thank You!