Sequential Sorting Algorithms Research Articles

Analisis Kinerja Algoritma Quick Double Merge Sort Paralel Menggunakan openMP

Processor technology currently tends to increase the number of cores more than increasing the clock speed. This development is very useful and becomes an opportunity to improve the performance of sequential algorithms that are only done by one core. This paper discusses the sorting algorithm that is executed in parallel by several logical CPUs or cores using the openMP library. This algorithm is named QDM Sort which is a combination of sequential quick sort algorithm and double merge algorithm. This study uses a data parallelism approach to design parallel algorithms from sequential algorithms. The data used in this study are the data that have not been sorted and also the data that has been sorted is integer type which is stored in advance in a file. The parameter measured to determine the performance of the QDM Sort algorithm is speedup. In a condition where a large amount of data is above 4096 and the number of threads in QDM Sort is the same as the number of logical CPUs, the QDM Sort algorithm has a better speedup compared to the other parallel sorting algorithms discussed in this study. For small amounts of data it is still better to use sequential sorting algorithm.

Performance Evaluation of Parallel Bubble Sort Algorithm on Supercomputer IMAN1

Parallel sorting algorithms order a set of elements USING MULTIPLE processors in order to enhance the performance of sequential sorting algorithms. In general, the performance of sorting algorithms are EVALUATED IN term of algorithm growth rate according to the input size. In this paper, the running time, parallel speedup and parallel efficiency OF PARALLEL bubble sort is evaluated and measured. Message Passing Interface (MPI) IS USED for implementing the parallel version of bubble sort and IMAN1 supercomputer is used to conduct the results. The evaluation results show that parallel bubble sort has better running time as the number of processors increases. On other hand, regarding parallel efficiency, parallel bubble sort algorithm is more efficient to be applied OVER SMALL number of processors.

Performance Evaluation of Parallel Bubble Sort Algorithm on Supercomputer IMAN1

Parallel sorting algorithms order a set of elements USING MULTIPLE processors in order to enhance the performance of sequential sorting algorithms. In general, the performance of sorting algorithms are EVALUATED IN term of algorithm growth rate according to the input size. In this paper, the running time, parallel speedup and parallel efficiency OF PARALLEL bubble sort is evaluated and measured. Message Passing Interface (MPI) IS USED for implementing the parallel version of bubble sort and IMAN1 supercomputer is used to conduct the results. The evaluation results show that parallel bubble sort has better running time as the number of processors increases. On other hand, regarding parallel efficiency, parallel bubble sort algorithm is more efficient to be applied OVER SMALL number of processors

Parallel Multidimensional Lookahead Sorting Algorithm

This paper presents a new parallel structured lookahead multidimensional sorting algorithm. Our algorithm can be based on any sequential sorting algorithm. The amount of parallelism can be controlled using several parameters such as the number of threads, word size, memory/processor communication overhead, and the dimension of the algorithm. The proposed technique is ideally suited for general purpose graphic processing units and shared-memory massively parallel processor systems. It ensures that data being processed exhibits temporal and spatial locality to maximize the utilization of processor cache. The algorithm achieves a speedup even when a single processor is used. A lookahead algorithm is also proposed to achieve even higher speedup. The performance of the proposed algorithm is verified numerically and experimentally.

A randomized sorting algorithm on the BSP model

An oversampling-based randomized algorithm is introduced for sorting n keys of any abstract data type on the p processors of a latency-tolerant parallel system such as a bulk-synchronous parallel computer. The algorithm is asymptotically, for large n, optimal in computation and communication compared to the best available sequential sorting algorithm, even when constant factors are taken into consideration. Its parallel time is within a (1 + o(1))/p multiplicative factor of the corresponding sequential method for sorting, improving upon other approaches for a wider range of values of p relative to n. It also improves upon other randomized sorting algorithms that have been developed for latency-tolerant models of computation on the amount of parallel slack (ratio n over p) required to achieve optimal speedup and also, on the associated failure probability. For values of p closer to n than other latency-tolerant randomized approaches, it can be turned into a PRAM-like algorithm but for such cases a speedup of O(p) rather than p/(1 + o(1)) is then achievable. Although the general framework of the proposed algorithm relies on the well-established prior idea of sample-based sorting, there are some novel features in its design such as the choice of splitter size, the way keys are split, and the handling of the base case of the recursive sorting algorithm that contribute to its performance.

