Parallel Sorting Algorithms Research Articles

An improved reliability bound of a probabilistic parallel integer sorting algorithm

It is shown how one can improve the reliability bound of the parallel sorting algorithm of Rajasekaran and Sen (1992) [7] that sorts uniformly distributed integer keys on a CRCW Parallel Random Access Machine (PRAM). The probability of success improves to 1−2−Ω(nloglogn/logn) from the previous bound of 1−2−Ω(n/(lognloglogn)) while retaining the O˜(logn) time bound for sorting n uniformly distributed integers on n/logn processors.

Performance Comparison of Parallel Sorting Algorithms on Homogeneous Cluster of Workstations

Sorting appears the most attention among all computational tasks over the past years because sorted data is at the heart of many computations. Sorting is of additional importance to parallel computing because of its close relation to the task of routing data among processes, which is an essential part of many parallel algorithms. Many parallel sorting algorithms have been investigated for a variety of parallel computer architectures. In this paper, three parallel sorting algorithms have been implemented and compared in terms of their overall execution time. The algorithms implemented are the odd-even transposition sort, parallel merge sort and parallel shell sort. Cluster of Workstations or Windows Compute Cluster has been used to compare the algorithms implemented. The C# programming language is used to develop the sorting algorithms. The MPI library has been selected to establish the communication and synchronization between processors. The time complexity for each parallel sorting algorithm will also be mentioned and analyzed.

Parallel Prefix Computation and Sorting on a Recursive Dual-Net

In this paper, we propose efficient algorithms for parallel prefix computation and sorting on a recursive dual-net. The recursive dual-net <TEX>$RDN^k$</TEX>(B) for k > 0 has <TEX>$(2n_o)^{2K}/2$</TEX> nodes and <TEX>$d_0$</TEX> + k links per node, where <TEX>$n_0$</TEX> and <TEX>$d_0$</TEX> are the number of nod es and the node-degree of the base-network B, respectively. Assume that each node holds one data item, the communication and computation time complexities of the algorithm for parallel prefix computation on <TEX>$RDN^k$</TEX>(B), k > 0, are <TEX>$2^{k+1}-2+2^kT_{comm}(0)$</TEX> and <TEX>$2^{k+1}-2+2^kT_{comp}(0)$</TEX>, respectively, where <TEX>$T_{comm}(0)$</TEX> and <TEX>$T_{comp}(0)$</TEX> are the communication and computation time complexities of the algorithm for parallel prefix computation on the base-network B, respectively. The algorithm for parallel sorting on <TEX>$RDN^k$</TEX>(B) is restricted on B = <TEX>$Q_m$</TEX> where <TEX>$Q_m$</TEX> is an m-cube. Assume that each node holds a single data item, the sorting algorithm runs in <TEX>$O((m2^k)^2)$</TEX> computation steps and <TEX>$O((km2^k)^2)$</TEX> communication steps, respectively.

Fast in‐place, comparison‐based sorting with CUDA: a study with bitonic sort

AbstractState‐of‐the‐art graphics processors provide high processing power and furthermore, the high programmability of GPUs offered by frameworks like CUDA (Compute Unified Device Architecture) increases their usability as high‐performance co‐processors for general‐purpose computing. Sorting is well investigated in Computer Science in general, but (because of this new field of application for GPUs) there is a demand for high‐performance parallel sorting algorithms that fit with the characteristics of the modern GPU‐architecture. We present a high‐performance in‐place implementation of Batcher's bitonic sorting networks for CUDA‐enabled GPUs. Therefore, we assigned compare/exchange operations to threads in a way that decreases low‐performance global‐memory access and makes efficient use of high‐performance shared memory. This greatly increases the performance of this in‐place, comparison‐based sorting algorithm. Our implementation outperforms all other algorithms in our tests when sorting 64‐bit keys. It is the fastest comparison‐based GPU sorting algorithm for 32‐bit keys, being only outperformed by (non‐comparison‐based) radix sort when sorting sequences larger than 223. Copyright © 2011 John Wiley &amp; Sons, Ltd.

