/***************************************/
/*************LAB 1 MPI*****************/
/***************************************/
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define M 3
#define N 15

int main( int argc, char *argv[] ){
    MPI_Init( &argc, &argv );
    int rank = 0;
    int i;
    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
    srand (time(NULL) + rank);
    double startwtime, endwtime;
    int *p_send, *p_recv;

    p_send = (int*) malloc(sizeof(int) * N);
    p_recv = (int*) malloc(sizeof(int) * N);

    startwtime = MPI_Wtime();

    printf("\nRank %i send: ", rank);
    for (i = 0; i < N; i++) {
        p_send[i] = rand() % 10;
        printf("%i ", p_send[i]);
    }
    printf("\n");

    MPI_Alltoall(p_send, M, MPI_INT, p_recv, M, MPI_INT, MPI_COMM_WORLD );

    printf("\nRank %i receive:\n", rank);
    for (i = 0; i < N; i++) {
        printf("%i ", p_recv[i]);
    }

    endwtime = MPI_Wtime();

    printf("\ntime = %f\n", endwtime - startwtime);
    printf("\n");

    MPI_Finalize();

    return 0;
}

/***************************************/
/*************LAB 2 MPI*****************/
/***************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mpi.h>

#define ROOT    0
#define M       10
#define N       3
#define RAND_RANGE 10
#define ABS(x) ((x < 0) ? -(x) : (x))

int main( int argc, char *argv[])
{
    int myid;
    int numprocs;
    int send_array[M];
    int *recv_buf;
    int i;
    double startwtime, endwtime;
    /* Инициализация библиотеки */
    srand(time(NULL));

    MPI_Init(&argc, &argv);
    /* Получаем общее количество запущенных процессов */
    MPI_Comm_size(MPI_COMM_WORLD, &numprocs);

    /* Получаем порядковый номер текущего процесса */
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);

    if (myid == ROOT) {
          recv_buf = (int *) malloc(M * sizeof(int));
    }

    for (i = 0; i < M; i++) {
        send_array[i] = (int) ABS((myid + 1) * rand() % RAND_RANGE);
    }
    int rank = 0;
    while (rank < numprocs) {
        if (myid == rank) {
            printf("\nrank = %d\t", myid);
            for (i = 0; i < M; i++) {
                printf ("%3d", send_array[i]);
            }
            fflush (stdout);
        }
        rank ++;
        MPI_Barrier (MPI_COMM_WORLD);
    }

    if (myid == ROOT){
          /* Засекаем время начала вычисления */
        startwtime = MPI_Wtime();
    }

    MPI_Reduce(send_array, recv_buf, M, MPI_INT, MPI_MAX, ROOT, MPI_COMM_WORLD);
    if (myid == ROOT) {
          /*Засекаем время окончания вычисления */
        endwtime = MPI_Wtime();
        printf("\n\nCollected data from processes:\n");
        for (i = 0; i < M; i++){
            printf("%6d", recv_buf[i]);
        }
        printf("\n");
        printf("time = %f\n", endwtime - startwtime);
    }

    MPI_Finalize();     /* Нормальное закрытие библиотеки */

    return 0;
}

