CSE 638: Advanced Algorithms. Lectures 18 & 19 ( Cache-efficient Searching and Sorting )

Transcription

1 CSE 638: Advanced Algorithms Lectures 18 & 19 ( Cache-efficient Searching and Sorting ) Rezaul A. Chowdhury Department of Computer Science SUNY Stony Brook Spring 2013

2 Searching ( Static B-Trees )

3 A Static Search Tree h ( n) = Θ log 2 degree: 2 A perfectly balanced binary search tree Static: no insertions or deletions Height of the tree, Θ log

4 A Static Search Tree a search path h ( n) = Θ log 2 A perfectly balanced binary search tree Static: no insertions or deletions Height of the tree, Θ log A search pathvisits O nodes, and incurs O O log I/Os

5 I/O-Efficient Static B-Trees h = Θ ( n) log B B + 1 Each node stores Bkeys, and has degree B+ 1 Height of the tree, Θ log

6 I/O-Efficient Static B-Trees a search path h = Θ ( n) log B B + 1 Each node stores Bkeys, and has degree B+ 1 Height of the tree, Θ log A search pathvisits O nodes, and incurs O O log I/Os

7 Cache-Oblivious Static B-Trees?

8 van Emde Boas Layout h a binary search tree

9 van Emde Boas Layout A h / 2 h B 1 B k h / 2 a binary search tree A B 1 B 2 B k If the tree contains nodes, each subtreecontains Θ 2 / Θ nodes, and Θ.

10 van Emde Boas Layout A h / 2 h B 1 B k h / 2 A B 1 B 2 a binary search tree B k Recursive Subdivision If the tree contains nodes, each subtreecontains Θ 2 / Θ nodes, and Θ.

11 van Emde Boas Layout A h / 2 h B 1 B k h / 2 A B 1 B 2 a binary search tree B k Recursive Subdivision If the tree contains nodes, each subtreecontains Θ 2 / Θ nodes, and Θ.

12 van Emde Boas Layout A h / 2 h B 1 B k h / 2 A B 1 B 2 a binary search tree B k Recursive Subdivision If the tree contains nodes, each subtreecontains Θ 2 / Θ nodes, and Θ.

13 van Emde Boas Layout A h / 2 h B 1 B k h / 2 A B 1 B 2 a binary search tree B k Recursive Subdivision If the tree contains nodes, each subtreecontains Θ 2 / Θ nodes, and Θ.

14 I/O-Complexity of a Search The height of the tree is log Each has height between log & log. Each spans at most 2 blocks of size.

15 I/O-Complexity of a Search a search path The height of the tree is log Each has height between log & log. Each spans at most 2 blocks of size. p= number of s visited by a search path Then log, and 2log The number of blocks transferred is 22log 4log

16 Sorting ( Mergesort )

17 Merge Sort Merge-Sort ( A, p, r ) { sort the elements in A[ p r ] } 1. if p < r then 2. q ( p + r ) / 2 3. Merge-Sort ( A, p, q ) 4. Merge-Sort ( A, q + 1, r ) 5. Merge ( A, p, q, r )

18 Merging k Sorted Sequences 2sorted sequences,,, stored in external memory for 1 is the length of the merged sequence ( initially empty ) will be stored in external memory Cache must be large enough to store one block from each one block from Thus 1

19 Merging k Sorted Sequences Let B i be the cache block associated with, and let Bbe the block associated with ( initially all empty ) Whenever a B i is empty fill it up with the next block from Keep transferring the next smallest element among all B i sto B Whenever B becomes full, empty it by appending it to In the Ideal Cache Modelthe block emptying and replacements will happen automatically cache-oblivious merging I/O Complexity Reading : #block transfers 2 Writing : #block transfers 1 Total #block transfers 1 2 O

20 Cache-Oblivious 2-Way Merge Sort Merge-Sort ( A, p, r ) { sort the elements in A[ p r ] } 1. if p < r then 2. q ( p + r ) / 2 3. Merge-Sort ( A, p, q ) 4. Merge-Sort ( A, q + 1, r ) 5. Merge ( A, p, q, r ) I/O Complexity: Ο 1,, 2 2 Ο 1,. Ο log How to improve this bound?

21 Cache-Oblivious k-way Merge Sort I/O Complexity: Ο 1,, Ο,. Ο log How large can be? Recall that for -way merging, we must ensure 1 1

22 Cache-Aware -Way Merge Sort I/O Complexity: Ο 1,, Ο,. Ο log Using 1, we get: Ο 1 log Ο log

23 Sorting ( Funnelsort )

24 k-merger ( k-funnel ) linking buffers ( each of size 2 ) 2sorted input sequences one merged output sequence -merger ( one ) Memory layout of a -merger: -mergers ( of them )

25 k-merger ( k-funnel ) Space usage of a -merger: Θ 1, 2, 1 Θ,. Θ A -merger occupies Θ contiguous locations.

26 k-merger ( k-funnel ) Each invocation of a -merger produces a sorted sequence of length incurs Ο 1 log cache misses provided Ω

