Merge Sort (pthreads) C++ [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 8 years ago.
Improve this question
I'm kinda new to pthreads and I'm trying to create a program that sorts 1 million randomly generated integers. I seem to have lost a bit of control over the threads. When run the first time, the code only produces a single thread, but when subsequently run, the thread, the threads multiply out of control. Since I don't really know precisely where the problem lies, I've provided the code below.
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <iostream>
#define N 8 /* # of thread */
#define NUM_INTS 10000 //ideally should be able to sort 1,000,000
int int_list[NUM_INTS];
/* structure for array index
* used to keep low/high end of sub arrays
*/
typedef struct Arr {
int low;
int high;
} ArrayIndex;
void merge(int low, int high) {
int mid = (low+high)/2;
int left = low;
int right = mid+1;
int list_b[high-low+1];
volatile int i, cur = 0;
while((left <= mid) && (right <= high)) {
if (int_list[left] > int_list[right])
list_b[cur++] = int_list[right++];
else
list_b[cur++] = int_list[right++];
}
while(left <= mid)
list_b[cur++] = int_list[left++];
while(right <= high)
list_b[cur++] = int_list[left++];
for (i = 0; i < (high-low+1) ; i++)
int_list[low+i] = list_b[i];
}
void * mergesort(void *a){
ArrayIndex *pa = (ArrayIndex *)int_list;
int mid = (pa->low + pa->high)/2;
ArrayIndex aIndex[N];
pthread_t thread[N];
aIndex[0].low = pa->low;
aIndex[0].high = mid;
aIndex[1].low = mid+1;
aIndex[1].high = pa->high;
if (pa->low >= pa->high)
return 0;
volatile int i;
for(i = 0; i < N; i++)
pthread_create(&thread[i], NULL, mergesort, &aIndex[i]);
for(i = 0; i < N; i++)
pthread_join(thread[i], NULL);
merge(pa->low, pa->high);
pthread_exit(NULL);
}
int main(){
volatile int i;
struct timeval start_time, end_time;
srand(getpid());
for(i=0; i<NUM_INTS; i++)
int_list[i] = rand();
ArrayIndex ai;
ai.low = 0;
ai.high = NUM_INTS/sizeof(int_list[0])-1;
pthread_t thread;
pthread_create(&thread, NULL, mergesort, &ai);
pthread_join(thread, NULL);
return 0;
}
gdb output:
(gdb) run
Starting program: /.../sort.o
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[New Thread 0x7ffff6fd5700 (LWP 25801)]
[Thread 0x7ffff6fd5700 (LWP 25801) exited]
Computation Time: 38006 micro-seconds.
[Inferior 1 (process 25797) exited normally]
(gdb) run
Starting program: /.../sort.o
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[New Thread 0x7ffff6fd5700 (LWP 25804)]
[New Thread 0x7ffff67d4700 (LWP 25805)]
[New Thread 0x7ffff5fd3700 (LWP 25806)]
[New Thread 0x7ffff57d2700 (LWP 25807)]
[New Thread 0x7ffff4fd1700 (LWP 25808)]
[New Thread 0x7fffef7fe700 (LWP 25811)]
[New Thread 0x7fffeeffd700 (LWP 25810)]
...
[New Thread 0x7ffeca6ec700 (LWP 26148)]
Program received signal SIGINT, Interrupt.
[Switching to Thread 0x7ffee8728700 (LWP 26088)]
__GI___nptl_create_event () at events.c:25
25 events.c: No such file or directory.

Answer 1

The problem is that you try to implement recursive divide-and-conquer parallelism by starting a new thread for each sub-problem, up to the point when a thread is given a single array item to "sort". This approach is just plain wrong for multiple reasons. To give you just one, sorting an array of 1 million items would require a million of threads at leaf calls of the recursion, and another million at all recursion levels above. Even if you introduce some grain size - a threshold after which the recursion becomes serial - the total amount of threads would still likely be very big, unless your threshold is something like NUM_INTS/N.
Even not counting the above, your implementation has some bugs:
at each level of recursion, you start N threads, even though the work is split just in halves. aIndex[i] is uninitialized for i>1, so corresponding threads receive garbage in their input parameter.
you cast int_list, which is a pointer to int, to a pointer to ArrayIndex.
There are a few ways how you may fix the design:
The simple one is to introduce a proper threshold after which the recursion becomes serial, as I said above.
The more complex one - but also more generic and flexible - is to implement a pool of threads and a pool/queue of tasks processed by the threads; so when you split the given array in halves you create two tasks for processing each half and submit these tasks to the work queue where threads take work from. Note that for good performance you would still require to set some grain size in order to have sufficient amount of work per task, but that would be much smaller threshold than the one necessary to limit the number of threads.
The right one, especially for production code, is to take a library or parallel technology that has proper primitives for recursive parallelism, such as Intel's Threading Building Blocks (tbb) or Microsoft's Parallel Patterns Library (ppl).
See also some links (and generally, google for "parallel merge sort C++")
performance problems in parallel mergesort C++
https://software.intel.com/en-us/articles/a-parallel-stable-sort-using-c11-for-tbb-cilk-plus-and-openmp
http://www.drdobbs.com/parallel/parallel-merge-sort/229400239