Parallel Algorithms for the Execution of Relational Database Operations Revisited On Grids

This paper presents an analytical discussion of algorithms for relational database operations in a grid environment, compares the findings with the classical generalized multiprocessor framework, and describes an optimization algorithm to maximize performance for a heterogeneous environment. We develop a concise but comprehensive analytical model of parallel algorithms for sorting, joining, and aggregation. In our approach we focus on a limited number of characteristic parameters to keep the analytical model clear. It is shown that an expressive model can be built upon just three characteristic parameter sets, namely the node processing performance and the network and the disk bandwidths. These parameters are the input for the optimization process for the orchestration of the execution workflow on the grid. Based on these results the paper proves that using smart enhancement to exploit the heterogeneity of the grid, the performance of the algorithms for database operations can be increased remarkably.

An optimal and processor efficient parallel sorting algorithm on a linear array with a reconfigurable pipelined bus system

Optical interconnections attract many engineers and scientists’ attention due to their potential for gigahertz transfer rates and concurrent access to the bus in a pipelined fashion. These unique characteristics of optical interconnections give us the opportunity to reconsider traditional algorithms designed for ideal parallel computing models, such as PRAMs. Since the PRAM model is far from practice, not all algorithms designed on this model can be implemented on a realistic parallel computing system. From this point of view, we study Cole’s pipelined merge sort [Cole R. Parallel merge sort. SIAM J Comput 1988;14:770–85] on the CREW PRAM and extend it in an innovative way to an optical interconnection model, the LARPBS (Linear Array with Reconfigurable Pipelined Bus System) model [Pan Y, Li K. Linear array with a reconfigurable pipelined bus system—concepts and applications. J Inform Sci 1998;106;237–58]. Although Cole’s algorithm is optimal, communication details have not been provided due to the fact that it is designed for a PRAM. We close this gap in our sorting algorithm on the LARPBS model and obtain an O(log N)-time optimal sorting algorithm using O( N) processors. This is a substantial improvement over the previous best sorting algorithm on the LARPBS model that runs in O(log N log log N) worst-case time using N processors [Datta A, Soundaralakshmi S, Owens R. Fast sorting algorithms on a linear array with a reconfigurable pipelined bus system. IEEE Trans Parallel Distribut Syst 2002;13(3):212–22]. Our solution allows efficiently assign and reuse processors. We also discover two new properties of Cole’s sorting algorithm that are presented as lemmas in this paper.

A Heapify Based Parallel Sorting Algorithm

Quick sort is a sorting algorithm whose worst case running time is θ(n2 ) on an input array of n numbers. It is the best practical for sorting because it has the advantage of sorting in place. Problem statement: Behavior of quick sort is complex, we proposed in-place 2m threads parallel heap sort algorithm which had advantage in sorting in place and had better performance than classical sequential quick sort in running time. Approach: The algorithm consisted of several stages, in first stage; it splits input data into two partitions, next stages it did the same partitioning for prior stage which had been spitted until 2 m partitions was reached equal to the number of available processors, finally it used heap sort to sort respectively ordered of non internally sorted partitions in parallel. Results: Results showed the speed of algorithm about double speed of classical Quick sort for a large input size. The number of comparisons needed was reduced significantly. Conclusion: In this study we had been proposed a sorting algorithm that uses less number of comparisons with respect to original quick sort that in turn requires less running time to sort the same input data.

Deterministic Parallel Sorting Algorithm for 2-D Mesh of Connected Computers

Sorting is one of the most important operations in database systems and its efficiency can influences drastically the overall system performance. To accelerate the performance of database systems, parallelism is applied to the execution of the data administration operations. We propose a new deterministic Parallel Sorting Algorithm (DPSA) that improves the performance of Quick sort in sorting an array of size n. where we use p Processor Elements (PE) that work in parallel to sort a matrix r*c where r is the number of rows r = 3 and c is the number of columns c = n/3. The simulation results show that the performance of the proposed algorithm DPSA out performs Quick sort when it works sequentially.

