Celija

#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>

#define KANCER 0
#define LEK 1
#define TKIVO 2

#define KANCER_VEROVATNOCA 2
#define LEK_VEROVATNOCA 18
#define TKIVO_VEROVATNOCA 80

#define TOP 1
#define BOTTOM 2
#define LEFT 4
#define RIGHT 8

typedef struct celija {
    int tip;
    int jacina;
} CELIJA;


CELIJA** allocateMatrix(int m, int n)
{
    int i;
    CELIJA **matrix = (CELIJA**)malloc(m * sizeof(CELIJA*));
    for(i = 0; i < m; i++) matrix[i] = (CELIJA*)malloc(n * sizeof(CELIJA));
    return matrix;
}

void printMatrix(CELIJA **matrix, int startM, int m, int n)
{
    int i, j;
    for (i = 0; i < m && startM <= m; i++)
    {
        for (j = 0; j < n; j++)
        {
            printf("| %d %6d ", matrix[i][j].tip, matrix[i][j].jacina);
            if (j == n - 1) printf("|");
        }
        printf("\n");
    }
}

void setMatrixData(CELIJA **matrix, int m, int n)
{
    int i, j;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            int verovatnocaTipa = rand() % 100 + 1;
            if (verovatnocaTipa <= KANCER_VEROVATNOCA)
            {
                matrix[i][j].tip = KANCER;
                matrix[i][j].jacina = rand() % 101 + 1;
            }
            else if (verovatnocaTipa > KANCER_VEROVATNOCA && verovatnocaTipa <= LEK_VEROVATNOCA)
            {
                matrix[i][j].tip = LEK;
                matrix[i][j].jacina = rand() % 20 + 1;
            }
            else if (verovatnocaTipa > LEK_VEROVATNOCA)
            {
                matrix[i][j].tip = TKIVO;
                matrix[i][j].jacina = rand() % 10001;
            }
        }
    }
}

int tryApplyCancerOrMedicine(CELIJA **matrix, int i, int j, CELIJA value)
{
    if (matrix[i][j].tip == TKIVO && value.tip == KANCER)
    {
        matrix[i][j].jacina -= value.jacina;

        if (matrix[i][j].jacina <= 0)
        {
            matrix[i][j].tip = KANCER;
            matrix[i][j].jacina = rand() % 101;
        }
    }

    if (matrix[i][j].tip == KANCER && value.tip == LEK)
    {
        matrix[i][j].jacina -= value.jacina;

        if (matrix[i][j].jacina <= 0)
        {
            matrix[i][j].tip = TKIVO;
            matrix[i][j].jacina = rand() % 10001;
        }
    }

    return matrix[i][j].tip != value.tip ? 1 : 0;
}

void doWork(CELIJA **matrix, int startM, int endM, int n)
{
    int i, j;
    for (i = startM; i <= endM; i++)
    {
        int hasCancerNeighbour = 0;
        for (j = 0; j < n; j++)
        {
            // check left
            if (j > 0) hasCancerNeighbour += tryApplyCancerOrMedicine(matrix, i, j, matrix[i][j-1]);
            // check right
            if (j < n) hasCancerNeighbour += tryApplyCancerOrMedicine(matrix, i, j, matrix[i][j+1]);
            // check top
            if (i > startM) hasCancerNeighbour += tryApplyCancerOrMedicine(matrix, i, j, matrix[i-1][j]);
            // check bottom
            if (i < endM) hasCancerNeighbour += tryApplyCancerOrMedicine(matrix, i, j, matrix[i+1][j]);
            // check top-left
            if (j > 0 && i > startM) hasCancerNeighbour += tryApplyCancerOrMedicine(matrix, i, j, matrix[i-1][j-1]);
            // check top-right
            if (j < n && i > startM) hasCancerNeighbour += tryApplyCancerOrMedicine(matrix, i, j, matrix[i-1][j+1]);
            // check bottom-left
            if (j > 0 && i < endM) hasCancerNeighbour += tryApplyCancerOrMedicine(matrix, i, j, matrix[i+1][j-1]);
            // check bottom-right
            if (j < n && i < endM) hasCancerNeighbour += tryApplyCancerOrMedicine(matrix, i, j, matrix[i+1][j+1]);

            // convert cell into a tissue if there cell is surrounded with tissues
            if (hasCancerNeighbour == 0 && matrix[i][j].tip == LEK)
            {
                matrix[i][j].tip = TKIVO;
                matrix[i][j].jacina = rand() % 10001;
            }
        }
    }
}

