User:ParAlgMergeSort/sandbox/Parallel merge sort

Parallel merge sort

Merge sort parallelizes well due to the use of the divide-and-conquer method. Many different parallel variants of the algorithm have been developed over the years.

Simple approach

A first approach is the parallelization of recursive calls, as described in the following pseudocode (see also fork and join):

// Sort elements lo through hi (exclusive) of array A.
algorithm mergesort(A, lo, hi) is
    if lo+1 < hi then  // Two or more elements.
        mid := ⌊(lo + hi) / 2⌋
        fork mergesort(A, lo, mid)
        mergesort(A, mid, hi)
        join
        merge(A, lo, mid, hi)

This Algorithm is the trivial modification of the sequential version, and does not parallelize well. Therefore its speedup is not very impressive. It has a span of $\Theta (n)$, which is only an improvement of $\Theta (\log n)$ compared to the sequential version (see Introduction to Algorithms). This is mainly due to the sequential merge method, as it is the bottleneck of the parallel executions.

Parallelizing the merge method

Main article: Merge algorithm § Parallel merge

Better parallelism can be achieved by using a parallel merge algorithm. Cormen et al. present a binary variant that merges two sorted sub-sequences into one sorted output sequence.

In one of the sequences (the longer one if unequal length), the element of the middle index is selected. Its position in the other sequence is determined, so that this sequence would remain sorted if this element were inserted at this position. Thus one knows how many other elements from both sequences are smaller and the position of the selected element in the output sequence can be calculated. For the partial sequences of the smaller and larger elements created in this way, the merge algorithm is again executed in parallel until the base case of the recursion is reached.

The following pseudocode shows the modified parallel merge sort method using the parallel merge algorithm (adopted from Cormen et al.)

/**
 * A: Input array
 * B: Output array
 * lo: lower bound
 * hi: higher bound
 * off: offset
 */
