（原）测试intel的并行计算pafor

转载请注明出处：

http://www.cnblogs.com/darkknightzh/p/4988264.html

参考网址：

关于mt19937：http://www.cnblogs.com/egmkang/archive/2012/09/06/2673253.html

代码如下：

#include "stdafx.h"
#include <iostream>
#include <random>     // mt19937的头文件
#include <ppl.h>      // parfor的头文件
#include <windows.h>  // QueryPerformanceFrequency等函数的头文件

using namespace concurrency; // parfor使用
using namespace std;


// 分配内存
void AllocMatrix(double** m, size_t n)
{
    *m = new double[n*n];
    memset(*m, 0, sizeof(double)*n*n);
}


// 初始化矩阵内容
template <class Gen>
void IniMatrix(double* m, size_t n, Gen& gen)
{
    for (size_t i = 0; i < n; ++i)
    {
        for (size_t j = 0; j < n; ++j)
        {
            m[i*n + j] = static_cast<double>(gen());
        }
    }
}


// 释放内存
void FreeMatrix(double** m)
{
    if (nullptr != *m)
    {
        delete[](*m);
        (*m) = nullptr;
    }
}


// 矩阵相乘，使用for
void matrixMultiplyFor(double* res, const double* m1, const double* m2, size_t n)
{
    for (size_t i = 0; i < n; i++)
    {
        for (size_t j = i; j < n; j++)
        {
            double temp = 0;
            for (size_t k = 0; k < n; k++)
            {
                temp += m1[i * n + k] * m2[k * n + j];
            }
            res[i*n + j] = temp;
        }
    }
}


// 矩阵相乘，外层使用parfor
void matrixMultiplyParForOuter(double* res, const double* m1, const double* m2, size_t n)
{
    parallel_for(size_t(0), n, [&](size_t i)
    {
        for (size_t j = i; j < n; j++)
        {
            double temp = 0;
            for (size_t k = 0; k < n; k++)
            {
                temp += m1[i * n + k] * m2[k * n + j];
            }
            res[i*n + j] = temp;
        }
    });
}


// 矩阵相乘，内层使用parfor
void matrixMultiplyParForInner(double* res, const double* m1, const double* m2, size_t n)
{
    for (size_t i = 0; i < n; i++)
    {
        parallel_for(size_t(i), n, [&](size_t j)
        {
            double temp = 0;
            for (size_t k = 0; k < n; k++)
            {
                temp += m1[i * n + k] * m2[k * n + j];
            }
            res[i*n + j] = temp;
        });
    }
}


// 测试矩阵相乘，使用for的时间
double testmatrixMultiplyFor(double* res, const double* m1, const double* m2, size_t n)
{
    LARGE_INTEGER nFreq, nBeginTime, nEndTime;
    QueryPerformanceFrequency(&nFreq);
    QueryPerformanceCounter(&nBeginTime);

    matrixMultiplyFor(res, m1, m2, n);

    QueryPerformanceCounter(&nEndTime);
    return (double)(nEndTime.QuadPart - nBeginTime.QuadPart) * 1000 / (double)nFreq.QuadPart;
}


// 测试矩阵相乘，外层使用parfor的时间
double testmatrixMultiplyParForOuter(double* res, const double* m1, const double* m2, size_t n)
{
    LARGE_INTEGER nFreq, nBeginTime, nEndTime;
    QueryPerformanceFrequency(&nFreq);
    QueryPerformanceCounter(&nBeginTime);

    matrixMultiplyParForOuter(res, m1, m2, n);

    QueryPerformanceCounter(&nEndTime);
    return (double)(nEndTime.QuadPart - nBeginTime.QuadPart) * 1000 / (double)nFreq.QuadPart;
}


// 测试矩阵相乘，内层使用parfor的时间
double testmatrixMultiplyParForInner(double* res, const double* m1, const double* m2, size_t n)
{
    LARGE_INTEGER nFreq, nBeginTime, nEndTime;
    QueryPerformanceFrequency(&nFreq);
    QueryPerformanceCounter(&nBeginTime);

    matrixMultiplyParForInner(res, m1, m2, n);

    QueryPerformanceCounter(&nEndTime);
    return (double)(nEndTime.QuadPart - nBeginTime.QuadPart) * 1000 / (double)nFreq.QuadPart;
}


// 主函数
int _tmain(int argc, _TCHAR* argv[])
{
    const size_t n = 1024;
    double* dM1 = NULL;
    double* dM2 = NULL;
    double* dRes1 = NULL;
    double* dRes2 = NULL;
    double* dRes3 = NULL;

    random_device rd;
    mt19937 gen(rd());

    AllocMatrix(&dM1, n);
    AllocMatrix(&dM2, n);
    IniMatrix(dM1, n, gen);
    IniMatrix(dM2, n, gen);

    AllocMatrix(&dRes1, n);
    AllocMatrix(&dRes2, n);
    AllocMatrix(&dRes3, n);
    
    double dTimeFor = testmatrixMultiplyFor(dRes1, dM1, dM2, n);
    double dTimeParForOuter = testmatrixMultiplyParForOuter(dRes2, dM1, dM2, n);
    double dTimeParForInner = testmatrixMultiplyParForInner(dRes3, dM1, dM2, n);

    printf("time(ms)
for: %f 
parforOunter: %f 
parforInner: %f
", dTimeFor, dTimeParForOuter, dTimeParForInner);

    FreeMatrix(&dM1);
    FreeMatrix(&dM2);
    FreeMatrix(&dRes1);
    FreeMatrix(&dRes2);
    FreeMatrix(&dRes3);

    return 0;
}

debug：

time(ms)

for: 7761.769099

parforOunter: 3416.670736

parforInner: 3423.701265

release：

time(ms)

for: 3884.167485

parforOunter: 1062.581817

parforInner: 1083.642302

说明：此处测试outer和inner是因为，matlab里面，使用outer形式的并行计算，使用parfor后，如果循环比对类似这种三角形式，最终有些核先跑完结果，有些核后跑完结果，导致出现，一个核累死累活的跑程序，另外N-1个核围观的状态，使最终的计算时间变长（不过在matlab中未测试outer和inner使用parfor的时间对比）。

但是，在C++里面，不知道是否优化的原因，outer使用parfor比inner使用parfor要快。此处测试了n=2048，结果也是outer比inner的形式要快。