New Parallel Sorting Algorithm Based on Partitioning and Redistribution

New Parallel Sorting Algorithm Based on Partitioning and Redistribution

Performance modeling and analysis of correlated parallel computations

A performance analysis methodology for correlated parallel computations based on statistical theory is proposed. Divide-and-conquer strategy is widely used in solving problems in parallel by partitioning and allocating a number of given tasks to available computing resources. When the tasks exhibit run-time-dependent behaviors during execution and share a universal distribution function in their execution times, analysis of parallel execution time can be performed with the assistance of probabilistic and statistical models. Correlation (dependence) in execution times among tasks has posed a significant factor in influencing the analysis accuracy which is unmanageable by any known analysis methodologies. We establish a relation between a task’s or a processor’s execution time and the parallel execution time, in terms of expected value as well as variance when each task’s execution time can be closely modeled by a normal distribution, for either uncorrelated or correlated tasks. This relation is then applied to the modeling and analysis of various parallel computation paradigms in which different communication and synchronization patterns along the processing are present. The method proposed has a wider application scope and gives more accurate prediction results than previously known approaches. We also show that, as an extended application of the analysis method to a large scope of problems, load balance among processors can be vastly improved with some novel static task allocation technique in manipulating the correlation among tasks. Experimental results in analyzing a parallel tree search algorithm and two parallel sorting algorithms show very accurate analysis and prediction with the proposed method.

Parallel space‐filling curve generation through sorting

AbstractIn this paper we consider the scalability of parallel space‐filling curve generation as implemented through parallel sorting algorithms. Multiple sorting algorithms are studied and results show that space‐filling curves can be generated quickly in parallel on thousands of processors. In addition, performance models are presented that are consistent with measured performance and offer insight into performance on still larger numbers of processors. At large numbers of processors, the scalability of adaptive mesh refined codes depends on the individual components of the adaptive solver. One such component is the dynamic load balancer. In adaptive mesh refined codes, the mesh is constantly changing resulting in load imbalance among the processors requiring a load‐balancing phase. The load balancing may occur often, requiring the load balancer to perform quickly. One common method for dynamic load balancing is to use space‐filling curves. Space‐filling curves, in particular the Hilbert curve, generate good partitions quickly in serial. However, at tens and hundreds of thousands of processors serial generation of space‐filling curves will hinder scalability. In order to avoid this issue we have developed a method that generates space‐filling curves quickly in parallel by reducing the generation to integer sorting. Copyright © 2007 John Wiley &amp; Sons, Ltd.

An ASIC design and formal analysis of a novel pipelined and parallel sorting accelerator

Sorting, which is widely used in different areas such as database systems, IP routing, bio informatics, and cognitive-processing-based applications, imposes considerable overhead on computing resources. Therefore, an efficient on-chip sorting accelerator may significantly enhance real-time decision-making in such applications. In this paper we introduce a novel pipelined and parallel sorting algorithm with streaming I/O, with the time, logic, and memory complexity of O ( n ) , O ( n ) , and O ( n ) , respectively. We present a formal analysis to prove the correctness of this algorithm. We then model, verify, and synthesize this unconditional algorithm (in the TSMC 0.13 micron technology) for 4k-word clusters as an ASIC accelerating engine. More specifically, our implementation with 3969-word multiple-bank memory, 63 word-size comparators, 64 word-size multiplexers, and 63 word-size registers only requires some 8k clock cycles to sort an arbitrary 3969-word long array of random data, which arrive at the sorter and also depart it one item at a time.

Approximating Huffman codes in parallel

In this paper we present new results on the approximate parallel construction of Huffman codes. Our algorithm achieves linear work and logarithmic time, provided that the initial set of elements is sorted. This is the first parallel algorithm for that problem with the optimal time and work. Combining our approach with the best known parallel sorting algorithms we can construct an almost optimal Huffman tree with optimal time and work. This also leads to the first parallel algorithm that constructs exact Huffman codes with maximum codeword length H in time O ( H ) with n / log n processors, if the elements are sorted.

