C++ 用于循环并行化的OpenMp

我尝试用OpenMP并行化下面的代码

#pragma omp parallel for collapse(2)
{
    for (int mNdx = 0; mNdx < M; ++mNdx)
    {
        for (int nNdx = mNdx; nNdx < N; ++nNdx)
        {
            for (int elemNdx = mNdx; elemNdx <= nNdx; ++elemNdx)
            {
                result[mNdx * N + nNdx] += matrixOne[mNdx * N + elemNdx] * matrixTwo[elemNdx * N + nNdx];
            }
        }
    }
}

用于折叠的pragma omp并行（2） { 对于（int-mNdx=0；mNdx对于（int elemNdx=mNdx；elemNdx）您有一个非规范形式的缩减和循环，我希望编译器会发出一条消息。如何计时？我使用omp_get_wtime（）计时…在此循环之前直接调用一个，之后直接调用一个。只是为了确保：您是否在编译器选项中启用了openmp支持，以及是否将omp.h头包含到文件中？您能否提供一个？这有助于人们更好地理解您的问题。已设置openmp标志（使用visual studio 2015编译）还包括omp.h。将添加一个可验证的示例。

#include <omp.h>
#include <iostream>

void initMatrix(float* mat, const int M, const int N);
void initResMatrix(float* mat, const int M, const int N);

double matMulUpperTriangular_C(float* matrixOne, float* matrixTwo, float* result, const int M, const int N);
double matMulUpperTriangular_Omp(float* matrixOne, float* matrixTwo, float* result, const int M, const int N);

int main()
{
    const int M = 2048, N = 2048;
    float* matOne = (float*)malloc(M * N * sizeof(float));
    float* matTwo = (float*)malloc(M * N * sizeof(float));
    float* res = (float*)malloc(M * N * sizeof(float));

    initMatrix(matOne, M, N);
    initMatrix(matTwo, M, N);
    initResMatrix(res, M, N);

    double timeConsumption[2] = { 0.0, 0.0 };

    timeConsumption[0] = matMulUpperTriangular_C(matOne, matTwo, res, M, N);
    timeConsumption[1] = matMulUpperTriangular_Omp(matOne, matTwo, res, M, N);

    std::cout << "Runtime C:\t\t" << timeConsumption[0] << "s" << std::endl;
    std::cout << "Runtime Omp:\t\t" << timeConsumption[1] << "s";
    std::cout << " | SpeedUp: " << timeConsumption[0] / timeConsumption[1] << std::endl;

    system("PAUSE");
    return 0;
}

void initMatrix(float* mat, const int M, const int N)
{
    for (int mNdx = 0; mNdx < M; ++mNdx)
    {
        for (int nNdx = 0; nNdx < mNdx; ++nNdx)
        {
            mat[mNdx * N + nNdx] = 0;
        }
        for (int nNdx = mNdx; nNdx < N; ++nNdx)
        {
            mat[mNdx * N + nNdx] = ((mNdx + nNdx) % 5 + 1) * 0.1f;
        }
    }
}

void initResMatrix(float* mat, const int M, const int N)
{
    for (int mNdx = 0; mNdx < M; ++mNdx)
    {
        for (int nNdx = 0; nNdx < N; ++nNdx)
        {
            mat[mNdx * N + nNdx] = 0.0f;
        }
    }
}

double matMulUpperTriangular_C(float* matrixOne, float* matrixTwo, float* result, const int M, const int N)
{
    double startTime = omp_get_wtime();

    for (int mNdx = 0; mNdx < M; ++mNdx)
    {
        for (int nNdx = mNdx; nNdx < N; ++nNdx)
        {
            for (int elemNdx = mNdx; elemNdx <= nNdx; ++elemNdx)
            {
                result[mNdx * N + nNdx] += matrixOne[mNdx * N + elemNdx] * matrixTwo[elemNdx * N + nNdx];
            }
        }
    }

    double endTime = omp_get_wtime();

    return endTime - startTime;
}

double matMulUpperTriangular_Omp(float* matrixOne, float* matrixTwo, float* result, const int M, const int N)
{
    double startTime = omp_get_wtime();

    #pragma omp parallel for collapse(2)
    {
        for (int mNdx = 0; mNdx < M; ++mNdx)
        {
            for (int nNdx = mNdx; nNdx < N; ++nNdx)
            {
                for (int elemNdx = mNdx; elemNdx <= nNdx; ++elemNdx)
                {
                    result[mNdx * N + nNdx] += matrixOne[mNdx * N + elemNdx] * matrixTwo[elemNdx * N + nNdx];
                }
            }
        }
    }

    double endTime = omp_get_wtime();

    return endTime - startTime;
}