You are on page 1of 20

Sorting

One of the most common operations


Definition:

Arrange an unordered collection of


elements into a increasing or decreasing
order.

Two categories of sorting


internal
external

Sorting Algorithms

Comparison based
compare-exchange
O(n log n)

Noncomparison based
Uses known properties of the elements
O(n) - bucket sort etc.

Parallel Sorting Issues

Input and Output sequence storage


Where?
Local to one processor or distributed

Comparisons
How compare elements on different nodes

elements per processor


One (compare-exchange --> comm.)
Multiple (compare-split --> comm.)

Compare-Exchange

Compare-Split

Sorting Networks

Specialized hardware for sorting


based on comparator
x
y

max{x,y}
min{x,y}

x
y

min{x,y}
max{x,y}

Sorting Network

Parallel Sorting Algorithms


Merge Sort
Quick Sort
Bitonic Sort

Merge Sort
Simplest parallel sorting algorithm?
Steps

Distribute the elements


Everybody sort their own sequence
Merge the lists

Problem
How to merge the lists

Bitonic Sort

Key operation:
rearrange a bitonic sequence to ordered

Bitonic Sequence
sequence of elements <a0, a1, , an-1>
There exists i such that <a0, ,ai> is
monotonically increasing and <ai+1, , an-1> is
monotonically decreasing or
There exists a cyclic shift of indicies such that the
above is satisfied.

Bitonic Sequences

<1, 2, 4, 7, 6, 0>
First it increases then decreases
i=3

<8, 9, 2, 1, 0, 4>
Consider a cyclic shift
i will equal 3

Rearranging a Bitonic Sequence

Let s = <a0, a1, , an-1>


an/2 is the beginning of the decreasing seq.

Let s1= <min{a0, an/2}, min{a1, an/2 +1}min{an/2-1,an-1}>


Let s2=<max{a0, an/2}, max{a1,an/2+1} max{an/2-1,an-1} >

In sequence s1 there is an element bi = min{ai, an/2+i}


all elements before bi are from increasing

all elements after bi are from decreasing


Sequence s2 has a similar point

Sequences s1 and s2 are bitonic

Rearranging a Bitonic Sequence


Every element of s1 is smaller than
every element of s2
Thus, we have reduced the problem of
rearranging a bitonic sequence of size n
to rearranging two bitonic sequences of
size n/2 then concatenating the
sequences.

Rearranging a Bitonic Sequence

Bitonic Merging Network

What about unordered lists?

To use the bitonic merge for n items, we must


first have a bitonic sequence of n items.
Two elements form a bitonic sequence
Any unsorted sequence is a concatenation of
bitonic sequences of size 2
Merge those into larger bitonic sequences
until we end up with a bitonic sequence of
size n

Mapping onto a hypercube


One element per processor
Start with the sorting network maps
Each wire represents a processor
Map processors to wires to minimize
the distance traveled during exchange

Bitonic Merging Network

Bitonic Sort
Procedure BitonicSort
for i = 0 to d -1
for j = i downto 0
if (i + 1)st bit of iproc <> jth bit of iproc
comp_exchange_max(j, item)
else
comp_exchange_min(j, item)
endif
endfor
endfor
comp_exchange_max and comp_exchange_min compare and
exchange the item with the neighbor on the jth dimension

Bitonic Sort Stages

You might also like