Parallel Computing for Sorting Algorithms

The expanding use of multi-processor supercomputers has made a significant impact on the speed and size of many problems. The adaptation of standard Message Passing Interface protocol (MPI) has enabled programmers to write portable and efficient codes across a wide variety of parallel architectures. Sorting is one of the most common operations performed by a computer. Because sorted data are easier to manipulate than randomly ordered data, many algorithms require sorted data. 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. In this paper, sequential sorting algorithms, the parallel implementation of many sorting methods in a variety of ways using MPICH.NT.1.2.3 library under C++ programming language and comparisons between the parallel and sequential implementations are presented. Then, these methods are used in the image processing field. It have been built a median filter based on these submitted algorithms. As the parallel platform is unavailable, the time is computed in terms of a number of computations steps and communications steps

Parallel Computing for Sorting Algorithms

The expanding use of multi-processor supercomputers has made a significant impact on the speed and size of many problems. The adaptation of standard Message Passing Interface protocol (MPI) has enabled programmers to write portable and efficient codes across a wide variety of parallel architectures. Sorting is one of the most common operations performed by a computer. Because sorted data are easier to manipulate than randomly ordered data, many algorithms require sorted data. 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. In this paper, sequential sorting algorithms, the parallel implementation of many sorting methods in a variety of ways using MPICH.NT.1.2.3 library under C++ programming language and comparisons between the parallel and sequential implementations are presented. Then, these methods are used in the image processing field. It have been built a median filter based on these submitted algorithms. As the parallel platform is unavailable, the time is computed in terms of a number of computations steps and communications steps

A specimen of parallel programming

One common example of parallel processing is the implementation of the merge sort within a parallel processing environment. In the fully parallel model, you repeatedly split the sublists down to the point where you have single-element lists [3]. You then merge these in parallel back up the processing tree until you obtain the fully merged list at the top of the tree. While of theoretical interest, you probably don't have the massively parallel processor that this would require. Instead, you can use a mixed strategy. Determine the number of parallel processes you can realistically obtain within your computing environment. Then construct the processing tree so that you have that number of leaf nodes. Within the leaf nodes of the processing tree, simply use the best sequential algorithm to accomplish the sorting, and send that result upstream to the internal nodes of the processing tree, which will merge the sorted sublists and then send the resulting list farther upstream in the tree. Figure One shows the processing tree for the case in which you have a list of 2000 items to be sorted and have resources only sufficient for four parallel processes. The processes receiving the size 500 lists use some sequential sorting algorithm. Because of the implementation environment, it will be something in the C/C++ language---either qsort() or your favorite implementation of a fast sorting algorithm. Each leaf node (with a size 500 list) then provides the sorted result to the parent process within the processing tree. That process combines the two lists to generate a size 1000 list, and then sends that result upstream to its parent process. Finally, the root process in the processing tree merges the two lists to obtain a size 2000 list, fully sorted. If your environment supports more parallel processes, you might take the processing tree to four levels, so that eight processes do the sequential sorting of size 250 lists. For that matter, you could even deal with circumstances in which the supported number of parallel processes is not an exact power of two. That just means that some of the leaf nodes will be at the bottommost level and some conceptually at a higher level above in the processing tree. Since in parallel processing, the time required is the time required by the slowest process, you will probably want to stick with circumstances where the number of leaf nodes is a power of two---in other words, the processing tree is a full binary tree and all leaf nodes are doing approximately the same amount of work.

The use of single-point measurements to characterize dynamic behavior in sprays

