An Efficient Implementation of Batcher′s Odd-Even Merge on a SIMD Hypercube

doi:10.1006/jpdc.1993.1090

Journal of Parallel and Distributed Computing

Volume 19, Issue 1, September 1993, Pages 58-63

https://doi.org/10.1006/jpdc.1993.1090 Get rights and content

Abstract

We present an efficient Θ(log N) implementation of Batcher′s odd-even merge on a SIMD hypercube. (The hypercube model assumes that all communications are restricted to one fixed dimension at a time.) The best previously known implementation of odd-even merge on a SIMD hypercube requires Θ(log²N) time. The performance of our odd-even merge implementation is comparable to that of bitonic merge. (If the input sequences are both in ascending order and the architecture provides half-duplex communication, then our algorithm runs faster than bitonic merge by a factor of $43$ .) A generalization of our technique has led to an efficient O(log N) algorithm for a wider class of parallel computations, called ±2^b-descend, on a SIMD hypercube [11]. This class includes odd-even merge and many other algorithms. In this paper, we briefly discuss the main ideas of this paradigm.

References (0)

Cited by (3)

On the Average Running Time of Odd-Even Merge Sort
1997, Journal of Algorithms
This paper gives an upper bound for the average running time of Batcher's odd–even merge sort when implemented on a collection of processors. We consider the case wheren, the size of the input, is an arbitrary multiple of the numberpof processors used. We show that Batcher's odd–even merge (for two sorted lists of lengthneach) can be implemented to run in timeO((n/p)(log(2 + p²/n))) on the average,1and that odd–even merge sort can be implemented to run in timeO((n/p)(log n + log p log(2 + p²/n))) on the average. In the case of merging (sorting), the average is taken over all possible outcomes of the merge (all possible permutations ofnelements). That means that odd–even merge and odd–even merge sort have an optimal average running time ifn ≥ p². The constants involved are also quite small.
Nearly Logarithmic-Time Parallel Algorithms for the Class of ±2b ASCEND Computations on a SIMD Hypercube
1994, Journal of Parallel and Distributed Computing
Recently, we studied two important classes of algorithms requiring ±2^b communications: ±2^b-descend, and ±2^b-ascend. Given an N-element input A[0 : N − 1], where N = 2ⁿ, the descend class consists of n iterations. For b = n − 1, n − 2, ..., 0, iteration b computes the new value of each A [i] as a function of the previous-iteration values of A[i], A[i + 2^b mod N], and A[i − 2^b mod N]. (Batcher′s odd-even merge falls into this class.) The ascend class is similar except that the iterations are for b = 0, 1, ..., n − 1. Let N = 2ⁿ be the number of processors in a SIMD hypercube which restricts all communications to a single fixed dimension at a time. For the descend class, we developed an efficient O(n) algorithm on a SIMD hypercube. And for the ascend class, we obtained a simple O(n²/log n) algorithm, requiring O(n) words of local memory per processor. In this paper, we develop two new algorithms for the ascend class on a SIMD hypercube. The first algorithm runs in O(n^1.5) time and requires O(1) space per PE. The second algorithm runs in [formula] time and requires O(log n) space per PE.
On the average running time of odd-even merge sort
1995, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

View full text

Regular ArticleAn Efficient Implementation of Batcher′s Odd-Even Merge on a SIMD Hypercube

Abstract

Regular Article
An Efficient Implementation of Batcher′s Odd-Even Merge on a SIMD Hypercube