void doWorkEdge(CELIJA **matrix, CELIJA *rowToCompare, int n, int i)
{
    int j;
    int hasCancerNeighbour = 0;
    for (j = 0; j < n; j++)
    {
        // default check
        hasCancerNeighbour += tryApplyCancerOrMedicine(matrix, i, j, rowToCompare[j]);

        // check edge-left
        if (j > 0) hasCancerNeighbour += tryApplyCancerOrMedicine(matrix, i, j, rowToCompare[j-1]);
        // check edge-right
        if (j < n) hasCancerNeighbour += tryApplyCancerOrMedicine(matrix, i, j, rowToCompare[j+1]);

        if (hasCancerNeighbour == 0 && matrix[i][j].tip == LEK)
        {
            matrix[i][j].tip = TKIVO;
            matrix[i][j].jacina = rand() % 10001;
        }
    }
}

CELIJA findLocalStrongestCancerCell(CELIJA **matrix, int startM, int endM, int n)
{
    int i, j;
    CELIJA strongest;
    strongest.tip = KANCER;
    strongest.jacina = -1;

    for (i = startM; i <= endM; i++)
    {
        for (j = 0; j < n; j++)
        {
            if (matrix[i][j].tip == KANCER && matrix[i][j].jacina > strongest.jacina)
            {
                strongest = matrix[i][j];
            }
        }
    }
    return strongest;
}

int main(int argc, char **argv)
{
    int rank, size;
    int m = 100, n = 10;
    int i;
    int steps = 1;

    CELIJA strongestGlobal;

    CELIJA *top_row = (CELIJA *)malloc(n * sizeof(CELIJA));
    CELIJA *bottom_row = (CELIJA *)malloc(n * sizeof(CELIJA));

    CELIJA **matrix = allocateMatrix(m, n);
    setMatrixData(matrix, m, n);

    MPI_Init(&argc, &argv);

    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    // Find submatrix for process
    int startM = (rank * (m / size));
    int endM = startM + (m / size) - 1;

    for (i = 0; i < steps; i++)
    {
        doWork(matrix, startM, endM, n);

        // upper cells
        if (rank != 0)
        {
            MPI_Send(matrix[startM], n * 2, MPI_INT, rank - 1, 40, MPI_COMM_WORLD);
            MPI_Recv(bottom_row, n * 2, MPI_INT, rank - 1, 40, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

            doWorkEdge(matrix, bottom_row, n, startM);
        }
        // lower cells
        if (rank != size - 1)
        {
            MPI_Send(matrix[endM], n * 2, MPI_INT, rank + 1, 40, MPI_COMM_WORLD);
            MPI_Recv(bottom_row, n * 2, MPI_INT, rank + 1, 40, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

            doWorkEdge(matrix, bottom_row, n, startM);
        }
    }

    // Find the strongest cancer cell
    CELIJA strongest = findLocalStrongestCancerCell(matrix, startM, endM, n);

    MPI_Reduce(&strongest.jacina, &strongestGlobal.jacina, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD);

    printf("[%d]: Strongest local: %d_%d\n", rank, strongest.tip, strongest.jacina);

    if (rank == 0) printf("Strongest global: %d\n", strongestGlobal.jacina);

    MPI_Finalize();

    return 0;
}