#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>
#include <omp.h>

#define NUM_CORES 2

void multiply_matrix_sequential(float **A, float **B, long n, float **C);
void multiply_matrix_parallel_static(float **A, float **B, long n, float **C);
void multiply_matrix_parallel_static_imgura(float **A, float **B, long n, float **C);
void multiply_matrix_parallel_static_16(float **A, float **B, long n, float **C);
void multiply_matrix_parallel_static_v2(float **A, float **B, long n, float **C);
void multiply_matrix_parallel_static_v3(float **A, float **B, long n, float **C);
void multiply_matrix_parallel_dynamic(float **A, float **B, long n, float **C);
void multiply_matrix_parallel_guided(float **A, float **B, long n, float **C);

float** init_matrix(long n, bool init_empty);
void zero_matrix(float **arr, long n);
void print_matrix(float **arr, long n);
void compare_two_matrices(float **C, float **Cs, long n);

int main(int argc, char* args[])
{
    srand(time(NULL));
    printf("\nn;parallel_static,parallel_static_v2;parallel_static_v3;");
    for (int i = 1; i < 25; i = i + 4 ) {
        long n = i * 100;
        float **A = init_matrix(n, false);
        float **B = init_matrix(n, false);
        float **C = init_matrix(n, true);
        float **Cs = init_matrix(n, true);

        zero_matrix(C, n);
        zero_matrix(Cs, n);

        printf("\n%ld;",n);
        multiply_matrix_sequential(A, B, n, Cs);

        multiply_matrix_parallel_static_imgura(A, B, n, C);
        // compare_two_matrices(C, Cs, n);
        zero_matrix(C, n);

        // multiply_matrix_parallel_static_v2(A, B, n, C);
        // // compare_two_matrices(C, Cs, n);
        // zero_matrix(C, n);

        // multiply_matrix_parallel_static_v3(A, B, n, C);
        // compare_two_matrices(C, Cs, n);
        // zero_matrix(C, n);
        printf("\n");

        free(A); free(B); free(C); free(Cs);
    }

    // printf("\n\n szeregowanie \n\n");
    // printf("n;seqentiual;parallel_static;parallel_dynamic;parallel_guided;");
    // for (int i = 1; i < 25; i = i + 4 ) {

    //     long n = i * 100;
    //     float **A = init_matrix(n, false);
    //     float **B = init_matrix(n, false);
    //     float **C = init_matrix(n, true);
    //     float **Cs = init_matrix(n, true);

    //     zero_matrix(C, n);
    //     zero_matrix(Cs, n);

    //     printf("\n%ld;",n);
    //     multiply_matrix_sequential(A, B, n, Cs);

    //     multiply_matrix_parallel_static(A, B, n, C);
    //     compare_two_matrices(C, Cs, n);
    //     zero_matrix(C, n);

    //     multiply_matrix_parallel_dynamic(A, B, n, C);
    //     compare_two_matrices(C, Cs, n);
    //     zero_matrix(C, n);

    //     multiply_matrix_parallel_guided(A, B, n, C);
    //     compare_two_matrices(C, Cs, n);
    //     zero_matrix(C, n);
    //     printf("\n");

    //     free(A); free(B); free(C); free(Cs);
    // }
    return EXIT_SUCCESS;
}

void multiply_matrix_sequential(float **A, float **B, long n, float **C)
{
    long i, j, k;
    clock_t start, stop;

    start = clock();
    for(i = 0 ; i < n; i++)
        for(k = 0 ; k < n ; k++)
            for(j = 0; j < n; j++)
                C[i][j] += A[i][k] * B[k][j];
    stop = clock();

    printf("\t\t%5.5f;", ((double) (stop - start)) / CLOCKS_PER_SEC);
}

void multiply_matrix_parallel_static(float **A, float **B, long n, float **C)
{
    clock_t start, stop;

    start = clock();
    #pragma omp parallel for schedule(static,16) num_threads(NUM_CORES)
    for(long i = 0 ; i < n; i++)
        for(long k = 0 ; k < n ; k++)
            for(long j = 0; j < n; j++) {
                C[i][j] += A[i][k] * B[k][j];
            }
    stop = clock();

    printf("\t%5.5f;", (((double) (stop - start)) / CLOCKS_PER_SEC) / NUM_CORES);
}

