GPU-ABiSort: optimal parallel sorting on stream architectures

Greb, Andreas; Zachmann, Gabriel

doi:10.1109/ipdps.2006.1639284

Cited by 44 publications

(39 citation statements)

References 10 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…Kipfer et al [7,8] have shown an improved version of the bitonic sort as well as an odd-even merge sort. Greß et al [9] introduced an approach based on the adaptive bitonic sorting technique presented by Bilardi et al [10]. Govindaraju et al [11] implemented a sorting solution based on the periodic balanced sorting network method by Dowd et al [12] and one based on bitonic sort [13].…”

Section: Introductionmentioning

confidence: 99%

A Practical Quicksort Algorithm for Graphics Processors

Cederman

Tsigas

2008

Algorithms - ESA 2008

121

View full text Add to dashboard Cite

Abstract. In this paper we present GPU-Quicksort, an efficient Quicksort algorithm suitable for highly parallel multi-core graphics processors. Quicksort has previously been considered as an inefficient sorting solution for graphics processors, but we show that GPU-Quicksort often performs better than the fastest known sorting implementations for graphics processors, such as radix and bitonic sort. Quicksort can thus be seen as a viable alternative for sorting large quantities of data on graphics processors.

show abstract

Section: Introductionmentioning

confidence: 99%

A Practical Quicksort Algorithm for Graphics Processors

Cederman

Tsigas

2008

Algorithms - ESA 2008

121

View full text Add to dashboard Cite

show abstract

“…Gress and Zachmann [4] present results of up to 1M elements, and then report a 37% performance improvement on the GPUSort algorithm on a GeForce 6800 based system, but only about 5% on a Geforce 7800 system. Our algorithm performs more than twice as fast as the GPUSort algorithm for arrays of four million elements and more.…”

Section: Millisecondsmentioning

confidence: 99%

“…It is, however, possible to modify bitonic sort to perform in O(n log n). GPU-ABiSort by Greß and Zachmann [4] utilizes Adaptive Bitonic Sorting [5], where the key is to use a bitonic tree, when merging two bitonic sequences, to rearrange the data to obtain a linear number of comparisons for the merge, instead of the n log n comparisons required by the standard bitonic sort [6]. This lowers the total complexity of Adaptive Bitonic Sorting to n log n. Greß and Zachmann thereby report slightly faster timings than Govindaraju [2] for their tested 32-bit streams of up to 1M elements.…”

Section: Introductionmentioning

confidence: 99%

Fast parallel GPU-sorting using a hybrid algorithm

Sintorn

Assarsson

2008

Journal of Parallel and Distributed Computing

128

View full text Add to dashboard Cite

Abstract-This paper presents an algorithm for fast sorting of large lists using modern GPUs. The method achieves high speed by efficiently utilizing the parallelism of the GPU throughout the whole algorithm. Initially, a parallel bucketsort splits the list into enough sublists then to be sorted in parallel using merge-sort. The parallel bucketsort, implemented in NVIDIA's CUDA, utilizes the synchronization mechanisms, such as atomic increment, that is available on modern GPUs. The mergesort requires scattered writing, which is exposed by CUDA and ATI's Data Parallel Virtual Machine[1]. For lists with more than 512k elements, the algorithm performs better than the bitonic sort algorithms, which have been considered to be the fastest for GPU sorting, and is more than twice as fast for 8M elements. It is 6-14 times faster than single CPU quicksort for 1-8M elements respectively. In addition, the new GPU-algorithm sorts on n log n time as opposed to the standard n(log n) 2 for bitonic sort. Recently, it was shown how to implement GPU-based radix-sort, of complexity n log n, to outperform bitonic sort. That algorithm is, however, still up to ∼ 40% slower for 8M elements than the hybrid algorithm presented in this paper. GPU-sorting is memory bound and a key to the high performance is that the mergesort works on groups of four-float values to lower the number of memory fetches. Finally, we demonstrate the performance on sorting vertex distances for two large 3D-models; a key in for instance achieving correct transparency.

show abstract

“…Moreover, degree of parallelism is reduced as higher levels are sorted and thus not fully utilizing parallel GPU architecture. An adaptive bitonic-scheme is proposed in [12]. Their technique sorts n values using p stream processors achieving optimum complexity of ( ) p n n log Ο .…”

Section: Related Workmentioning

confidence: 99%