Parallel Sort Library that is more efficient version 4.1
Author: Amine Moulay Ramdane
Description:
Parallel Sort Library that supports Parallel Quicksort, Parallel HeapSort and Parallel MergeSort on Multicores systems.
Notice also in the source code that my Mergesort uses also insertion sort like in a Timsort manner, so it is very efficient.
Parallel Sort Library uses my Thread Pool Engine and sort many array parts - of your array - in parallel using Quicksort or HeapSort or MergeSort and after that it finally merge them - with the merge() procedure -
In the previous parallelsort version i have parallelized only the sort part, but in this new parallelsort version i have parallelized also the merge procedure part and it gives better performance.
My new parallel sort algorithm has become more cache-aware, and i have done some benchmarks with my new parallel algorithm and it has given up to 5X scalability on a Quadcore when sorting strings, other than that i have cleaned more the code and i think my parallel Sort library has become a more professional and industrial parallel Sort library , you can be confident cause i have tested it thoroughly and no bugs have showed , so i hope you will be happy with my new Parallel Sort library.
I have also included a "test.pas" example, just compile first the "gendata.pas" inside the zip file and run it first, after that compile the "test.pas" example and run it and do your benchmarks.
I have implemented a Parallel hybrid divide-and-conquer merge algorithm that performs 0.9-5.8 times better than sequential merge, on a quad-core processor, with larger arrays outperforming by over 5 times. Parallel processing combined with a hybrid algorithm approach provides a powerful high performance result.
My algorithm of finding the median of Parallel merge of my Parallel Sort Library that you will find here in my website:
https://sites.google.com/site/scalable68/parallel-sort-library
Is O(log(min(|A|,|B|))), where |A| is the size of A, since the binary search is performed within the smaller array and is O(lgN). But this new algorithm of finding the median of parallel merge of my Parallel Sort Library is O(log(|A|+|B|)), which is slightly worse. With further optimizations the order was reduced to O(log(2*min(|A|,|B|))), which is better, but is 2X more work, since both arrays may have to be searched. All algorithms are logarithmic. Two binary searches were necessary to find an even split that produced two equal or nearly equal halves. Luckily, this part of the merge algorithm is not performance critical. So, more effort can be spent looking for a better split. This new algorithm in the parallel merge balances the recursive binary tree of the divide-and-conquer and improve the worst-case performance of parallel merge sort.
Why are we finding the median in the parallel algorithm ?
Here is my previous idea of finding the median that is O(log(min(|A|,|B|))) to understand better:
Let's assume we want to merge sorted arrays X and Y. Select X[m] median element in X. Elements in X[ .. m-1] are less than or equal to X[m]. Using binary search find index k of the first element in Y greater than X[m]. Thus Y[ .. k-1] are less than or equal to X[m] as well. Elements in X[m+1..] are greater than or equal to X[m] and Y[k .. ] are greater. So merge(X, Y) can be defined as concat(merge(X[ .. m-1], Y[ .. k-1]), X[m], merge(X[m+1.. ], Y[k .. ])) now we can recursively in parallel do merge(X[ .. m-1], Y[ .. k-1]) and merge(X[m+1 .. ], Y[k .. ]) and then concat results.
The best case time complexity of ParallelSort using mergesort is:
((n/p)* log(n/p)) + O(n/p)
p: is the number of cores
the ((n/p)* log(n/p)) is the time complexity of the sorting part.
O(n/p) is the best case time complexity of the merging part.
so the best case time complexity is: ((n/p)* log(n/p))
The worst case time complexity of parallel sort library using mergesort is:
((n/p)* log(n/p)) + O(n/p)
the ((n/p)* log(n/p)) is the time complexity of the sorting part.
O(n/p) is the worst case time complexity of the merging part.
so the worst case time complexity of parallelsort using mergesort is approximatly: ((n/p)* log(n/p))
I have done some tests with my ParallelSort library and i have noticed that it can give up to 5X scalability with strings, and it gives 3x scalability with integers on a quad cores.
So, why it scales to 5X with strings and only 3x with integers on a quad cores ?
I explain:
In the SequentialMerge() method and QSort() method inside Parallel Sort library, i am calling the Scompare() method and also in both of them i am copying to the memory system.
So when i am using strings the SCompare() method is more expensive, so the parallel part p in the Amdahl equation 1/ S + P/N (S: the serial part, P: parallel part and N: the number of cores) is bigger than with integers so the Amdahl equation will scale better, but when we are using integers the SCompare() method is less expensive than the SCompare() with strings, so the parallel part p in the Amdahl equation is less bigger than with strings. so this is why parallel sorting with strings scales better than with integers.
I have implemented mergsort and quicksort, but as you know the complexity of mergesort in the worst case is better than quicksort , and the mergesort that i have implemented is faster than quicksort, but mergesort takes more space..
One way to parallelize the sorts is:
- Divide the data among the processors
- Sort the data on the individual processors.
- Parallel Merge the various data
Note that the merge operation is a reduction operation !
I have done some scalability tests on my parallelsort library and i have come to the conclusion that parallel heapsort is better on scalability than parallel quicksort cause the P part (of the Amdahl equation) is bigger in parallel heapsort than in parallel quicksort, the parallel heapsort is doing more on the parallel part, it's why it scales better than parallel quicksort, but parallel quicksort is still faster than parallel heapsort on my tests on a quad core processor.
You have to set the number of cores in the constructor to power of 2 or 1.
You can go to download the zip files by clicking on the following web link:
https://drive.google.com/drive/folders/1hjAHPVdIoqmxk7Ajy4fXYaEuY_SdOuhP?usp=sharing
Language: FPC Pascal v2.2.0+ / Delphi 7+
Required FPC switches: -O3 -Sd
-Sd for delphi mode....
Operating Systems: Win , Linux and Mac (all x86).
Here is how to configure it from the defines.inc files:
{$DEFINE CPU32} and {$DEFINE Windows32} for 32 bit systems
{$DEFINE CPU64} and {$DEFINE Windows64} for 64 bit systems
Look at the test1.pas example to know how to use my ParallelSort library.