algorithm PMergesort(A, lo, hi, B, off) is
    len := hi - lo + 1
    if len == 1
        B[off] := A[lo]
    else let T[1..len] be a new array
        mid := ⌊(lo + hi) / 2⌋ 
        mid' := mid - lo + 1
        fork PMergesort(A, lo, mid, T, 1)
        PMergesort(A, mid + 1, hi, T, mid' + 1) 
        join 
        PMerge(T, 1, mid', mid' + 1, len, B, off)

In order to analyze a Recurrence relation for the worst case span, the recursive calls of PMergesort have to be incorporated only once due to their parallel execution, obtaining

${\textstyle T_{\infty }^{\text{sort}}(n)=T_{\infty }^{\text{sort}}\left({\frac {n}{2}}\right)+T_{\infty }^{\text{merge}}(n)=T_{\infty }^{\text{sort}}\left({\frac {n}{2}}\right)+\Theta \left(\log(n)^{2}\right)}$.

For detailed information about the complexity of the parallel merge procedure, see Merge algorithm.

The solution of this recurrence is given by

${\textstyle T_{\infty }^{\text{sort}}=\Theta \left(\log(n)^{3}\right)}$.

This parallel merge algorithm reaches a parallelism of $\Theta {\biggr (}{n \over (\log n)^{2}}{\biggr )}$, which is much higher than the parallelism of the naive algorithm.

Parallel multiway merge sort

K-way merge is a generalization of 2-way merge, or binary merge, in which k sorted sequences are merged together. This merge variant is well suited to describe a sorting algorithm on a PRAM.

Basic Idea

The parallel multiway mergesort process on four processors $t_{0}$ to $t_{3}$.

Given an unsorted sequence of $n$ elements, the goal is to sort the sequence with $p$ available processors. These elements are distributed equally among all processors and sorted locally using a sequential Sorting algorithm. Hence, the sequence consists of sorted sequences $S_{1},...,S_{p}$ of length ${\textstyle \lceil {\frac {n}{p}}\rceil }$. For simplification let n be a multiple of p, so that ${\textstyle \left\vert S_{i}\right\vert ={\frac {n}{p}}}$ for $i=1,...,p$.

These sequences will be used to perform a splitter selection. For $i=1,...,p$, the algorithm determines splitter elements $v_{i}$ with global rank ${\textstyle k=i{\frac {n}{p}}}$.

Then the corresponding positions of $v_{1},...,v_{p}$ in each sequence $S_{i}$ are determined with binary search and thus the $S_{i}$ are further partitioned into $p$ subsequences $S_{i,1},...,S_{i,p}$ with ${\textstyle S_{i,j}:=\{x\in S_{i}|rank(v_{j-1})<rank(x)\leq rank(v_{j})\}}$.

Furthermore the elements of $S_{i,1},...,S_{i,p}$ are assigned to processor $i$, means all elements between rank ${\textstyle (i-1){\frac {n}{p}}}$ and rank ${\textstyle i{\frac {n}{p}}}$, which are distributed over all $S_{i}$. Thus each processor receives a sequence of sorted sequences.

The fact that the rank $k$ of the splitter elements $v_{i}$ was chosen globally, provides two important properties: On the one hand, $k$ was chosen so that each processor can still operate on ${\textstyle n/p}$ elements after assignment. The Algorithm is perfectly load-balanced. On the other hand, all elements on processor $i$ are less than or equal to all elements on processor $i+1$.

Hence, each processor performs the p-way merge locally and thus obtains a sorted sequence from its sub-sequences. Because of the second property, no further p-way-merge has to be performed, the results only have to be put together in the order of the processor number.

Splitter selection

In its simplest form, given $p$ sorted sequences $S_{1},...,S_{p}$ distributed evenly on $p$ processors and a rank $k$, the task is to find an element $x$ with a global rank $k$ in the union of the sequences. Hence, this can be used to divide each $S_{i}$ in two parts at a splitter index $l_{i}$, where the lower part contains only elements which are smaller than $x$, while the elements bigger than $x$ are located in the upper part.

The presented algorithm returns the indices of the splits in each sequence, e.g. the indices $l_{i}$ in sequences $S_{i}$ such that $S_{i}[l_{i}]$ has a global rank less than $k$ and $\mathrm {rank} \left(S_{i}[l_{i}+1]\right)>k$.

msSelect(S: Array of sorted Sequences [S_1,..,S_p], k: int)	returns Array of int
	for i = 1,..., p: 
	    (l_i, r_i) = (0, |S_i|-1)
	while there exists i: l_i < r_i:
		//pick Pivot Element in S_j[l_j],..,S_j[r_j], chose random j uniformly
		v := pickPivot(S, l, r)
		for i = 1,..,p:
			m_i = binarySearch(v, S_i[l_i, r_i]) //sequentially
		if m_1 + ... + m_p >= k: 
			r := m  //vector assignment
		else:
			l := m 
	return l

For the complexity analysis the PRAM model is chosen.

If the data is evenly distributed over all $p$, the p-fold execution of the binarySearch method has a running time of ${\mathcal {O}}\left(p\log \left(n/p\right)\right)$. The expected recursion depth is ${\mathcal {O}}\left(\log \left(\textstyle \sum _{i}|S_{i}|\right)\right)={\mathcal {O}}(\log(n))$ as in the ordinary Quickselect.

Thus the overall expected running time is ${\mathcal {O}}\left(p\log(n/p)\log(n)\right)$.

Applied on the parallel multiway merge sort, this algorithm has to be invoked in parallel such that all splitter elements of rank ${\textstyle i{\frac {n}{p}}}$ for $i=1,..,p$ are found simultaneously. These splitter elements can then be used to partition each sequence in $p$ parts, with the same total running time of ${\mathcal {O}}\left(p\,\log(n/p)\log(n)\right)$.

Pseudocode

/**
 * d: Unsorted Array of Elements
 * n: Number of Elements
 * p: Number of Processors
 * return Sorted Array
 */
pMultiwayMergesort(d : Array, n : int, p : int) : Array {
	o := new array[0, n]                         // the output array
	
	for i = 1 to p in parallel do {              // each processor in parallel
	    s_i := d[(i-1) * n/p, i * n/p] 		     // Sequence of length n/p
	    sort(s_i)                                // sort locally
	
	    v_i := select_splitter(i * n/p)          // element with global rank i * n/p
	    (s_i,1 ,..., s_i,p) = sequence_partitioning(si, v_1, ..., v_p) // split s_i into subsequences
	    
	    o[(i-1) * n/p, i * n/p] := kWayMerge(s_1,i, ..., s_p,i)  // merge and assign to output array
	}
	return o
}

Analysis

Firstly, each processor sorts the assigned $n/p$ elements locally using a sorting algorithm with complexity ${\mathcal {O}}\left(n/p\;\log(n/p)\right)$. After that, the splitter elements have to be calculated in time ${\mathcal {O}}\left(p\,\log(n/p)\log(n)\right)$. Finally, each group of $p$ splits have to be merged in parallel by each processor with a running time of ${\mathcal {O}}(\log(p)\;n/p)$ using a sequential p-way merge algorithm. Thus, the overall running time is given by

${\mathcal {O}}\left({\frac {n}{p}}\log \left({\frac {n}{p}}\right)+p\log \left({\frac {n}{p}}\right)\log(n)+{\frac {n}{p}}\log(p)\right)$.

Practical adaption and application

The multiway mergesort algorithm benifits from its scalability. The high parallelization capability makes it possible to sort very large amounts of data with many processors. In distributed systems, where memory is usually not a limiting resource and a large number of processors are available, its advantages are used.

However, other factors are important in such systems, which are not taken into account when modelling on a PRAM. For example, the communication overhead of exchanging data between processors could become a bottleneck when the data can no longer be accessed via the shared memory.

Sanders et al. have presented a bulk synchronous parallel like algorithm for multilevel multiway mergesort, which divides $p$ processors into $r$ groups of size $p'$. All processors sort locally first. Unlike single level mergesort, these sequences are then partitioned into $r$ parts and assigned to the appropriate processor groups. These steps are repeated recursively in those groups. This reduces communication and especially avoids problems with many small messages. The hierarchial structure of the underlying real network can be used to define the processor groups (e.g. racks, clusters,...).

More Variants

Merge sort was one of the first sorting algorithms where optimal speed up was achieved, with Richard Cole using a clever subsampling algorithm to ensure O(1) merge. Other sophisticated parallel sorting algorithms can achieve the same or better time bounds with a lower constant. For example, in 1991 David Powers described a parallelized quicksort (and a related radix sort) that can operate in O(log n) time on a CRCW parallel random-access machine (PRAM) with n processors by performing partitioning implicitly. Powers further shows that a pipelined version of Batcher's Bitonic Mergesort at O((log n)²) time on a butterfly sorting network is in practice actually faster than his O(log n) sorts on a PRAM, and he provides detailed discussion of the hidden overheads in comparison, radix and parallel sorting.

External links

• www.example.com