Parallel

MatrixMult.cpp

#include <iostream>
#include <chrono>
#include <ctime>
#include <string>

using namespace std;

typedef double** matrix;

void matrixmult_common(matrix A, matrix B, matrix C, size_t N)
{
    for (int r = 0; r < N; ++r)
    {
        for (int c = 0; c < N; ++c)
        {
            for (int e = 0; e < N; ++e)
            {
                C[r][c] = C[r][c] + A[r][e] * B[e][c];
            }
        }
    }
}

void matrixmult_common_trans(matrix A, matrix B, matrix C, size_t N)
{
    for (int r = 0; r < N; ++r)
        for (int c = 0; c < N; ++c)
            for (int e = 0; e < N; ++e)
                C[r][c] = C[r][c] + A[r][e] * B[c][e];
}

void matrixmult_block(matrix A, matrix B, matrix C, size_t N, size_t blockN)
{
    for (int rb = 0; rb < N / blockN; ++rb)
        for (int cb = 0; cb < N / blockN; ++cb)
            for (int eb = 0; eb < N / blockN; ++eb)
                for (int r = 0; r < blockN; ++r)
                    for (int c = 0; c < blockN; ++c)
                        for (int e = 0; e < blockN; ++e)
                            C[rb * blockN + r][cb * blockN + c] += A[rb * blockN + r][eb * blockN + e]
                                                                 * B[eb * blockN + e][cb * blockN + c];
     
}

void matrixmult_block_trans(matrix A, matrix B, matrix C, size_t N, size_t blockN)
{
    for (int rb = 0; rb < N / blockN; ++rb)
        for (int cb = 0; cb < N / blockN; ++cb)
            for (int eb = 0; eb < N / blockN; ++eb)
                for (int r = 0; r < blockN; ++r)
                    for (int c = 0; c < blockN; ++c)
                        for (int e = 0; e < blockN; ++e)
                            C[rb * blockN + r][cb * blockN + c] += A[rb * blockN + r][eb * blockN + e]
                                                                 * B[cb * blockN + c][eb * blockN + e];

}

int main()
{
    chrono::time_point<chrono::system_clock> start, end;
    size_t buffer_size = 30;
    char* buffer = new char[buffer_size];
    chrono::duration<double> elapsed_seconds;
    time_t end_time;

    // Fill the matrix
start = chrono::system_clock::now();

    int N = 4060;
    int blockN = 290;
    matrix a = new double*[N];
    matrix b = new double*[N];
    matrix c = new double*[N];
    for (int r = 0; r < N; ++r)
    {
        a[r] = new double[N];
        b[r] = new double[N];
        c[r] = new double[N];

        for (int c = 0; c < N; ++c)
        {
            a[r][c] = r*c;
            b[r][c] = r*c;
        }
    }

end = chrono::system_clock::now();
    elapsed_seconds = end - start;
    end_time = chrono::system_clock::to_time_t(end);

    ctime_s(buffer, buffer_size, &end_time);
    cout << "finished filling at " << string(buffer)
        << " elapsed time: " << elapsed_seconds.count() << "s\n";
    // Common Calculation
/*    
    start = chrono::system_clock::now();
    matrixmult_common(a, b, c, N);
    end = chrono::system_clock::now();

    elapsed_seconds = end - start;
    end_time = chrono::system_clock::to_time_t(end);

    ctime_s(buffer, buffer_size, &end_time);
    cout << "finished computation at " << string(buffer)
        << "elapsed time: " << elapsed_seconds.count() << "s\n";
    
    // Common trans
    start = chrono::system_clock::now();
    matrixmult_common_trans(a, b, c, N);
    end = chrono::system_clock::now();

    elapsed_seconds = end - start;
    end_time = chrono::system_clock::to_time_t(end);

    ctime_s(buffer, buffer_size, &end_time);
    cout << "finished computation at " << string(buffer)
        << "elapsed time: " << elapsed_seconds.count() << "s\n";
        */
    // Block
    start = chrono::system_clock::now();
    matrixmult_block(a, b, c, N, blockN);
    end = chrono::system_clock::now();

    elapsed_seconds = end - start;
    end_time = chrono::system_clock::to_time_t(end);

    ctime_s(buffer, buffer_size, &end_time);
    cout << "finished computation at " << string(buffer)
        << "elapsed time: " << elapsed_seconds.count() << "s\n";

    // Block trans
    start = chrono::system_clock::now();
    matrixmult_block_trans(a, b, c, N, blockN);
    end = chrono::system_clock::now();

    elapsed_seconds = end - start;
    end_time = chrono::system_clock::to_time_t(end);

    ctime_s(buffer, buffer_size, &end_time);
    cout << "finished computation at " << string(buffer)
        << "elapsed time: " << elapsed_seconds.count() << "s\n";

    cin >> N;
}

/*
Результаты:

    N = 4000:
        fill:                       0.1011
        Common:                     1045.6
        Common with transponed:     70.8225
        Block:                      179.975     blockSize = 200
        Block with transponed:      60.0575     blockSize = 200


*/