27 k-merger ( k-funnel ) Cache-complexity: Ο 1,, 2 2 Θ,. Ο log, provided Ω

28 k-merger ( k-funnel ) : Ο 1 Let be #items extracted the -thinput queue. Then Ο. Since and Ω, at least for the input buffers. Ω cache blocks are available Hence, #cache-misses for accessing the input queues (assuming circular buffers) Ο 1 Ο

29 k-merger ( k-funnel ) : Ο 1 #cache-misses for accessing the input queues Ο #cache-misses for writing the output queue Ο 1 #cache-misses for touching the internal data structures Ο 1 Hence, total #cache-misses Ο 1

30 k-merger ( k-funnel ) : 2 2 Θ Each call to outputs items. So, #times merger is called Each call to an puts items into. Since items are output, and the buffer space is 2 2,#times the s are called 2 Before each call to, the merger must check each for emptiness, and thus incurring Ο cache-misses. So, #such cache-misses Ο Ο

31 Funnelsort Split the input sequence of length into contiguous subsequences,,, Recursively sort each subsequence of length each Merge the sorted subsequences using a -merger Cache-complexity: Ο 1,,,. Ο 1,, Ο log,. Ο 1 log

32 Sorting ( Distribution Sort )

33 Cache-Oblivious Distribution Sort Step 1: Partition, and recursively sort partitions. Step 2: Distribute partitions into buckets. Step 3: Recursively sort buckets.

34 Step 1: Partition & Recursively Sort Partitions Partitioned Recursively Sorted n sub-arrays n elements Order: Figure Source: Adapted from figures drawn by Piyush Kumar (2003), FSU

35 Step 2: Distribute to Buckets Recursively Sorted Distributed to Buckets A : 1 A : 2 A : 3 B : 1 B : 2 B 3 : A n : B q : n elements Number of buckets, Number of elements in 2 max min Figure Source: Adapted from figures drawn by Piyush Kumar (2003), FSU

36 Step 3: Recursively Sort Buckets B : 1 B : 2 B 3 : Recursively Sort Each Bucket B q : Done! Figure Source: Adapted from figures drawn by Piyush Kumar (2003), FSU

37 Distribution Sort Step 1: Partition, and recursively sort partitions. Step 2: Distribute partitions into buckets. Step 3: Recursively sort buckets.

38 Distribution Sort Step 1: Partition, and recursively sort partitions. Step 2: Distribute partitions into buckets. Step 3: Recursively sort buckets.

39 The Distribution Step Sorted Partitions Buckets A 1 A 2 A 3 B 1 B 2 B 3 A n We can take the partitions one by one, and distribute all elements of current partition to buckets Has very poorcache performance: upto Θ Θ cache-misses Figure Source: Adapted from figures drawn by Piyush Kumar (2003), FSU B q

40 Sorted Partitions Recursive Distribution Buckets A 1 A 2 A 3 B 1 B 2 B 3 A n B n [ A i,, A i + m 1 ] [ B j,, B j + m 1 ] Distribute (i, j, m ) 1. if m = 1 thencopy elements from A i to B j 2. else 3. Distribute ( i, j, m / 2 ) 4. Distribute ( i + m / 2, j, m / 2 ) 5. Distribute ( i, j + m / 2, m / 2 ) 6. Distribute ( i + m / 2, j + m / 2, m / 2 ) may need to split to maintain 2

41 Recursive Distribution Distribute (i, j, m ) 1. if m = 1 thencopy elements from A i to B j 2. else 3. Distribute ( i, j, m / 2 ) 4. Distribute ( i+ m / 2, j, m / 2 ) 5. Distribute ( i, j + m / 2, m / 2 ) 6. Distribute ( i + m / 2, j + m / 2, m / 2 ) ignore the cost of splits for the time being Let, denote the cache misses incurred by Distribute ( i, j, m) that copies elements from mpartitions to buckets. Then Ο,,, 2,,,. Ο, Ο

42 Recursive Distribution Distribute (i, j, m ) 1. if m = 1 thencopy elements from A i to B j 2. else 3. Distribute ( i, j, m / 2 ) 4. Distribute ( i+ m / 2, j, m / 2 ) 5. Distribute ( i, j + m / 2, m / 2 ) 6. Distribute ( i + m / 2, j + m / 2, m / 2 ) ignore the cost of splits for the time being

43 Recursive Distribution Distribute (i, j, m ) 1. if m = 1 thencopy elements from A i to B j 2. else 3. Distribute ( i, j, m / 2 ) 4. Distribute ( i+ m / 2, j, m / 2 ) 5. Distribute ( i, j + m / 2, m / 2 ) 6. Distribute ( i + m / 2, j + m / 2, m / 2 ) #cache-misses incurred by all splits Ο Ο Cache-complexity of Distribute( 1,1, ) is, Ο Ο

44 Cache-Complexity of Distribution Sort Step 1:Partition into sub-arrays containing elements each and sort the sub-arrays recursively. Step 2:Distribute sub-arrays into buckets,,,. Step 3: Recursively sort the buckets. Cache-complexity of Distribution Sort: Ο 1,, Ο 1,. Ο 1 log, Ω