mpi_2

#include <cstdio>
#include <mpi.h>
#include <fstream>
#include <iostream>
#include <cstdlib>

using namespace std;

#define msg1 10
#define msg2 20
#define msg3 30

void generateMatrix(int** &matrix, int size) {
    for(int i=0; i<size; ++i) {
        for(int j=0; j<size; ++j) {
            if(i<=j )
                matrix[i][j]=i+1;
            else
                matrix[i][j]=j+1;
        }
    }
}

int main(int argc, char **argv)
{
    int ranksize, myrank, n, start;
    MPI_Status status;
    MPI_Init(&argc,&argv);
    MPI_Comm_size (MPI_COMM_WORLD, &ranksize);
    MPI_Comm_rank (MPI_COMM_WORLD, &myrank);

    double start_time, finish_time;

    MPI_Barrier(MPI_COMM_WORLD);

    start = myrank;
    if (myrank == 0)
        cin >> n;

    start_time = MPI_Wtime();

    MPI_Bcast(&n, 1, MPI_INTEGER, 0, MPI_COMM_WORLD);
    int **matrix = new int*[n];
    for(int i = 0; i < n; ++i)
        matrix[i] = new int[n];
    if(myrank == 0)
        generateMatrix(matrix, n);

    int *l = new int[n];

    MPI_Barrier(MPI_COMM_WORLD);

    int nrows = ((n%ranksize)>myrank)? (n/ranksize+1) : (n/ranksize);

    if(myrank == 0)
    {
        for(int i = 1; i < n; ++i)
            if(i % ranksize != 0)
                MPI_Send(matrix[i], n, MPI_INTEGER, i%ranksize, msg1, MPI_COMM_WORLD);

        for(int i = 1; i < n; ++i)
        {
            matrix[0][i] /= matrix[0][0];
            l[i] = matrix[0][i];
        }
        start += ranksize;
        nrows--;
    }
    else
        for(int i = 0; i < nrows; ++i)
            MPI_Recv(matrix[start + ranksize*i], n, MPI_INTEGER, 0, msg1, MPI_COMM_WORLD, &status);

    MPI_Bcast(&l[1], n - 1, MPI_INTEGER, 0, MPI_COMM_WORLD);

    MPI_Barrier(MPI_COMM_WORLD);

    for(int k = 1; k < n; ++k)
    {
        for(int j = 0; j < nrows; ++j)
            if(start >= k)
                for(int i = k; i < n; ++i)
                    matrix[start + j*ranksize][i] -= matrix[start + j*ranksize][k-1] * l[i];

        if(myrank == k % ranksize)
        {
            for(int i = k + 1; i < n; ++i)
                l[i] = matrix[k][i] / matrix[k][k];
        }
        MPI_Bcast(&l[k+1], n - k - 1, MPI_INTEGER, k % ranksize, MPI_COMM_WORLD);
        if(myrank == k % ranksize){
            // for (int i = 0; i < ranksize; ++i) {
            //     if (i != myrank) {
            //         MPI_Send(l + k + 1, n - k - 1, MPI_INTEGER, i, msg3, MPI_COMM_WORLD);
            //     }
            // }
            if(myrank != 0)
                MPI_Send(matrix[k], k + 1, MPI_INTEGER, 0, msg2, MPI_COMM_WORLD);
            start += ranksize;
            nrows--;
        } else {
            // MPI_Recv(l + k + 1, n - k - 1, MPI_INTEGER, k % ranksize, msg3, MPI_COMM_WORLD, &status);
        }

        if(myrank == 0)
        {
            if(k % ranksize != 0)
                MPI_Recv(matrix[k], k + 1, MPI_INTEGER, k % ranksize, msg2, MPI_COMM_WORLD, &status);
            for(int i = k + 1; i < n; ++i)
                matrix[k][i] = l[i];
        }
        MPI_Barrier(MPI_COMM_WORLD);

    }
    MPI_Barrier(MPI_COMM_WORLD);
    finish_time = MPI_Wtime();

    double s_wb_time, f_wb_time;
    MPI_Barrier(MPI_COMM_WORLD);

    s_wb_time = MPI_Wtime();

    ofstream fout("output.txt");
    if(myrank == 0)
    {
        fout << n << endl;
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
                fout<<matrix[i][j]<<' ';
            fout<<endl;
        }
        fout<<endl;

        cout << "Execution: " << finish_time - start_time;
    }
    MPI_Barrier(MPI_COMM_WORLD);

    f_wb_time = MPI_Wtime();
    if(myrank == 0)
    {
        cout << ", write back: " << f_wb_time - s_wb_time << endl;
    }

    MPI_Finalize();

    return 0;
}