Parallel matching for ranking all teams in a tournament

We propose a simple and efficient scheme for ranking all teams in a tournament where matches can be played simultaneously. We show that the distribution of the number of rounds of the proposed scheme can be derived using lattice path counting techniques used in ballot problems. We also discuss our method from the viewpoint of parallel sorting algorithms.

Parallel matching for ranking all teams in a tournament

We propose a simple and efficient scheme for ranking all teams in a tournament where matches can be played simultaneously. We show that the distribution of the number of rounds of the proposed scheme can be derived using lattice path counting techniques used in ballot problems. We also discuss our method from the viewpoint of parallel sorting algorithms.

A Cost Optimal Parallel Algorithm for Patience Sorting

In this paper, we consider a parallel algorithm for the patience sorting. The problem is not known to be in the class NC or P-complete. We propose two algorithms for the patience sorting of n distinct integers. The first algorithm runs in [Formula: see text] time using p processors on the EREW PRAM, where m is the number of decreasing subsequences in a solution of the patience sorting. The second algorithm runs in [Formula: see text] time using p processors on the EREW PRAM. If [Formula: see text] is satisfied, the second algorithm becomes cost optimal.

Parallel out-of-core sorting and fast accesses to disks

The paper addresses two problems. We investigate the problem of parallel external sorting in the context of a form of heterogeneous clusters then we investigate the impact of efficient disk remote accesses on the performance of external sorting. We explore three techniques to show how they can be deployed for clusters with proportional processor performances. We also validate the READ2 library, an efficient implementation of remote SCSI disk accesses. We derive a new parallel sorting algorithm that is adapted to the READ2 interface. The expected gain of using READ2 is compared to the measured gain for one external sorting implementation.

A generalized fault-tolerant sorting algorithm on a product network

A product network defines a class of topologies that are very often used such as meshes, tori, and hypercubes, etc. This paper proposes a generalized algorithm for fault-tolerant parallel sorting in product networks. To tolerate r - 1 faulty nodes, an r-dimensional product network containing faulty nodes is partitioned into a number of subgraphs such that each subgraph contains at most one fault. Our generalized sorting algorithm is divided into two steps. First, a single-fault sorting operation is presented to correctly performed on each faulty subgraph containing one fault. Second, each subgraph is considered a supernode, and a fault-tolerant multiway merging operation is presented to recursively merge two sorted subsequences into one sorted sequence. Our generalized sorting algorithm can be applied to any product network only if the factor graph of the product graph can be embedding in a ring. Further, we also show the time complexity of our sorting operations on a grid, hypercube, and Petersen cube. Performance analysis illustrates that our generalized sorting scheme is a truly efficient fault-tolerant algorithm.

Parametric search made practical*1

In this paper we show that in sorting-based applications of parametric search, Quicksort can replace the parallel sorting algorithms that are usually advocated. Because of the simplicity of Quicksort, this may lead to applications of parametric search that are not only efficient in theory, but in practice as well. Also, we argue that Cole's optimization of certain parametric-search algorithms may be unnecessary under realistic assumptions about the input. Furthermore, we present a generic, flexible, and easy-to-use framework that greatly simplifies the implementation of algorithms based on parametric search. We use our framework to implement an algorithm that solves the Fréchet-distance problem. The implementation based on parametric search is faster than the binary-search approach that is often suggested as a practical replacement for the parametric-search technique.

Parametric search made practical

In this paper we show that in sorting-based applications of parametric search, Quicksort can replace the parallel sorting algorithms that are usually advocated. Because of the simplicity of Quicksort, this may lead to applications of parametric search that are not only efficient in theory, but in practice as well. Also, we argue that Cole's optimization of certain parametric-search algorithms may be unnecessary under realistic assumptions about the input. Furthermore, we present a generic, flexible, and easy-to-use framework that greatly simplifies the implementation of algorithms based on parametric search. We use our framework to implement an algorithm that solves the Fréchet-distance problem. The implementation based on parametric search is faster than the binary-search approach that is often suggested as a practical replacement for the parametric-search technique.