CS355, pthread project

Preparation

To do this project, you must obtain a copy of the prepared files with these commands:

Execute these commands:

mkdir ~/cs355/pthread cp /home/cs355001/Handouts/pthread/* ~/cs355/pthread

You should have these files:

main.c: single-threaded merge sort merge-sort.c: merge sort algorithm file + some support functions merge-sort.h: header file for merge-sort.c main-t.c: skeleton file for the multi-threaded merge sort project Makefile: make file for main and main-t programs

Project overview

In this project, you will write a multi-threaded program to sort an array

Important note:

This project is not an algorithm project
Meaning: you are not suppose to write any code for sorting

Purpose of this project:

You must organize the threads in your program so that it will perform

The merge sort algorithm

The file merge-sort.c contains 2 functions that constitute the merge sort algorithm

void merge (int a[], int iLeft, int iMiddle, int iRight, int tmp[])

merge() will merge the following 2 sorted segments:

Sorted array segement 1: a[iLeft] a[iLeft+1] .... a[iMiddle - 1] Sorted array segement 2: a[iMiddle] a[iMiddle+1] .... a[iRight - 1]

into 1 sorted array segment:

Sorted array segement: a[iLeft] a[iLeft+1] ... a[iMiddle - 1] a[iMiddle] ... a[iRight - 1]

(The tmp[ ] array in the parameter is a help variable used in the merge operation)

void mergeSort (int a[], int start, int stop, int tmp[] )

Example on how to use these functions: main.c:

The gist of the code in main.c is:

#define MAX 50000000 // Max array size int N; // Actual array size int x[MAX]; // input data int t[MAX]; // help array to perform merge int main(int argc, char *argv[]) { int i; N = some value; /* -------------------------------------- Generate random numbers to be sorted -------------------------------------- */ for (i = 0; i < N; i++) x[i] = random()%1000; mergeSort(x, 0, N, t ); // Sort the entire array }

Assignment: multi-threaded merge sort

Assignment:

Use the main-t.c skeletal file and write a multi-threaded merge sort program main-t that sort the array x[N]
Use the help array t[N] in the merge sort
In other words:
The program main-t accept 2 arguments:
The number of pieces can be: 1, 2, 4, 8, or 16.
So main-t can be run as:
(If N < 100, main-t will print the array before and after sorted --- acts as a visual tool for you to debug)

Sketch of the algorithm:

Logically partition the array x[N] into "num_threads" pieces
Sort each piece of the array with one thread
After this step, you will have N pieces of sorted array segments

Now you must merge the sorted pieces:

2 adjacent sorted pieces are merged

The merge step must proceed with multiple threads:

If num_threads = 2, then you only need to perform the merge step once using 1 thread

If num_threads = 4, then you will need to perform the merge step twice:

First merge step uses 2 threads and each thread merges 2 pairs of arrays
After this step, you will have 2 longer pieces of sorted arrays
Second merge step uses 1 thread and merges 2 pairs of longer arrays

If num_threads = 8, then you need to perform the merge step 3 times:

First merge step uses 4 threads and each thread merges 2 pairs of arrays
After this step, you will have 4 longer pieces of sorted arrays
Second merge step uses 2 thread and each thread merges 2 pairs of longer arrays
After this step, you will have 2 even longer pieces of sorted arrays
Final merge step uses 1 thread and merges 2 pairs of "longer longer" arrays

Note:

Print the state of the array x[N] after each merge step using:
It will help you find bugs....

Requirement:

The input array must be partioned into N equal chunks and all chunks must be sorted at the same time by different threads (= parallel)

If there are more than 1 pair of sorted chunks, your program must spawn threads to merge pairs of sorted chunks at the same time

So if you have 8 sorted chunks, you must spawn 4 threads and have each thread merge 2 sorted chunks as the same time.
This will result in 4 sorted (larger) chunks
When the previous step is completed, you will have 4 (larger) sorted chunks
Now you must spawn 2 threads and have each thread merge 2 sorted chunks as the same time.
Finally, you spawn 1 thread to merge the 2 sorted chunks

Check your output

I have provide a test program (main) that you can use to check the output of your program.

Run it using:

main N

Example:

main 80 Array before sorting: 383 886 777 915 793 335 386 492 649 421 362 27 690 59 763 926 540 426 172 736 211 368 567 429 782 530 862 123 67 135 929 802 22 58 69 167 393 456 11 42 229 373 421 919 784 537 198 324 315 370 413 526 91 980 956 873 862 170 996 281 305 925 84 327 336 505 846 729 313 857 124 895 582 545 814 367 434 364 43 750 Array AFTER sorting: 11 22 27 42 43 58 59 67 69 84 91 123 124 135 167 170 172 198 211 229 281 305 313 315 324 327 335 336 362 364 367 368 370 373 383 386 393 413 421 421 426 429 434 456 492 505 526 530 537 540 545 567 582 649 690 729 736 750 763 777 782 784 793 802 814 846 857 862 862 873 886 895 915 919 925 926 929 956 980 996 Good job: Array was sorted correctly ! **** Elapsed time = 20 microseconds

If array must be sorted when the program is done

The only difference between main and your main-t program will be the elapsed time:

Your program main-t should run NThreads times faster than main

Stress test

When you have tested your main-t.c for small array size (like 80), you should try the stress test on large array sizes:

main-t 10000000 2 (should finish in around 1322288 microseconds) main-t 10000000 4 (should finish in around 968839 microseconds) main-t 10000000 8 (should finish in around 744422 microseconds) main-t 10000000 16 (should finish in around 690425 microseconds)

If possible, log in to euler and you can use upto 40 threads !

Turn in
- Turn in your project using this procedure: