int mergesort( int *array, int size ) {
int *front = ( int* )malloc( sizeof(int) * size );
int *back = ( int* )malloc( sizeof(int) * size );
for( int i = 0; i < size; i++ ) {
*(front+i) = *(array+i);
*(back+i) = *(array+i);
}
printf( "////////////////////////////////////////\n" );
printf( "// merge sort start\n" );
disp( front , size );
for( int block_size = 1; block_size < size; block_size*=2 ) {
for( int start = 0; start < size; start+=(block_size*2) ) {
merge_swap( front, back, start, block_size, size );
}
int *temp = (int*)back;
back = front;
front = temp;
disp( front , size );
}
printf( "// result\n" );
disp( front , size );
free( front );
free( back );
return 0;
}
/**
* Helper function.
* PRECONDITION: a<=mid<=b
*/
void merge_recursive(tour_t** tours, int a, int mid, int b)
{
int i,j;
for (i=a;i<=mid;i++)
{
for (j=mid+1;j<=b;j++)
{
if (tours[j]->fitness >= tours[i]->fitness)
break;
else
{
merge_swap(&tours[i],&tours[j]);
merge_sort(tours,j,b);
}
}
}
}
void merge_sort(tour_t** tours, int a, int b)
{
if (b-a > 1)
{
// recursive step
int middex = (a+b)/2;
merge_sort(tours, a, middex);
merge_sort(tours, middex+1, b);
// return the recursive merge
merge_recursive(tours,a,middex,b);
}
else
{
// base step
if (tours[b]->fitness < tours[a]->fitness)
merge_swap(&tours[a],&tours[b]);
}
}
int main(int argc, char** argv) {
int i, n;
int* A;
clock_t start, end;
double elapsed_time, t1, t2;
MPI_Init(NULL, NULL);
int world_rank;
MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
int world_size;
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
t1 = MPI_Wtime();
if(world_rank == 0) {
A = (int *)malloc(sizeof(int)*N);
if (A == NULL) {
printf("Fail to malloc\n");
exit(0);
}
for (i=N-1; i>=0; i--)
A[N-1-i] = i;
if (isSorted(A, N))
printf("Array is sorted\n");
else
printf("Array is NOT sorted\n");
}
//Scatter
int *sub_A = (int *)malloc(sizeof(int) * N/world_size);
assert(sub_A != NULL);
MPI_Scatter(A, N/world_size, MPI_INT, sub_A, N/world_size, MPI_INT, 0, MPI_COMM_WORLD);
// if(world_rank == 0){
// printf("Rank: %d \n", world_rank);
// printArray(&sub_A[0], 10);
// }
bubbleSort(sub_A, N/world_size);
printf("Rank: %d isSorted: %d\n", world_rank, isSorted(sub_A, N/world_size));
// printArray(sub_A, N/world_size);
//Gather
int *result = NULL;
if(world_rank == 0){
result = (int *)malloc(sizeof(int) * N);
}
MPI_Gather(sub_A, N/world_size, MPI_INT, result, N/world_size, MPI_INT, 0, MPI_COMM_WORLD);
if(world_rank == 0){
printArray(&result[0], N);
for(i = 0; i < world_size/2; i++){
merge_swap(&result[N/world_size*i], &result[N/world_size*(world_size-i-1)], world_size);
}
printArray(&result[0], N);
}
// printArray(&result[0], N);
// printArray(&result[N-10], 10);
// printArray(&A[N-10], 10);
// if (isSorted(A, N))
// printf("Array is sorted\n");
// else
// printf("Array is NOT sorted\n");
// t2 = MPI_Wtime();
// printf( "Elapsed time MPI_Wtime is %f\n", t2 - t1 );
MPI_Finalize();
return 0;
}
