scispace - formally typeset
Search or ask a question
Journal ArticleDOI

On parallel integer sorting

01 Feb 1992-Acta Informatica (Springer-Verlag New York, Inc.)-Vol. 29, Iss: 1, pp 1-15
TL;DR: An optimal algorithm for sortingn integers in the range [1,nc] (for any constantc) for the EREW PRAM model where the word length isn'tε, for any ε>0.
Abstract: We present an optimal algorithm for sortingn integers in the range [1,nc] (for any constantc) for the EREW PRAM model where the word length isne, for any e>0. Using this algorithm, the best known upper bound for integer sorting on the (O(logn) word length) EREW PRAM model is improved. In addition, a novel parallel range reduction algorithm which results in a near optimal randomized integer sorting algorthm is presented. For the case when the keys are uniformly distributed integers in an arbitrary range, we give an algorithm whose expected running time is optimal.

Content maybe subject to copyright    Report

Citations
More filters
Proceedings Article
01 Sep 1992
TL;DR: The algorithm is closer to optimality than all previous algorithms for the stated problem in the stated model, and the third result matches the operation count of the best known sequential algorithm.
Abstract: We show that n integers in the range 1..n can be stably sorted on an EREW PRAM using O((log n)1/2) time, O(n(log n)1/2(log log n)1/2) operations and O(n) space. In addition, we are able to stably sort n integers in the range 1..n on a deterministic CREW PRAM in O((log n)3/2) time with O(n(log n)1/2) operations and O(n) space and to stably sort n arbitrary integers on a randomized CREW PRAM within the same complexity bounds with high probability. In each case our algorithm is closer to optimality than all previous algorithms for the stated problem in the stated model, and our third result matches the operation count of the best known sequential algorithm. We also show that m integers in the range 1..m can be sorted in O((log n)2) time with O(n) operations on an EREW PRAM using a nonstandard word length of O(log n log log n log m) bits, thereby greatly improving the upper bound on the word length necessary to sort integers with a linear time-processor product, even sequentially. Our algorithms were inspired by, and in one case directly use, the fusion trees recently introduced by Fredman and Willard.

99 citations

Journal ArticleDOI
TL;DR: In this paper, it was shown that integers in the range 1,?n can be sorted in O((logn)2) time with O(n) operations on an EREW PRAM using a nonstandard word length of O(loglognlogm) bits, thereby greatly improving the upper bound on the word length necessary to sort integers with a linear time?processor product.
Abstract: We show thatnintegers in the range 1,?,ncan be sorted stably on an EREW PRAM usingO(t) time andO(n(lognloglogn+(logn)2/t)) operations, for arbitrary givent?lognloglogn, and on a CREW PRAM usingO(t) time andO(n(logn+logn/2t/logn)) operations, for arbitrary givent?logn. In addition, we are able to sortnarbitrary integers on a randomized CREW PRAM within the same resource bounds with high probability. In each case our algorithm is a factor of almost?:(logn) closer to optimality than all previous algorithms for the stated problem in the stated model, and our third result matches the operation count of the best previous sequential algorithm. We also show thatnintegers in the range 1,?,mcan be sorted inO((logn)2) time withO(n) operations on an EREW PRAM using a nonstandard word length ofO(lognloglognlogm) bits, thereby greatly improving the upper bound on the word length necessary to sort integers with a linear time?processor product, even sequentially. Our algorithms were inspired by, and in one case directly use, the fusion trees of Fredman and Willard.

57 citations

Proceedings ArticleDOI
13 Jun 2015
TL;DR: This work implements the parallel integer sorting algorithm of Rajasekaran and Reif, but instead of processing bits of a integers in a reduced range in a bottom-up fashion, it process the hashed values of keys directly top-down.
Abstract: Semisorting is the problem of reordering an input array of keys such that equal keys are contiguous but different keys are not necessarily in sorted order. Semisorting is important for collecting equal values and is widely used in practice. For example, it is the core of the MapReduce paradigm, is a key component of the database join operation, and has many other applications. We describe a (randomized) parallel algorithm for the problem that is theoretically efficient (linear work and logarithmic depth), but is designed to be more practically efficient than previous algorithms. We use ideas from the parallel integer sorting algorithm of Rajasekaran and Reif, but instead of processing bits of a integers in a reduced range in a bottom-up fashion, we process the hashed values of keys directly top-down. We implement the algorithm and experimentally show on a variety of input distributions that it outperforms a similarly-optimized radix sort on a modern 40-core machine with hyper-threading by about a factor of 1.7--1.9, and achieves a parallel speedup of up to 38x. We discuss the various optimizations used in our implementation and present an extensive experimental analysis of its performance.

50 citations


Cites background from "On parallel integer sorting"

  • ...Linear work and logarithmic depth can be achieved if a non-standard polynomial word length is assumed [17]....

    [...]

