[Paper Review] Parallelize Bubble and Merge Sort Algorithms Using Message Passing Interface (MPI)

Zaid Abdi Alkareem Alyasseri, Kadhim Al-Attar+1 more|arXiv (Cornell University)|Nov 19, 2014

Parallel Computing and Optimization Techniques10 references3 citations

TL;DR

This paper proposes a parallel implementation of bubble and merge sort using Message Passing Interface (MPI) to improve sorting performance on multi-core systems. By distributing input data into sub-arrays based on word length and leveraging MPI with Intel i7-3610QM (8 CPUs), the authors evaluate two data structures—vectors of strings and 3D arrays—and find that the 3D array approach yields better performance due to reduced memory access overhead.

ABSTRACT

Sorting has been a profound area for the algorithmic researchers and many resources are invested to suggest more works for sorting algorithms. For this purpose, many existing sorting algorithms were observed in terms of the efficiency of the algorithmic complexity. In this paper we implemented the bubble and merge sort algorithms using Message Passing Interface (MPI) approach. The proposed work tested on two standard datasets (text file) with different size. The main idea of the proposed algorithm is distributing the elements of the input datasets into many additional temporary sub-arrays according to a number of characters in each word. The sizes of each of these sub-arrays are decided depending on a number of elements with the same number of characters in the input array. We implemented MPI using Intel core i7-3610QM ,(8 CPUs),using two approaches (vectors of string and array 3D) . Finally, we get the data structure effects on the performance of the algorithm for that we choice the second approach.

Motivation & Objective

• To enhance sorting efficiency through parallelization using MPI on multi-core architectures.
• To investigate the impact of data structure design (vectors of strings vs. 3D arrays) on sorting performance in a distributed environment.
• To evaluate the scalability and performance of parallelized bubble and merge sort on standard datasets of varying sizes.
• To determine the optimal method for distributing input data across processes based on word length characteristics.

Proposed method

• The input dataset is partitioned into sub-arrays based on the number of characters in each word to balance workload across processes.
• MPI is used to distribute data and coordinate communication between processes running on 8 CPUs of an Intel i7-3610QM processor.
• Two data structures are implemented: a vector of strings and a 3D array, to compare memory access patterns and performance.
• Bubble and merge sort algorithms are independently parallelized using MPI, with sorting performed locally on each sub-array before final merging (for merge sort).
• Performance is measured and compared across both data structures using standard text files of different sizes.
• The final decision on the better-performing approach is based on execution time and memory access efficiency.

Experimental results

Research questions

• RQ1 How does data partitioning by word length affect load balancing in parallel sorting using MPI?
• RQ2 What is the performance difference between using a vector of strings and a 3D array for storing and sorting distributed data in MPI?
• RQ3 How do bubble sort and merge sort scale when parallelized via MPI on a multi-core system?
• RQ4 What role does data structure design play in minimizing communication and memory overhead in parallel sorting?

Key findings

• The 3D array data structure outperformed the vector of strings due to improved memory locality and reduced access overhead.
• Parallel merge sort achieved better scalability and lower execution time compared to parallel bubble sort on larger datasets.
• Data partitioning based on word length effectively balanced workloads across processes, improving overall efficiency.
• The MPI-based implementation successfully reduced sorting time on multi-core systems, with measurable performance gains on larger inputs.