KMITL

Permanent URI for this communityhttps://dspace.kmitl.ac.th/handle/123456789/1

Browse

Search Results

Now showing 1 - 7 of 7
  • Some of the metrics are blocked by your 
    Item type:Item,
    Optimizing MultiStack parallel (MSP) sorting algorithm
    (2021-06-02)
    Rattanatranurak, Apisit
    ;
    Kittitornkun, Surin
    Mobile smartphones/laptops are becoming much more powerful in terms of core count and memory capacity. Demanding games and parallel applications/algorithms can hopefully take advantages of the hardware. Our parallel MSPSort algorithm is one of those examples. However, MSPSort can be optimized and fine tuned even further to achieve its highest capabilities. To evaluate the effectiveness of MSPSort, two Linux systems are quad core ARM Cortex-A72 and 24-core AMD ThreadRipper R9-2920. It has been demonstrated that MSPSort is comparable to the well-known parallel standard template library sorting functions, i.e. Balanced QuickSort and Multiway MergeSort in various aspects such as run time and memory requirements.
  • Some of the metrics are blocked by your 
    Item type:Item,
    A Parallel Multi-Deque Sorting Algorithm
    (2021-01-01)
    Kittitornkun, Surin
    ;
    Rattanatranurak, Apisit
    Parallel or multithreaded sorting algorithms have been proposed and researched for multicore and manycore CPU and GPU systems. Some of them are based on divide and conquer concept to exploit data parallelism as well as task parallelism at the same time. In this paper, a Multi-Deque Sort (MDQSort) is proposed and developed on top of our previous algorithm called Multi-Stack (MSP) Sort. Therefore, the MDQSort can easily enhance the performance while getting rid of weaknesses of MSPSort. As a result, MDQSort can be as competitive as the Standard Template Library parallel mode sorting algorithms on a 4-core ARM Cortex A72 Linux system in terms of run time, stability, CPU utilization and memory (RAM) utilization.
  • Some of the metrics are blocked by your 
    Item type:Item,
    A MultiStack Parallel (MSP) partition algorithm applied to sorting
    (2020-09-09)
    Rattanatranurak, Apisit
    ;
    Kittitornkun, Surin
    The CPUs of smartphones are becoming multicore with huge RAM and storage to support a variety of multimedia applications in the near future. A MultiStack Parallel (MSP) sorting algorithm is proposed and named MSPSort to support manycore systems. It can be regarded as many threads of single-pivot interleaving block-based Hoare’s algorithm. Each thread performs compare-swap operations between left and right (stacked and interleaved) data blocks. A number of multithreading features of OpenMP and our own optimization strategies have been utilized. To simulate those smartphones, MSPSort is fine tuned and tested on four Linux systems, e.g. Intel i7-2600, Xeon X5670, AMD R7-1700 and R9-2920. Their memory configurations can be classified as either uniform or non-uniform memory access. The statistical results are satisfied compared to parallel-mode sorting algorithms of Standard Template Library, namely Balanced QuickSort and MultiWay MergeSort. Moreover, MSPSort looks promising to be developed further to improve both run time and stability.
  • Some of the metrics are blocked by your 
    Item type:Item,
    A Parallel Triple-Pivot Sorting (PTPSort) Algorithm: Preliminary Results
    (2020-06-01)
    Rattanatranurak, Apisit
    ;
    Kittitornkun, Surin
    Parallel or multithreaded sorting algorithms can be useful for data science/analytics and other applications for manycore CPU systems. A Parallel Triple Pivot Sort (PTPSort) is devised based on the Hoare's partition algorithm. The input array is initially partitioned with two pivots, PLo and PHi in parallel with two threads. Subsequently, the middle pivot, PMi, is applied resulting in approximately two halves. Finally, four subarrays can be obtained from two independent threads partitioning each leftover half with PLo and PHi, respectively. The process is recursively forked as threads until the subarray is shorter than a cutoff threshold and then STLSorted in parallel. However, its preliminary execution time is a bit longer than that of our benchmark, a parallel original Hoare's algorithm, on a 24-thread AMD ThreadRipper 2920x Linux system.
  • Some of the metrics are blocked by your 
    Item type:Item,
    A Parallel Dual-Pivot QuickSort Algorithm with Lomuto Partition
    (2018-08-21)
    Taotiamton, Surapong
    ;
    Kittitornkun, Surin
    Sorting is one of the basic problems in computer Science and big data analytics. This paper presents a parallel Dual Pivot QuickSort (PDPSort) for manycore CPU systems. PDPSort makes use of the classic Lomuto partioning algorithm with two pivot values in parallel. It is developed in C++ and linked with OpenMP 4.5. PDPSort is compatible with the Standard Template Library sort (STLSort). The comparison includes run time, Speedup over STLSort and CPU utilization. PDPSort is faster than STLSort by 6.13×,3.54× and 2.99× on an 8-core 16-thread AMD R7-1700, an 8-core 8-thread AMD FX-8320 and a 4-core Intel i7-2600 Linux systems, respectively.
  • Some of the metrics are blocked by your 
    Item type:Item,
    Parallel hybrid dual pivot sorting algorithm
    (2017-11-03)
    Taotiamton, Surapong
    ;
    Kittitornkun, Surin
    Sorting is one of the common problems in Computer Science and data analytics. This paper presents empirical results of parallel Hybrid Dual Pivot Sort (HDPSort) for multicore/manycore CPU systems. HDPSort makes use of both classic Lomuto and Hoare partioning algorithms with two pivot values in parallel. It is developed in C++ with OpenMP 3.0 or better. HDPSort is benchmarked with the sequential STLSort in terms of run time, instruction count and branch load. The Speedups of HDPSort are up to 3.02× and 2.79× faster than the STLSort on 8-core AMD FX-8320 and 4-core Intel i7-2600 Linux systems, respectively. An indepth analysis shows that HDPSort gains the Speedup by 300% over STLSort at the expense of 1%-4% of branch mispredictions.
  • Some of the metrics are blocked by your 
    Item type:Item,
    Parallel Partition and Merge QuickSort (PPMQSort) on Multicore CPUs
    (2016-03-01)
    Ranokphanuwat, Ratthaslip
    ;
    Kittitornkun, Surin
    An explosive amount of data has tremendous impacts on sorting, searching, indexing, and so on. Sorting is one of the basic Computer Science problems needed to be fast and efficient to serve Big Data. This paper presents an efficient and scalable algorithm called Parallel Partition and Merge QuickSort (PPMQSort) running on any shared memory/multicore/multi-socket systems. Together with OpenMP 3.0 library, the PPMQSort is developed to be compatible and benchmarked with the fastest C/C++ Stdlib qsort(). The PPMQSort recursively divides an unsorted input array into partially sorted partitions up to Cutoff length using nested multithreading. Finally, those independent partitions are qsort() (conquered) such that no synchronizations are needed. The resulting Speedup of 12.29 (Formula presented.) on a dual-socket 8-core Xeon E5520 can be achieved for sorting random 200 M 32-bit integer data at 16 threads. With the same configuration, a 4-core AMD A6-3600 CPU (non-HyperThread) can reach up to 4.67 (Formula presented.) , a superlinear Speedup. It has been proved that the proposed PPMQSort can exploit all available cache levels and HyperThread CPU cores well thus utilizing up to 83 % and 96 % of CPU on E5520 and A6-3600, respectively.