Recap: Prefix Sums. Given A: set of n integers Find B: prefix sums 1 / 86

Transcription

1 Recap: Prefix Sums Given : set of n integers Find B: prefix sums : B: / 86

2 Recap: Parallel Prefix Sums Recursive algorithm Recursively computes sums Use partial sums to get prefix sums T(n) = O(log n) W(n) = O(n) Hard to get intuition Iterative algorithm easier to grasp? 2 / 86

3 Iterative prefix sum 2 phases: up-sweep, down-sweep Up-sweep pseudocode: 3 / 86

4 Up-sweep phase B[0] / 86

5 Up-sweep phase B[1] B[0] / 86

6 Up-sweep phase B[2] B[1] B[0] / 86

7 Up-sweep phase B[3] B[2] B[1] B[0] / 86

8 Up-sweep phase B[3] B[2] B[1] B[0] / 86

9 Up-sweep phase B[3] B[2] B[1] B[0] / 86

10 Up-sweep phase B[3] 30 B[2] B[1] B[0] / 86

11 Down-sweep phase 11 / 86

12 Down-sweep phase C[3] 0 B[2] B[1] B[0] / 86

13 Down-sweep phase C[3] 0 B[2] B[1] B[0] / 86

14 Down-sweep phase C[3] 0 B[2] B[1] B[0] / 86

15 Down-sweep phase C[3] 0 C[2] 0 12 B[1] B[0] / 86

16 Down-sweep phase C[3] 0 C[2] 0 12 B[1] B[0] / 86

17 Down-sweep phase C[3] 0 C[2] 0 12 C[1] B[0] / 86

18 Down-sweep phase C[3] 0 C[2] 0 12 C[1] B[0] / 86

19 Down-sweep phase C[3] 0 C[2] 0 12 C[1] C[0] / 86

20 Down-sweep phase C[0] / 86

21 Down-sweep phase C[0] / 86

22 pplications of prefix sums More useful than it seems: Create an array of 1s and 0s Prefix sums gives # of 1s up to each point Used to separate an array into 2 Using almost any criteria! Examples: separate array into upper-case and lower-case letters separate array into numbers >x and <x 22 / 86

23 Example: string separation Separate array into lower-case and upper-case: a P r e R E c F I o X o S U l M S 23 / 86

24 Example: string separation Create bitstring B: 1 if upper-case, 0 otherwise a P r e R E c F I o X o S U l M S 24 / 86

25 Example: string separation Create bitstring B: 1 if upper-case, 0 otherwise a P r e R E c F I o X o S U l M S B Time/work to do this in parallel? 25 / 86

26 Example: string separation Create bitstring B: 1 if upper-case, 0 otherwise a P r e R E c F I o X o S U l M S B Time/work to do this in parallel? W(n) = O(n) T(n) = O(1) 26 / 86

27 Example: string separation Perform prefix sums on B a P r e R E c F I o X o S U l M S B / 86

28 Example: string separation Perform prefix sums on B a P r e R E c F I o X o S U l M S B What is B[i]? 28 / 86

29 Example: string separation Perform prefix sums on B a P r e R E c F I o X o S U l M S B What is B[i]? The number of capital letters with index i 29 / 86

30 Example: string separation Copy capital letters into C a P r e R E c F I o X o S U l M S B C How can we use B to write only capitals into C? 30 / 86

31 Example: string separation Copy capital letters into C a P r e R E c F I o X o S U l M S B C How can we use B to write only capitals into C? B[i] is the index of each capital in C! 31 / 86

32 Example: string separation Copy capital letters into C a P r e R E c F I o X o S U l M S B C P R E F I X S U M S How can we use B to write only capitals into C? B[i] is the index of each capital in C! 32 / 86

33 Example: string separation Create B 1 for lower-case, 0 otherwise a P r e R E c F I o X o S U l M S B C P R E F I X S U M S / 86

34 Example: string separation Prefix sums on B a P r e R E c F I o X o S U l M S B C P R E F I X S U M S / 86

35 Example: string separation Copy lower-case into the rest of C a P r e R E c F I o X o S U l M S B C P R E F I X S U M S / 86

36 Example: string separation Copy lower-case into the rest of C a P r e R E c F I o X o S U l M S B C P R E F I X S U M S a r e c o o l [i] = C[j] where j = B[n] + B [i] = 10 + B [i] 36 / 86

37 Example: string separation Create B and B Prefix sums Copy into C Total algorithm 37 / 86

38 Example: string separation Create B and B Prefix sums Copy into C Total algorithm 38 / 86

