scholarly journals Fully Flexible Parallel Merge Sort for Multicore Architectures

Complexity ◽  
2018 ◽  
Vol 2018 ◽  
pp. 1-19 ◽  
Author(s):  
Zbigniew Marszałek ◽  
Marcin Woźniak ◽  
Dawid Połap

The development in multicore architectures gives a new line of processors that can flexibly distribute tasks between their logical cores. These need flexible models of efficient algorithms, both fast and stable. A new line of efficient sorting algorithms can support these systems to efficiently use all available resources. Processes and calculations shall be flexibly distributed between cores to make the performance as high as possible. In this article we present a fully flexible sorting method designed for parallel processing. The idea we describe in this article is based on modified merge sort, which in parallel form is designed for multicore architectures. The novelty of this idea is in particular way of processing. We have developed a fully flexible method that can be implemented for a number of processors. The tasks are flexibly distributed between logical cores to increase the efficiency of sorting. The method preserves separation of concerns; therefore, each of the processors works separately without any cross actions and interruptions. The proposed method was described in theoretical way, examined in tests, and compared to other methods. The results confirm high efficiency and show that with each newly added processor sorting becomes faster and more efficient.

2012 ◽  
Vol 433-440 ◽  
pp. 3900-3904
Author(s):  
Lai Lai Win Kyi ◽  
Nay Min Tun

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.


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.


1994 ◽  
Vol 04 (04) ◽  
pp. 429-436 ◽  
Author(s):  
SANJEEV SAXENA ◽  
P.C.P. BHATT ◽  
V.C. PRASAD

We prove that prefix sums of n integers of at most b bits can be found on a COMMON CRCW PRAM in [Formula: see text] time with a linear time-processor product. The algorithm is optimally fast, for any polynomial number of processors. In particular, if [Formula: see text] the time taken is [Formula: see text]. This is a generalisation of previous result. The previous [Formula: see text] time algorithm was valid only for O(log n)-bit numbers. Application of this algorithm to r-way parallel merge sort algorithm is also considered. We also consider a more realistic PRAM variant, in which the word size, m, may be smaller than b (m≥log n). On this model, prefix sums can be found in [Formula: see text] optimal time.


1994 ◽  
Vol 30 (5) ◽  
pp. 631-647 ◽  
Author(s):  
Ya. E. Romm
Keyword(s):  

Author(s):  
Klaus Schoeffmann ◽  
David Ahlström

Many image browsing tools employ a scrollable grid-like arrangement of thumbnails of images for enabling users to browse through image collections. The thumbnails in these arrangements are typically sorted by some kind of metadata, e.g., by filename or creation date. However, users looking for a specific image in mind prefer search by visual similarity rather than search based on simple metadata. In difference to previous work, which rarely present results from user studies, the authors provide empirical evidence that color sorting is an effective approach for that purpose. With a user survey, the authors identify which of six alternative color sorting algorithms produces the most intuitive result. The authors use the best algorithm, a simple HSV-based sorting method, and compare users’ visual search performance in a color sorted storyboard against performance in an unsorted storyboard. The results show that color sorting can improve user interaction, both in terms of subjective impressions and visual search times.


2014 ◽  
Vol 701-702 ◽  
pp. 24-29
Author(s):  
Jun Zhang ◽  
Yong Ping Gao ◽  
Yue Shun He ◽  
Xue Yuan Wang

Two-way merge sort algorithm has a good time efficiency which has been used widely. The sort algorithm can be improved on speed and efficient based on its own potential parallelism via the parallel processing capacity of multi-core processor and the convenient programming interface of OpenMP. The time complexity is improved to O(nlog2n/TNUM) and inversely proportional to the number of parallel threads. The experiment results show that the improved two-way merge sort algorithm become much more efficient compared to the traditional one.


Sign in / Sign up

Export Citation Format

Share Document