Journal ArticleDOI
H J Reif1, Sandeep Sen1
TL;DR: In this paper, the authors present parallel algorithms for 3-D maxima and two-set dominance counting by an application of integer sorting, which have running time of O(logn)$ using $n$ processors, with very high probability.
Abstract: We present parallel algorithms for some fundamental problems in computational geometry which have running time of $O(logn)$ using $n$ processors, with very high probability (approaching 1 as $n~ \rightarrow~ \infty$). These include planar point location, triangulation and trapezoidal decomposition. We also present optimal algorithms for 3-D maxima and two-set dominance counting by an application of integer sorting. Most of these algorithms run on CREW PRAM model and have optimal processor-time product which improve on the previously best known algorithms of Atallah and Goodrich [3] for these problems. The crux of these algorithms is a useful data structure which emulates the plane sweeping paradigm used for sequential algorithms. We extend some of the techniques used by Reischuk [22] Reif and Valiant [21] for flashsort algorithm to perform divide and conquer in a plane very efficiently leading to the improved performance by our approach.

45 citations

Journal ArticleDOI
TL;DR: The problem of deterministic integer sorting on unit-cost sequential and parallel machines with a large word length is considered and it is shown that n integers drawn from {0,..., m -1} can be sorted using a word length of O( m log n ) bits.

25 citations

References
More filters
Book
01 Jan 1968
TL;DR: The arrangement of this invention provides a strong vibration free hold-down mechanism while avoiding a large pressure drop to the flow of coolant fluid.
Abstract: A fuel pin hold-down and spacing apparatus for use in nuclear reactors is disclosed. Fuel pins forming a hexagonal array are spaced apart from each other and held-down at their lower end, securely attached at two places along their length to one of a plurality of vertically disposed parallel plates arranged in horizontally spaced rows. These plates are in turn spaced apart from each other and held together by a combination of spacing and fastening means. The arrangement of this invention provides a strong vibration free hold-down mechanism while avoiding a large pressure drop to the flow of coolant fluid. This apparatus is particularly useful in connection with liquid cooled reactors such as liquid metal cooled fast breeder reactors.

17,939 citations


"On parallel integer sorting" refers background or methods in this paper

  • ...Many optimal algorithms like QUICK SORT and HEAP SORT whose run times match this lower bound can be found in the literature [1, 13]....

    [...]

  • ...This is not an unreasonable assumption in many applications (see [13](pp....

    [...]

Book
01 Jan 1974
TL;DR: This text introduces the basic data structures and programming techniques often used in efficient algorithms, and covers use of lists, push-down stacks, queues, trees, and graphs.
Abstract: From the Publisher: With this text, you gain an understanding of the fundamental concepts of algorithms, the very heart of computer science. It introduces the basic data structures and programming techniques often used in efficient algorithms. Covers use of lists, push-down stacks, queues, trees, and graphs. Later chapters go into sorting, searching and graphing algorithms, the string-matching algorithms, and the Schonhage-Strassen integer-multiplication algorithm. Provides numerous graded exercises at the end of each chapter. 0201000296B04062001

9,262 citations

Journal ArticleDOI
TL;DR: In this paper, it was shown that the likelihood ratio test for fixed sample size can be reduced to this form, and that for large samples, a sample of size $n$ with the first test will give about the same probabilities of error as a sample with the second test.
Abstract: In many cases an optimum or computationally convenient test of a simple hypothesis $H_0$ against a simple alternative $H_1$ may be given in the following form. Reject $H_0$ if $S_n = \sum^n_{j=1} X_j \leqq k,$ where $X_1, X_2, \cdots, X_n$ are $n$ independent observations of a chance variable $X$ whose distribution depends on the true hypothesis and where $k$ is some appropriate number. In particular the likelihood ratio test for fixed sample size can be reduced to this form. It is shown that with each test of the above form there is associated an index $\rho$. If $\rho_1$ and $\rho_2$ are the indices corresponding to two alternative tests $e = \log \rho_1/\log \rho_2$ measures the relative efficiency of these tests in the following sense. For large samples, a sample of size $n$ with the first test will give about the same probabilities of error as a sample of size $en$ with the second test. To obtain the above result, use is made of the fact that $P(S_n \leqq na)$ behaves roughly like $m^n$ where $m$ is the minimum value assumed by the moment generating function of $X - a$. It is shown that if $H_0$ and $H_1$ specify probability distributions of $X$ which are very close to each other, one may approximate $\rho$ by assuming that $X$ is normally distributed.

3,760 citations

Journal ArticleDOI
TL;DR: A recurstve construction is used to obtain a product circuit for solving the prefix problem and a Boolean clrcmt which has depth 2[Iog2n] + 2 and size bounded by 14n is obtained for n-bit binary addmon.
Abstract: The prefix problem is to compute all the products x t o x2 . . . . o xk for i ~ k .~ n, where o is an associative operation A recurstve construction IS used to obtain a product circuit for solving the prefix problem which has depth exactly [log:n] and size bounded by 4n An application yields fast, small Boolean ctrcmts to simulate fimte-state transducers. By simulating a sequentml adder, a Boolean clrcmt which has depth 2[Iog2n] + 2 and size bounded by 14n Is obtained for n-bit binary addmon The size can be decreased significantly by permitting the depth to increase by an addmve constant

1,159 citations