mpi并行排序

//��������ʱ����ֻ����windowsƽ̨ʹ�ã���������������Ϊ�Դ���timeֻ�ܾ�ȷ����

#include <iostream>
#include <mpi.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <limits.h>
#include <fstream>
#define TOTAL_SIZE 6250000
#define size TOTAL_SIZE/process_num
using namespace std;

int getStandard(int array[], int i, int j) {
    // 基准数据
    int key = array[i];
    while (i < j) {
        // 因为默认基准是从左边开始，所以从右边开始比较
        // 当队尾的元素大于等于基准数据 时,就一直向前挪动 j 指针
        while (i < j && array[j] >= key) {
            j--;
        }
        // 当找到比 array[i] 小的时，就把后面的值 array[j] 赋给它
        if (i < j) {
            array[i] = array[j];
        }
        // 当队首元素小于等于基准数据 时,就一直向后挪动 i 指针
        while (i < j && array[i] <= key) {
            i++;
        }
        // 当找到比 array[j] 大的时，就把前面的值 array[i] 赋给它
        if (i < j) {
            array[j] = array[i];
        }
    }
    // 跳出循环时 i 和 j 相等,此时的 i 或 j 就是 key 的正确索引位置
    // 把基准数据赋给正确位置
    array[i] = key;
    return i;
}

void QuickSort(int array[], int low, int high) {
    // 开始默认基准为 low
    if (low < high) {
        // 分段位置下标
        int standard = getStandard(array, low, high);
        // 递归调用排序
        // 左边排序
        QuickSort(array, low, standard - 1);
        // 右边排序
        QuickSort(array, standard + 1, high);
    }
}

//void bubblingSort(int arr[], int n) {
//	int i, j, temp;
//	// ÿ�ν�һ��Ԫ���͵�ĩβ��n��Ԫ�أ�ִ��n��
//	for (i = 0; i < n; ++i) {
//		// ֮ǰ��ѭ���Ѿ���i��Ԫ���͵�ĩβ������Ҫ�ٴαȽϣ��ʼ�ȥ����Ϊ����һ��Ԫ�رȽϣ�Ϊ�˱����������ʼ�һ
//		for (j = 0; j < n - i - 1; ++j) {
//			// ������ǰ��Ԫ�رȺ�һ��Ԫ��С���ͽ���
//			if (arr[j] > arr[j + 1]) {
//				temp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = temp;
//			}
//		}
//	}
//	//printf("no use?");
//}

int main(int argc, char* argv[])
{
	double s = time(NULL);


	int *original_array = new int[TOTAL_SIZE];
	int *sorted_array = new int[TOTAL_SIZE];
	int c;
	srand(time(NULL));
	int world_rank;
	int process_num;
	MPI_Init(&argc, &argv);
	string data_num=argv[1];
	MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
	MPI_Comm_size(MPI_COMM_WORLD, &process_num);
	if (world_rank == 0)
	{
                //printf("This is the unsorted array: ");

        fstream in;
        string address1 = "/data/data"+data_num+".txt";
        in.open(address1.c_str(),ios::in);
        string x;
        for(int i =0;i<TOTAL_SIZE;i++) {
            in >> x;
            int x1 = atoi(x.c_str());
            original_array[i] =x1;
           // cout << x1 <<' ';
        }

//		for (c = 0; c < TOTAL_SIZE; c++)
//		{
//			original_array[c] = rand() % TOTAL_SIZE;
//			printf("%d ", original_array[c]);
//		}
		printf("\n");
		printf("\n");
	}
	int start_time, end_time;
	start_time = MPI_Wtime();//���㿪ʼʱ��
//	int *sub_array = (int *)malloc(size * sizeof(int));
	int *sub_array = new int [size];

	MPI_Scatter(original_array, size, MPI_INT, sub_array, size, MPI_INT, 0, MPI_COMM_WORLD);

//	bubblingSort(sub_array, size);
	QuickSort(sub_array,0,size-1);

	MPI_Gather(sub_array, size, MPI_INT, sorted_array, size, MPI_INT, 0, MPI_COMM_WORLD);


	if (world_rank == 0)//�����Ļ��ܽ���0�Ž���
	{
		int *current_num = (int *)malloc(process_num * sizeof(int));//���������ӽ������鵱ǰ��Ҫ�Ƚϵ�ֵ
		int *sub_num = (int *)malloc(process_num * sizeof(int));//���������ӽ��������Ѿ�������ֵ����ֹԽ������
		for (int i = 0; i < process_num; ++i) {
			sub_num[i] = 0;//��ʼ��
		}
//		int final_array[TOTAL_SIZE];//����������������
		int *final_array=new int[TOTAL_SIZE];
		int min;//����ÿ�αȽϵ���Сֵ
		int min_num;//����ÿ�αȽ���Сֵ��Ӧ�Ľ��̺�

                //printf("This is the sorted array: ");
                cout<<"Sorting completed and ready to write to file"<<endl;
                ofstream out;
                string address2 = "/data/sorted_data"+data_num+".txt";
                out.open(address2.c_str(),ios::out);

		for (c = 0; c < TOTAL_SIZE; c++)
		{
			for (int k = 0; k < process_num; ++k) {
				if (sub_num[k] >= size) {
					current_num[k] = INT_MAX;//Խ�磬����limits.h���꣬��ʾ����ֵ
				}
				else{
					current_num[k] = sorted_array[k*size + sub_num[k]];//��ȡ��ǰ��Ҫ�Ƚϵ�ֵ
				}
			}
			min = INT_MAX;//ÿ�αȽ϶�Ҫ��min������ʼ��
			for (int i=0; i < process_num; ++i) {
				if (current_num[i] < min) {
					min = current_num[i];
					min_num = i;
				}
			}
			sub_num[min_num] += 1;

			final_array[c] = min;
			out<<min<<' ';
                        //printf("%d ",min);

		}
		printf("\n");
		printf("\n");

		end_time = MPI_Wtime();
                cout<<"Totally, the time it takes is:"<<(end_time - start_time)<<" s"<<endl;

		free(sub_num);//�ͷ��ڴ�
		free(current_num);
		sub_num = NULL;
		current_num = NULL;//��ֹ����Ұָ��
		delete [] final_array;
	}
	//ÿ�����̶����ͷ��ڴ�
	sub_array = NULL;
	MPI_Finalize();
	delete [] original_array;
	delete [] sorted_array;
	delete [] sub_array;
	return 0;
}