/***************************************/
/*************LAB 3 MPI*****************/
/***************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mpi.h>

#define ROOT 0
#define M    5
#define N    8
#define RAND_RANGE 100
#define SWAP(A, B) { int t = A; A = B; B = t; }

void bubblesort(int *a, int n);

int main( int argc, char *argv[])
{
    int myid;
    int numprocs;
    int *arr;
    arr = (int *) malloc(N * M * sizeof(int));
    int *arr2;
    arr2 = (int *) malloc(N * M * sizeof(int));

    //long arr[N][M];
    int subarr[M];
    int subarr2[N];
    int buf[N];

    int i, j;
    int *ranks;
    double startwtime, endwtime;
    MPI_Group orig_group, new_group;
    MPI_Comm new_comm;
    /* Инициализация библиотеки */
    MPI_Init(&argc, &argv);
    /* Получаем общее количество запущенных процессов */
    MPI_Comm_size(MPI_COMM_WORLD, &numprocs);

    /* Получаем порядковый номер текущего процесса */
    MPI_Comm_rank(MPI_COMM_WORLD, &myid);
    MPI_Comm_group(MPI_COMM_WORLD, &orig_group);

    if (myid == ROOT) {
        srand(time(NULL));
        for(i = 0; i < N; ++i) {
            for(j = 0; j < M; ++j) {
                //arr[i][j] = rand() % RAND_RANGE;
                arr2[i * M + j] = rand() % RAND_RANGE;
            }
        }
        printf("Initial arr[%d][%d]:\n", N, M);
        for(i = 0; i < N; i++){
            for(j = 0; j < M; j++){
                //printf("%4ld", arr[i][j]);
                printf("%4d", arr2[i * M + j]);
            }
            printf("\n");
        }
        for(i = 0; i < N; ++i) {
            for(j = 0; j < M; ++j) {
                arr[j * N + i] = arr2[i * M + j];
            }
        }
    }

    //transponirovanie

    if (myid == ROOT){
        /* Засекаем время начала вычисления */
        startwtime = MPI_Wtime();
    }
    /*
    if(N == numprocs) {
        MPI_Scatter(arr2, M, MPI_LONG, subarr, M, MPI_LONG, ROOT, MPI_COMM_WORLD);
        bubblesort(subarr, M);
        MPI_Gather(subarr, M, MPI_LONG, arr2, M, MPI_LONG, ROOT, MPI_COMM_WORLD);
    }
    if(N < numprocs) {
        ranks = (int *) malloc(N * sizeof(int));
        for(i = 0; i < N; i++) {
            ranks[i] = i;
        }
        MPI_Group_incl(orig_group, N, ranks, &new_group);
        MPI_Comm_create(MPI_COMM_WORLD, new_group, &new_comm);

        if (myid < N) {
            MPI_Scatter(arr2, M, MPI_LONG, subarr, M, MPI_LONG, ROOT, new_comm);
            bubblesort(subarr, M);
            MPI_Gather(subarr, M, MPI_LONG, arr2, M, MPI_LONG, ROOT, new_comm);
        }
    }

    if(N > numprocs) {
        for(i = 0; i < N / numprocs; i++) {
            MPI_Scatter(arr2 + (i * M * numprocs), M, MPI_LONG, subarr, M, MPI_LONG, ROOT, MPI_COMM_WORLD);
            bubblesort(subarr, M);
            MPI_Gather(subarr, M, MPI_LONG, arr2 + (i * M * numprocs), M, MPI_LONG, ROOT, MPI_COMM_WORLD);
            MPI_Barrier(MPI_COMM_WORLD);
        }
        int tail = N - numprocs * i;
        ranks = (int *) malloc(tail * sizeof(int));
        for(i = 0; i < tail; i++) {
            ranks[i] = i;
        }
        MPI_Group_incl(orig_group, tail, ranks, &new_group);
        MPI_Comm_create(MPI_COMM_WORLD, new_group, &new_comm);

        if (myid < tail) {
            MPI_Scatter(arr2 + ((N - tail) * M), M, MPI_LONG, subarr, M, MPI_LONG, ROOT, new_comm);
            bubblesort(subarr, M);
            MPI_Gather(subarr, M, MPI_LONG, arr2 + ((N - tail) * M), M, MPI_LONG, ROOT, new_comm);
        }

    }*/
    if(M == numprocs) {
        MPI_Scatter(arr, N, MPI_INT, subarr2, N, MPI_INT, ROOT, MPI_COMM_WORLD);
        bubblesort(subarr2, N);
        MPI_Gather(subarr2, N, MPI_INT, arr, N, MPI_INT, ROOT, MPI_COMM_WORLD);
    }
    if(M < numprocs) {
        ranks = (int *) malloc(M * sizeof(int));
        for(i = 0; i < M; i++) {
            ranks[i] = i;
        }
        MPI_Group_incl(orig_group, M, ranks, &new_group);
        MPI_Comm_create(MPI_COMM_WORLD, new_group, &new_comm);

        if (myid < M) {
            MPI_Scatter(arr, N, MPI_INT, subarr2, N, MPI_INT, ROOT, new_comm);
            bubblesort(subarr2, N);
            MPI_Gather(subarr2, N, MPI_INT, arr, N, MPI_INT, ROOT, new_comm);
        }
    }

    if(M > numprocs) {
        for(i = 0; i < M / numprocs; i++) {
            MPI_Scatter(arr + (i * N * numprocs), N, MPI_INT, subarr2, N, MPI_INT, ROOT, MPI_COMM_WORLD);
            bubblesort(subarr2, N);
            MPI_Gather(subarr2, N, MPI_INT, arr + (i * N * numprocs), N, MPI_INT, ROOT, MPI_COMM_WORLD);
            MPI_Barrier(MPI_COMM_WORLD);
        }
        int tail = M - numprocs * i;
        ranks = (int *) malloc(tail * sizeof(int));
        for(i = 0; i < tail; i++) {
            ranks[i] = i;
        }
        MPI_Group_incl(orig_group, tail, ranks, &new_group);
        MPI_Comm_create(MPI_COMM_WORLD, new_group, &new_comm);

        if (myid < tail) {
            MPI_Scatter(arr + ((M - tail) * N), N, MPI_INT, subarr2, N, MPI_INT, ROOT, new_comm);
            bubblesort(subarr2, N);
            MPI_Gather(subarr2, N, MPI_INT, arr + ((M - tail) * N), N, MPI_INT, ROOT, new_comm);
        }

    }

    if (myid == ROOT) {
        /*Засекаем время окончания вычисления */
        endwtime = MPI_Wtime();
        printf("\nSorted arr[%d][%d]:\n", N, M);
        for (i = 0; i < N; i++){
            for (j = 0; j < M; j++){
                //printf("%4ld", arr[i][j]);
                //printf("%4ld", arr2[i * M + j]);
                printf("%4d", arr[j * N + i]);
            }
            printf("\n");
        }
        printf("time = %f\n", endwtime - startwtime);
    }

    MPI_Finalize();
    return 0;
}

void bubblesort(int *a, int n) {
    int i, j;
    for (i = 0; i < n; ++i) {
        for(j = 1; j < n - i; ++j) {
            if(a[j - 1] < a[j]) {
                SWAP(a[j - 1], a[j]);
            }
        }
    }
}