LV3 Z2 djelomični

#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <math.h>

#define NTHRD 2
#define N 5

CRITICAL_SECTION cs;
double **matricaThread;
HANDLE handleThread[NTHRD];
volatile double columnAverageGlobal = 0;

struct threadParams
{
    int rowStart, rowEnd, id;
    double partSum;
    double colAvg;
};

double** newMatrix(int rows, int columns) {
    int i, j;

    double** Matrix = new double*[rows];
    for (int i = 0; i < rows; ++i)
        Matrix[i] = new double[columns];

    return Matrix;
}

double colAverage(int column, double** matrix, int numRows) {
    double asps = 0;
    int i, j;

    for (i = 0; i < numRows; i++) {
        asps += matrix[i][column];
    }

    return asps/numRows;
}

DWORD WINAPI threadFunction(VOID *params)
{
    time_t t1, t2;
    int i, j, k;
    struct threadParams *threadParam;
    threadParam = (struct threadParams *)params;

    t1 = clock();
    printf("I am thread no. %d\n", threadParam->id);
    for (j = threadParam->rowStart; j < threadParam->rowEnd; j++) {
        threadParam->colAvg = 0;
        for (i = 0; i < N; i++) {
            matricaThread[i][j] = 0;

            for (k = 0; k <= i; k++) {
                matricaThread[i][j] += k * sin(j) - j * cos(k);
            }
            printf("[%d][%d] = %.2f\t", i, j, matricaThread[i][j]);

            matricaThread[i][j] += columnAverageGlobal;
            threadParam->partSum += matricaThread[i][j];
        }
        threadParam->colAvg = colAverage(j, matricaThread, N);
        EnterCriticalSection(&cs);
        columnAverageGlobal = threadParam->colAvg;
        LeaveCriticalSection(&cs);
        printf("Prosjek %d.: %f\n", j, columnAverageGlobal);
    }
    t2 = clock();

    printf("Thread %d time: %dms\n", threadParam->id, t2 - t1);
    printf("Thread %d partial sum: %f\n", threadParam->id, threadParam->partSum);
    return 0;
}

int main()
{
    double matrixSum = 0;
    double matrixSum2 = 0;
    double colAvgSeq = 0;
    matricaThread = newMatrix(N, N);
    double **matricaSeq = newMatrix(N, N);

    int i, j, k;

    time_t time1seq, time2seq;
    time_t time1thr, time2thr;

    long delta = N / NTHRD;

    printf("DELTA: %d\n\n", delta);

    time1seq = clock();
    printf("Started sequential timer...\n");

    //S prosjekom
    for (j = 0; j < N; j++) {
        for (i = 0; i < N; i++) {
            matricaSeq[i][j] = 0;

            for (k = 0; k <= i; k++) {
                matricaSeq[i][j] += k * sin(j) - j * cos(k);
            }
            matricaSeq[i][j] += colAvgSeq;
            matrixSum += matricaSeq[i][j];
        }
        colAvgSeq = colAverage(j, matricaSeq, N);
        printf("Prosjek %d.: %f\n", j, colAvgSeq);
    }

    printf("Matrica s prosjekom: \n");
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            printf("[%d][%d] = %.2f\t", i, j, matricaSeq[i][j]);
        }
        printf("\n");
    }

    time2seq = clock();

    printf("\nTime seq: %dms\n", time2seq - time1seq);
    printf("Sum seq: %f\n\n", matrixSum);

    struct threadParams threadParam[NTHRD + 1];

    time1thr = clock();
    printf("Started thread timer...\n");
    InitializeCriticalSection(&cs);
    //threadParam[0].colStart = 0;
    threadParam[0].rowStart = 0;
    for (i = 1; i <= NTHRD; i++)
    {
        if (N / NTHRD == N) {
            threadParam[i - 1].rowEnd = N;
        }
        else {
            threadParam[i - 1].rowEnd = N % 2 == 0 ? delta * i : (delta * i) + 1;
        }
        threadParam[i - 1].id = i;
        threadParam[i - 1].partSum = 0;
        //threadParam[i - 1].colEnd = delta * i;
        handleThread[i - 1] = CreateThread(NULL, 0, threadFunction, &threadParam[i - 1], 0, NULL);
        printf("%d. thread [%d][%d] - [%d][%d]\n", i, threadParam[i - 1].rowStart, N, threadParam[i - 1].rowEnd, N);
        threadParam[i].rowStart = threadParam[i - 1].rowEnd;

        //threadParam[i].colStart = threadParam[i - 1].colEnd;
    }

    if (threadParam[NTHRD - 1].rowEnd < N) {
        threadParam[NTHRD - 1].rowEnd = N;
    }

    WaitForMultipleObjects(NTHRD, handleThread, TRUE, INFINITE);
    DeleteCriticalSection(&cs);
    matrixSum = 0;
    for (i = 0; i < NTHRD; i++) {
        printf("sp[%d]=%f\n", i, threadParam[i].partSum);
        matrixSum += threadParam[i].partSum;
    }
    time2thr = clock();
    printf("\nTime thread: %dms\n", time2thr - time1thr);
    printf("Sum thread: %f\n", matrixSum);

    system("pause");
    return 0;
}