void multiply_matrix_parallel_static_imgura(float **A, float **B, long n, float **C)
{
    clock_t start, stop;

    start = clock();
    #pragma omp parallel for schedule(static,16) num_threads(NUM_CORES)
    for(long i = 0 ; i < n; i++)
        for(long j = 0; j < n; j++)
            for(long k = 0 ; k < n ; k++){
                C[i][j] += A[i][k] * B[k][j];
            }
    stop = clock();

    printf("\t%5.5f;", (((double) (stop - start)) / CLOCKS_PER_SEC) / NUM_CORES);
}

void multiply_matrix_parallel_static_16(float **A, float **B, long n, float **C)
{
    clock_t start, stop;

    start = clock();
    #pragma omp parallel for schedule(static) num_threads(NUM_CORES)
    for(long i = 0 ; i < n; i++)
        for(long k = 0 ; k < n ; k++)
            for(long j = 0; j < n; j++) {
                C[i][j] += A[i][k] * B[k][j];
            }
    stop = clock();

    printf("\t%5.5f;", (((double) (stop - start)) / CLOCKS_PER_SEC) / NUM_CORES);
}

void multiply_matrix_parallel_static_v2(float **A, float **B, long n, float **C)
{
    clock_t start, stop;

    start = clock();
    for(long i = 0 ; i < n; i++)
    #pragma omp parallel for schedule(static) num_threads(NUM_CORES)
        for(long k = 0 ; k < n ; k++) {
            for(long j = 0; j < n; j++) {
                #pragma omp atomic
               C[i][j] += A[i][k] * B[k][j];
            }
        }
    stop = clock();

    printf("\t%5.5f;", (((double) (stop - start)) / CLOCKS_PER_SEC) / NUM_CORES);
}

void multiply_matrix_parallel_static_v3(float **A, float **B, long n, float **C)
{
    clock_t start, stop;

    start = clock();
    for(long i = 0 ; i < n; i++)
        for(long k = 0 ; k < n ; k++)
    #pragma omp parallel for schedule(static) num_threads(NUM_CORES)
            for(long j = 0; j < n; j++) {
                C[i][j] += A[i][k] * B[k][j];
            }
    stop = clock();

    printf("\t%5.5f;", (((double) (stop - start)) / CLOCKS_PER_SEC) / NUM_CORES);
}

void multiply_matrix_parallel_dynamic(float **A, float **B, long n, float **C)
{
    clock_t start, stop;

    start = clock();
    #pragma omp parallel for schedule(dynamic) num_threads(NUM_CORES)
    for(long i = 0 ; i < n; i++)
        for(long k = 0 ; k < n ; k++)
            for(long j = 0; j < n; j++) {
                C[i][j] += A[i][k] * B[k][j];
            }
    stop = clock();

    printf("\t%5.5f;", (((double) (stop - start)) / CLOCKS_PER_SEC) / NUM_CORES);
}

void multiply_matrix_parallel_guided(float **A, float **B, long n, float **C)
{
    clock_t start, stop;

    start = clock();
    #pragma omp parallel for schedule(guided) num_threads(NUM_CORES)
    for(long i = 0 ; i < n; i++)
        for(long k = 0 ; k < n ; k++)
            for(long j = 0; j < n; j++) {
                C[i][j] += A[i][k] * B[k][j];
            }
    stop = clock();

    printf("\t%5.5f;", (((double) (stop - start)) / CLOCKS_PER_SEC) / NUM_CORES);
}

float** init_matrix(long n, bool init_empty)
{
    long i, j;
    float **arr = (float **)malloc((size_t) (n * sizeof(float *)));

    for(i = 0; i < n; i++)
    {
        arr[i] = (float *)malloc((size_t) (n * sizeof(float)));

        for(j = 0; j < n; j++)
        {
            if(init_empty)
                arr[i][j] = 0;
            else
                arr[i][j] = (float) rand() / RAND_MAX;
        }
    }

    return arr;
}

void zero_matrix(float **arr, long n)
{
    long i, j;

    for(i = 0; i < n; i++)
        for(j = 0; j < n; j++)
            arr[i][j] = 0;
}

void print_matrix(float **arr, long n)
{
    long i, j;

    for(i = 0; i < n; i++)
    {
        for(j = 0; j < n; j++)
            printf("%5.5f ", arr[i][j]);

        printf("\n");
    }
}

void compare_two_matrices(float **C, float **Cs, long n)
{
    long i, j;

    for(i = 0; i < n; i++)
    {
        for(j = 0; j < n; j++)
            if(C[i][j] != Cs[i][j]) {
                printf("Not indentical matrices, C = %.6f Cs = %.6f, C[%ld][%ld]",C[i][j] , Cs[i][j], i, j);
                return;
            }
    }
}