Upcoming SlideShare
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Standard text messaging rates apply

# Sortingnetworks

793
views

Published on

Published in: Technology, Sports

0 Likes
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

• Be the first to like this

Views
Total Views
793
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
28
0
Likes
0
Embeds 0
No embeds

No notes for slide
• ### Transcript

• 1. SORTING NETWORKS Presented by: Vikram S. Choudhary, JECRC, Jodhpur.
• 2. Overview
• Sorting Network Components
• Comparison Networks
• Comparator
• Zero-one Principle
• Bitonic Sorting Network
• Half-Cleaner
• Bitonic Sorter
• Merging Network
• Sorting Network
• 3. Comparison Networks
• Sorting networks are Comparison Networks that always sort their inputs
• Comparison Network composed of:
• wires
• comparators
• Wires: transmits values from place to place
• Comparators: two inputs  two outputs
• 4. Comparison Networks
• Comparators:
• inputs: x and y
• outputs: x’ and y’
• x’ = min(x, y)
• y’ = max(x, y)
• input output
• x   x’ = min(x, y)
• y   y’ = max(x, y)
• x ------------------------------ x’ = min(x, y)
• y ------------------------------ y’ = max(x, y)
comparator
• 5. Comparison Networks
• Comparators
• n input wires: a 1 , a 2 , …, a n
• input sequence: < a 1 , a 2 , …, a n >
• n output wires: b 1 , b 2 , …, b n
• output sequence: <b 1 , b 2 , …, b n >
• Properties:
• requirement: graph is acyclic
• output produced only when input is available
• comparators process in parallel if input is available
• 6. Comparison Networks
• comparators
• a1 9 ----------------------------------------- b1
• a2 5 ----------------------------------------- b2
• a3 2 ----------------------------------------- b3
• a4 6 ----------------------------------------- b4
• values
A B C D E
• 7. Comparison Networks
• outputs
• a1 9 ----------------------------------------- 2 b1
• a2 5 ----------------------------------------- 5 b2
• a3 2 ----------------------------------------- 6 b3
• a4 6 ----------------------------------------- 9 b4
• depth: 1 1 2 2 3
• depth starts at 0
• input wires depth: d x and d y
• output wires depth: max(d x , d y ) + 1
A B C D E 5 9 2 6 2 6 5 9
• 8. Comparison Networks
• Sorting Network is a Comparison Network where the output is sorted
• output sequence is monotonically increasing
• (b 1 <= b 2 …<= b n ) for every input sequence
• Not all Comparison Networks are Sorting Networks
• Comparison Network is like a procedure in that it specifies how comparisons are to occur
• 9. Zero-One Principle
• If a Sorting Network works correctly when each input is drawn from the set {0, 1}, then it works correctly on arbitrary input numbers
• (integers, reals, or values from any linearly sorted set)
• 10. Zero-One Principle
• Lemma 27.1
• If a Comparison Network transforms the input sequence a = <a 1 , a 2 , …, a n > into the output sequence b = <b 1 , b 2 , …, b n >, then for any monotonically increasing function f, the network transforms the input sequence:
• f(a) = <f(a 1 ), f(a 2 ), …, f(a n )>
• into the output sequence:
• f(b) = <f(b 1 ), f(b 2 ), …, f(b n )>
• 11. Zero-One Principle
• Proof:
• prove claim: if f is a monotonically increasing function, then a single comparator with inputs f(x) and f(y) produces output f(min(x, y)) and f(max(x, y))
• f(x) ------------------------------ min(f(x), f(y))
• f(y) ------------------------------ max(f(x), f(y))
• min(f(x), f(y)) = f(min(x, y))
• max(f(x), f(y)) = f(max(x, y))
• 12. Zero-One Principle
• outputs
• f(x) = ceiling(x/2)
• a1 9 ----------------------------------------- 1 b1
• a2 5 ----------------------------------------- 3 b2
• a3 2 ----------------------------------------- 3 b3
• a4 6 ----------------------------------------- 5 b4
A B C D E 3 5 1 3 1 3 3 5
• 13. Zero-One Principle
• Theorem 27.2 (Zero-One Principle)
• If a Comparison Network with n inputs sorts all 2 n possible sequences of 0’s and 1’s correctly, then it sorts all sequences of arbitrary numbers correctly.
• 14. Zero-One Principle
• Proof:
• Suppose that the network sorts all zero-one sequences, but there exists a sequence of arbitrary numbers that the network does not sort:
• <a 1 , a 2 , …, a n > contains elements a i and a j
• where a i < a j
• but the network places a j before a i in the output sequence
• 15. Zero-One Principle
• Define monotonically increasing function f:
• f(x) = { 0 if x <= a i ,
• 1 if x > a i .
• a j is placed before a i in the output sequence
• f(a j ) placed before f(a i )
• when input is <a 1 , a 2 , …, a n >
• since f(a j ) = 1 and f(a i ) = 0, from above we have a contradiction
• 16. Bitonic Sorting Network
• Bitonic Sequence:
• a sequence that monotonically increases and then decreases, or can be circularly shifted to become monotonically increasing and then monotonically decreasing
• examples:
• <1, 4, 6, 8, 3, 2>, < 6, 9, 4, 2, 3, 5>, and
• <9, 8, 3, 2, 4, 6>
• zero-one: 0 i 1 j 0 k or 1 i 0 j 1 k when i,j,k >= 0
• 17. Bitonic Sorting Network
• Half-Cleaner
• a bitonic sorter is composed of several stages, each of which is called a half-cleaner
• half-cleaner is a Comparison Network of depth 1
• line i compared with i + n/2 for i = 1, 2,…, n/2
• assume that n is even
• 18. Bitonic Sorting Network
• Example: Half-Cleaner[8] all 1’s or 0’s
• 0 ---------------------------------- 0
• 0 ---------------------------------- 0 bitonic
• 1 ---------------------------------- 0 clean
• bitonic 1 ---------------------------------- 0 ________
• 1 ---------------------------------- 1
• 0 ---------------------------------- 0 bitonic
• 0 ---------------------------------- 1
• 0 ---------------------------------- 1
• 19. Bitonic Sorting Network
• Lemma 27.3
• If the input to a half-cleaner is a bitonic sequence of 0’s and 1’s, then the output satisfies the following properties:
• both the top half and the bottom half are bitonic
• every element in the top half is at least as small as every element in the bottom half
• at least one half is clean (either all 0’s or 1’s)
• 20. Bitonic Sorting Network
• Proof:
• the Comparison Network Half-Cleaner[n] compares inputs i and i + n/2 for i = 1, 2, … n/2
• suppose input is of the form:
• 00…011…100…0
• there are 3 possible cases for the n/2 midpoint to fall
• and the situation where the midpoint falls in a block of 1’s is separated into 2 cases
• So 4 cases in total
• 21. Bitonic Sorting Network
• Cases:
• bitonic
• n/2
• bitonic
• n/2
0 1 0 0 1 0 0 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 0 0 1 0 top top top top bottom bottom bottom bottom bitonic clean bitonic clean bitonic bitonic
• 22. Bitonic Sorting Network
• Cases:
• bitonic
• n/2
• bitonic
• n/2
0 0 0 1 0 0 1 0 1 0 0 0 0 1 0 1 1 0 0 0 1 0 top top top top bottom bottom bottom bottom bitonic clean bitonic clean bitonic bitonic 0 1 1 1 1 1 1 1
• 23. Bitonic Sorting Network
• Bitonic Sorter
• by recursively combining half-cleaners, we can build a bitonic sorter, a network that sorts bitonic sequences
• first stage: Half-Cleaner[n]
• subsequent sorts with Bitonic-Sorter[n/2]
• Depth D(n) of Bitonic-Sorter[n]:
• D(n) = { 0 if n =1,
• D(n/2) + 1 if n = 2 k and k>= 1
• 24. Bitonic Sorting Network
• Example:
Half-Cleaner[n] Bitonic- Sorter[n/2] Bitonic- Sorter[n/2]
• 25. Bitonic Sorting Network
• Example:
0 0 1 1 1 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 1 0 1 1 0 0 0 0 0 1 1 1 bitonic sorted
• 26. Bitonic Sorting Network
• Bitonic-Sorter can be used to sort a zero-one sequence
• By the Zero-One principle it follows that any bitonic sequence of arbitrary numbers can be sorted using this network
• 27. A Merging Network
• Networks that can merge two sorted input sequences into one sorted output sequence
• The merging network is based on the following
• Given two sorted sequences, if we reverse the second sequence and then concatenate the two, the resulting sequence is bitonic.
• ie.
• given : X = 00001111 and Y = 000011111
• Y R = 111110000
• X● Y R = 00001111111110000
• 28. A Merging Network
• We can construct M ERGER [n] by modifying the first half cleaner of B ITONIC -S ORTER [n].
• The key is to perform the reversal of the second half of the inputs implicitly.
• Given two sorted sequences <a 1 , a 2 , …, a n/2 > and <a n/2+1 , a n/2+2 , …, a n >
• Want the effect of bitonically sorting the sequence < a 1 , a 2 , …, a n/2, a n, a n-1, a n-2, ..., a n/2+1 >
• 29. A Merging Network
• B ITONIC -S ORTER [n] compares inputs i and n /2+ i for i = 1,2,3,…, n /2.
• a 1 0 ---------------------------------- 0 b 1
• a 2 0 ---------------------------------- 0 b 2 bitonic
• a 3 1 ---------------------------------- 0 b 3 clean
• bitonic a 4 1 ---------------------------------- 0 b 4
• a 8 1 ---------------------------------- 1 b 8
• a 7 0 ---------------------------------- 0 b 7 bitonic
• a 6 0 ---------------------------------- 1 b 6
• a 5 0 ---------------------------------- 1 b 5
• 30. A Merging Network
• First stage of the merging network compares inputs i and n /2 + i for i = 1,2,3,…, n /2.
• a 1 0 ---------------------------------- 0 b 1
• sorted a 2 0 ---------------------------------- 0 b 2 bitonic
• a 3 1 ---------------------------------- 0 b 3 clean
• a 4 1 ---------------------------------- 0 b 4
• a 5 0 ---------------------------------- 1 b 5
• sorted a 6 0 ---------------------------------- 1 b 6 bitonic
• a 7 0 ---------------------------------- 0 b 7
• a 8 1 ---------------------------------- 1 b 8
• 31. A Merging Network
• Since the reversal of a bitonic sequence is bitonic sequence.
• Both top and bottom outputs from the first stage of the merging network satisfy the properties of Lemma 27.3
• both the top half and the bottom half are bitonic
• every element in the top half is at least as small as every element in the bottom half
• at least one half is clean (either all 0’s or 1’s)
• 32. A Merging Network
• The top and bottom outputs can be bitonically sorted in parallel to produce the sorted output of the merging network.
• 33. A Merging Network Bitonic- Sorter[n/2] Bitonic- Sorter[n/2]
• 34. A Merging Network 1 0 0 1 0 0 1 1 0 1 1 0 1 0 1 1 0 1 1 0 1 0 1 1 0 1 0 1 1 0 1 1 sorted sorted sorted
• 35. A Merging Network
• First stage is different
• Consequently the depth is the same as B ITONIC -S ORTER [n]
• Depth D(n) of M ERGER [n]:
• D(n) = { 0 if n =1,
• D(n/2) + 1 if n = 2 k and k>= 1
• D(n) = lg n
• 36. A Sorting Network
• Now we have all the necessary tools to construct a network that can sort any input sequence
• We are going to use the a fore mentioned merging network to implement a parallel version of merge sort, called S ORTER [n]
• 37. A Sorting Network Sorter[n/2] Sorter[n/2] Merger[n]
• 38. A Sorting Network Merger[4] Merger[4] Merger[8] Merger[2] Merger[2] Merger[2] Merger[2]
• 39. A Sorting Network 1 0 1 0 1 0 0 0 0 0 1 1 0 0 0 1 0 1 0 0 0 0 1 1 0 1 0 1 0 1 0 0 1 depth 2 2 3 4 4 4 4 5 5 6
• 40. A Sorting Network
• 41. Conclusion
• Sorting Network Components
• Comparison Networks
• Zero-one Principle
• Bitonic Sorting Network
• Half-Cleaner
• Bitonic Sorter
• Merging Network
• Sorting Networks