39 Example: string separation Create B and B Prefix sums Copy into C Total algorithm 39 / 86

40 Quicksort Review Quicksort is a popular sorting algorithm Works in-place O(n 2 ) worst-case BUT O(n log n) expected Each recursive call: Find pivot Partition around pivot 40 / 86

41 Sequential Quicksort 41 / 86

42 Select pivot pivot 42 / 86

43 Select pivot / 86

44 Partition elements / 86

45 Partition elements part 45 / 86

46 Partition elements i part 46 / 86

47 Partition elements FLSE i part 47 / 86

48 Partition elements TRUE i part 48 / 86

49 Partition elements TRUE i part 49 / 86

50 Partition elements FLSE i part 50 / 86

51 Partition elements TRUE i part 51 / 86

52 Partition elements TRUE i part 52 / 86

53 Partition elements FLSE i part 53 / 86

54 Partition elements FLSE i part 54 / 86

55 Partition elements TRUE i part 55 / 86

56 Partition elements TRUE i part 56 / 86

57 Recurse part 57 / 86

58 Recursion sorts sublists part 58 / 86

59 How can we parallelize? O(1)??? Parallel calls 59 / 86

60 Parallel partition Separate all elements pivot pivot How can we do this in parallel? 60 / 86

61 Parallel partition Separate all elements pivot pivot How can we do this in parallel? Prefix sums! 61 / 86

62 Parallel partition Create B[i] by comparing [i] to pivot 1 if [i] [0] 0 otherwise B / 86

63 Parallel partition Prefix sums on B B / 86

64 Parallel partition Write each [i] [0] to array C C[B[i]] = [i] B C / 86

65 Parallel partition Create B as opposite of B B [i] = 1 if [i] > [0] B [i] = 0 otherwise B C / 86

66 Parallel partition Prefix sums on B B C / 86

67 Parallel partition Write remaining elements to C C[B[n-1] + B [i]] = [i] B C / 86

68 Parallel quicksort analysis Each recursive call performs prefix sum Worst-case, pivot is always min or max: If we assume good pivot is chosen: 68 / 86

69 Parallel quicksort analysis ssuming a good pivot choice: 69 / 86

70 Issues with parallel quicksort Have to copy to C => not in-place O(n) extra space needed O(log2 n) average parallel runtime Recursive definition Difficult to make iterative Perform many small prefix-sums Performance overhead 70 / 86

71 Iterative solution What if we can combine recursive calls One iteration for each level Separate recursive calls on partitions: P 0 P 1 P 2 P / 86

72 Iterative solution Know size of partition i = P i Find a pivot for each partition P 0 P 1 P 2 P / 86

73 Iterative solution Know size of partition i = P i Find a pivot for each partition Move pivots to front P 0 P 1 P 2 P / 86

74 Iterative solution Know size of partition i = P i Find a pivot for each partition Move pivots to front Compute B Compare each to the pivot in its partition P 0 P 1 P 2 P B / 86

75 Iterative solution Want prefix sum within each partition: Segmented prefix sums Each partition is a separate segment P 0 P 1 P 2 P B / 86

76 Iterative solution Want prefix sum within each partition: Segmented prefix sums Each partition is a separate segment Can combine into 1 operation... P 0 P 1 P 2 P B / 86

77 Segmented prefix sums Input array and flag bits F 1 if start of new segment 0 otherwise Prefix sums, except sum resets when F[i]= F / 86

78 Segmented prefix sums Input array and flag bits F 1 if start of new segment 0 otherwise Prefix sums, except sum resets when F[i]= F C / 86

79 Partition with segments Create F with partition boundaries P 0 P 1 P 2 P B F / 86

80 Partition with segments Create F with partition boundaries Perform segmented prefix sums on B and F P 0 P 1 P 2 P B F / 86

81 Partition with segments Create F with partition boundaries Perform segmented prefix sums on B and F Copy [i] into C[B[i]] (plus partition offsets) P 0 P 1 P 2 P B C / 86

82 Partition with segments Repeat for > pivots: Build B P 0 P 1 P 2 P B C / 86

83 Partition with segments Repeat for > pivots: Segmented prefix sums on B P 0 P 1 P 2 P B C / 86

84 Partition with segments Repeat for > pivots: Copy remaining values into C P 0 P 1 P 2 P B C / 86

85 Partition with segments Ready for next iteration... P 0 P 1 P 2 P B C / 86

86 Notes about Iterative quicksort Need to keep track of partition offsets, etc. Still need to pick good pivots Same runtime as recursive Easier to optimize Unroll loops, etc. Less overhead (on most architectures) 86 / 86