Evaluation of Execution Time by Various Multicore Processors on the Parallel Sorting Algorithm

Author(s):  
Pranjal Joshi ◽  
Pankaj Acharya
2018 ◽  
Vol 28 (04) ◽  
pp. 1850014
Author(s):  
Alexandros V. Gerbessiotis

Integer sorting on multicores and GPUs can be realized by a variety of approaches that include variants of distribution-based methods such as radix-sort, comparison-oriented algorithms such as deterministic regular sampling and random sampling parallel sorting, and network-based algorithms such as Batcher’s bitonic sorting algorithm. In this work we present an experimental study of integer sorting on multicore processors. We have implemented serial and parallel radix-sort for various radixes, deterministic regular oversampling, and random oversampling parallel sorting, including new variants of ours, and also some previously little explored or unexplored variants of bitonic-sort and odd-even transposition sort. The study uses multithreading and multiprocessing parallel programming libraries with the same C language code working under Open MPI, MulticoreBSP, and BSPlib. We first provide some general high-level observations on the performance of these implementations. If we can conclude anything is that accurate prediction of performance by taking into consideration architecture dependent features such as the structure and characteristics of multiple memory hierarchies is difficult and more often than not untenable. To some degree this is affected by the overhead imposed by the high-level library used in the programming effort. Another objective is to model the performance of these algorithms and their implementations under the MBSP (Multi-memory BSP) model. Despite the limitations mentioned above, we can still draw some reliable conclusions and reason about the performance of these implementations using the MBSP model, thus making MBSP useful and usable.


IEEE Micro ◽  
1995 ◽  
Vol 15 (3) ◽  
pp. 60-71 ◽  
Author(s):  
A. Louri ◽  
J.A. Hatch ◽  
Jongwhoa Na

1984 ◽  
Vol 24 (2) ◽  
pp. 187-195 ◽  
Author(s):  
S. S. Tseng ◽  
R. C. T. Lee

2020 ◽  
Vol 11 (2) ◽  
pp. 95-102
Author(s):  
I Nyoman Aditya Yudiswara ◽  
Abba Suganda

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.


Sign in / Sign up

Export Citation Format

Share Document