（原）测试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, , sizeof(double)*n*n);
 }
 
 // 初始化矩阵内容
 template <class Gen>
 void IniMatrix(double* m, size_t n, Gen& gen)
 {
     for (size_t i = ; i < n; ++i)
     {
         for (size_t j = ; 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 = ; i < n; i++)
     {
         for (size_t j = i; j < n; j++)
         {
             double temp = ;
             for (size_t k = ; 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(), n, [&](size_t i)
     {
         for (size_t j = i; j < n; j++)
         {
             double temp = ;
             for (size_t k = ; 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 = ; i < n; i++)
     {
         parallel_for(size_t(i), n, [&](size_t j)
         {
             double temp = ;
             for (size_t k = ; 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) *  / (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) *  / (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) *  / (double)nFreq.QuadPart;
 }
 
 // 主函数
 int _tmain(int argc, _TCHAR* argv[])
 {
     const size_t n = ;
     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)\nfor: %f \nparforOunter: %f \nparforInner: %f\n", dTimeFor, dTimeParForOuter, dTimeParForInner);
 
     FreeMatrix(&dM1);
     FreeMatrix(&dM2);
     FreeMatrix(&dRes1);
     FreeMatrix(&dRes2);
     FreeMatrix(&dRes3);
 
     return ;
 }

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的形式要快。