OpenMP的C：矩阵乘以向量

Question

I tried to make matrix times vector with a lot of loop and i want to speedup the process

Here's my code

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

int main()
{
    int i, j, n, a[719][719], b[719], c[719];

    clock_t start = clock();

    n = 100; //Max 719

    printf("Matrix A\n");

    for (i = 0; i < n; ++i) {
        for (j = 0; j < n; ++j) {
            a[i][j] = 10;
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }

    printf("\nMatrix B\n");

    #pragma omp parallel private(i) shared(b)
    {
        #pragma omp for
        for (i = 0; i < n; ++i) {
            b[i] = 5;
            printf("%d\n", b[i]);
        }
    }

    printf("\nA * B\n");

    #pragma omp parallel private(i) shared(c)
    {
        #pragma omp for
        for (i = 0; i < n; ++i) {
            c[i] = 0;
        }
    }

    #pragma omp parallel private(i,j) shared(n,a,b,c)
    {
        #pragma omp for schedule(dynamic)
        for (i = 0; i < n; ++i) {
            for (j = 0; j < n; ++j) {
                c[i] += b[j] * a[j][i];
            }
        }
    }


    #pragma omp parallel private(i) shared(c)
    {
        #pragma omp for
        for (i = 0; i < n; ++i) {
            printf("%d\n", c[i]);
        }
    }

    clock_t stop = clock();
    double elapsed = (double)(stop - start) / CLOCKS_PER_SEC;
    printf("\nTime elapsed: %.5f\n", elapsed);

    return 0;
}

I also think that there are a lot of ineffective part in this code, I would appreciate it if anyone could fix the code into the effective one and speed up the process

Answer 1

I warn you that i recently tried to make a similar thing (matrix multiplication) and i didn't get the results i hoped: with two cores and hyperthreading i ran the my program and the speedup respect to the linear implementation was very little and only using matrices very big. With matrices of small size you will only slow down your algorithm due to thread overhead.

You can use the collapse(n) statement. The threading is applayed to the nested loops. You should reduced your overhead. A fast overview of OpenMP directives can be found here (also collapse): http://bisqwit.iki.fi/story/howto/openmp/ .

You can check the code i wrote here: http://pastebin.com/edi4DgrJ You can define at compile time the size of the matrices. Just change the define.

You can also use "condensed" OpenMP directives ( like parallel for ) that speed up your programming session (and i also think that readability of the code is better).