In an effort to derive dynamic information from a single-particle counting device such as the phase-Doppler interferometer (PDI), a one-dimensional motion model and a sequential sorting algorithm have been developed to calculate the distance and velocity difference between consecutive droplets in sprays, as well as the number of droplets in close proximity (grouplets) and the frequency of grouplet formation. By focusing on sprays that are primarily uni-directional, this model can be used to highlight dynamic behavior and provide information that may indicate tendencies for clustering, collision, coalescence or evaporation among the droplets – information that is not available when considering the histograms of droplet size and velocity normally produced by PDIs. The motion model and sorting algorithm are validated for a mono-sized droplet stream generated by piezo-electric excitation, and are then applied to two other sprays to determine dynamic behavior. For a pressurized-liquid nozzle emitting water, the expected trends of droplet deceleration and spatial dispersion are found moving away from the exit of the nozzle, and significant in velocity differences between closely-spaced droplet pairs are observed. No dominant frequencies are present in the grouping of the droplets. For a droplet-laden air jet excited at a known frequency, similar results are calculated for droplet spacing, grouping and velocity differences, and the driving frequency is also obtained from analysis of the sequentially-sorted PDI data. Although the models developed assume an idealized PDI system, real operating characteristics of PDI systems place limits on the accuracy of these analyses.

Sorting in Parallel

Although more than a century passed before Menabrea's vision became a reality, today parallel computers with hundreds and even thousands of processors are used in a broad range of applications. One of the great challenges of parallel computing is the design of algorithms that make efficient use of the large number of processors in the machine. In this paper we explore parallel algorithms for one of the most fundamental problems in computer science: the problem of sorting a list of numbers. Specifically, given a list a1, a2, ... , an of integers, the sorting problem is that of finding a permutation of this list, 7T, such that a.(l) < a.(2) < ...< a(n) Before considering parallel sorting algorithms, we examine a sequential sorting algorithm; an algorithm for a computer with a single processor. One sequential algorithm for sorting is known as selection sort. The selection sort algorithm first examines each of the n integers a1, ... , an to find an integer ai with minimum value. Elements a1 and ai are then exchanged so that the element with minimum value is now in the first position in the list. Next, the algorithm examines each of the n 1 integers a2, ... ., an to find an integer with minimum value in this portion of the list. This integer is exchanged with a2 so that now the second smallest integer is in the second position in the list. In general, in the k th iteration the algorithm examines integers ak, .. , an, finds a minimum element in this list, and exchanges it with ak. At the end of nth iteration, the list is sorted. Observe that the first iteration of the algorithm requires n steps to find an element with minimum value and then some constant additional number of steps, c, to exchange this minimum value with a1. The next iteration requires n 1 steps to locate a minimum value in the remaining list and c steps to perform the exchange. In general, the kth iteration requires n k + 1 steps to locate a minimum value in the remaining list and c steps to perform the exchange. Since there are n iterations, the total number of steps or running time of the algorithm is

BOTTOM-UP-HEAPSORT, a new variant of HEAPSORT beating, on an average, QUICKSORT (if n is not very small)

A variant of HEAPSORT, called BOTTOM-UP-HEAPSORT, is presented. It is based on a new reheap procedure. This sequential sorting algorithm is easy to implement and beats, on an average, QUICKSORT if n⩾400 and a clever version of QUICKSORT (where the split object is the median of 3 randomly chosen objects) if n⩾16000. The worst-case number of comparisons is bounded by 1.5 n log n+O( n). Moreover, the new reheap procedure improves the delete procedure for the heap data structure for all n.

A Lower Bound on the Size of Shellsort Sorting Networks

Shellsort is a sorting algorithm that is based on a set of parameters called increments. Shellsort has been used both as a sequential sorting algorithm and as a sorting network. The central result of this paper is that all Shellsort sorting networks based on monotonically decreasing increments require $\Omega (N\log ^2 {N / {\log \log N}})$ comparators. Previously, only the trivial $\Omega (N\log N)$ bound was known for this class of networks. The lower bound obtained in this paper nearly matches the upper bound of $O(N\log ^2 N)$ that was proven by Pratt.