使用TBB的并行性-我们的检查列表中应该包含哪些内容
Parallelism employing TBB - What should be in our check list?
直到最近,并行编程的前景才引起我的注意。从那以后,我使用了各种并行编程库。也许我第一站是英特尔线程构建块(TBB)。但是,经常成为瓶颈的是由于舍入等因素造成的错误,以及这些程序在不同处理器架构中的不可预测行为。下面是一段代码,用于计算两组值的Pearsons相关系数。它采用了TBB的非常基本的并行模式——*parallel_for*和*parallet_reduce*:
// A programme to calculate Pearsons Correlation coefficient
#include <math.h>
#include <stdlib.h>
#include <iostream>
#include <tbb/task_scheduler_init.h>
#include <tbb/parallel_for.h>
#include <tbb/parallel_reduce.h>
#include <tbb/blocked_range.h>
#include <tbb/tick_count.h>
using namespace std;
using namespace tbb;
const size_t n=100000;
double global=0;
namespace s //Namesapce for serial part
{
double *a,*b;
int j;
double mean_a,mean_b,sd_a=0,sd_b=0,pcc=0;
double sum_a,sum_b,i;
}
namespace p //Namespace for parallel part
{
double *a,*b;
double mean_a,mean_b,pcc;
double sum_a,sum_b,i;
double sd_a,sd_b;
}
class serials
{
public:
void computemean_serial()
{
using namespace s;
sum_a=0,sum_b=0,i=0;
a=(double*) malloc(n*sizeof(double));
b=(double*) malloc(n*sizeof(double));
for(j=0;j<n;j++,i++)
{
a[j]=sin(i);
b[j]=cos(i);
sum_a=sum_a+a[j];
sum_b=sum_b+b[j];
}
mean_a=sum_a/n;
mean_b=sum_b/n;
cout<<"nMean of a :"<<mean_a;
cout<<"nMean of b :"<<mean_b;
}
void computesd_serial()
{
using namespace s;
for(j=0;j<n;j++)
{sd_a=sd_a+pow((a[j]-mean_a),2);
sd_b=sd_b+pow((b[j]-mean_b),2);
}
sd_a=sd_a/n;
sd_a=sqrt(sd_a);
sd_b=sd_b/n;
sd_b=sqrt(sd_b);
cout<<"nStandard deviation of a :"<<sd_a;
cout<<"nStandard deviation of b :"<<sd_b;
}
void pearson_correlation_coefficient_serial()
{
using namespace s;
pcc=0;
for(j=0;j<n;j++)
{
pcc+=(a[j]-mean_a)*(b[j]-mean_b);
}
pcc=pcc/(n*sd_a*sd_b);
cout<<"nPearson Correlation Coefficient: "<<pcc;
}
};
class parallel
{
public:
class compute_mean
{
double *store1,*store2;
public:
double mean_a,mean_b;
void operator()( const blocked_range<size_t>& r)
{
double *a= store1;
double *b= store2;
for(size_t i =r.begin();i!=r.end(); ++i)
{
mean_a+=a[i];
mean_b+=b[i];
}
}
compute_mean( compute_mean& x, split) : store1(x.store1),store2(x.store2),mean_a(0),mean_b(0){}
void join(const compute_mean& y) {mean_a+=y.mean_a;mean_b+=y.mean_b;}
compute_mean(double* a,double* b): store1(a),store2(b),mean_a(0),mean_b(0){}
};
class read_array
{
double *const a,*const b;
public:
read_array(double* vec1, double* vec2) : a(vec1),b(vec2){} // constructor copies the arguments into local store
void operator() (const blocked_range<size_t> &r) const { // opration to be used in parallel_for
for(size_t k = r.begin(); k!=r.end(); k++,global++)
{
a[k]=sin(global);
b[k]=cos(global);
}
}};
void computemean_parallel()
{
using namespace p;
i=0;
a=(double*) malloc(n*sizeof(double));
b=(double*) malloc(n*sizeof(double));
parallel_for(blocked_range<size_t>(0,n,5000),read_array(a,b));
compute_mean sf(a,b);
parallel_reduce(blocked_range<size_t>(0,n,5000),sf);
mean_a=sf.mean_a/n;
mean_b=sf.mean_b/n;
cout<<"nMean of a :"<<mean_a;
cout<<"nMean of b :"<<mean_b;
}
class compute_sd
{
double *store1,*store2;
double store3,store4;
public:
double sd_a,sd_b,dif_a,dif_b,temp_pcc;
void operator()( const blocked_range<size_t>& r)
{
double *a= store1;
double *b= store2;
double mean_a=store3;
double mean_b=store4;
for(size_t i =r.begin();i!=r.end(); ++i)
{
dif_a=a[i]-mean_a;
dif_b=b[i]-mean_b;
temp_pcc+=dif_a*dif_b;
sd_a+=pow(dif_a,2);
sd_b+=pow(dif_b,2);
}}
compute_sd( compute_sd& x, split) : store1(x.store1),store2(x.store2),store3(p::mean_a),store4(p::mean_b),sd_a(0),sd_b(0),temp_pcc(0){}
void join(const compute_sd& y) {sd_a+=y.sd_a;sd_b+=y.sd_b;}
compute_sd(double* a,double* b,double mean_a,double mean_b): store1(a),store2(b),store3(mean_a),store4(mean_b),sd_a(0),sd_b(0),temp_pcc(0){}
};
void computesd_and_pearson_correlation_coefficient_parallel()
{
using namespace p;
compute_sd obj2(a,b,mean_a,mean_b);
parallel_reduce(blocked_range<size_t>(0,n,5000),obj2);
sd_a=obj2.sd_a;
sd_b=obj2.sd_b;
sd_a=sd_a/n;
sd_a=sqrt(sd_a);
sd_b=sd_b/n;
sd_b=sqrt(sd_b);
cout<<"nStandard deviation of a :"<<sd_a;
cout<<"nStandard deviation of b :"<<sd_b;
pcc=obj2.temp_pcc;
pcc=pcc/(n*sd_a*sd_b);
cout<<"nPearson Correlation Coefficient: "<<pcc;
}
};
main()
{
serials obj_s;
parallel obj_p;
cout<<"nSerial Part";
cout<<"n-----------";
tick_count start_s=tick_count::now();
obj_s.computemean_serial();
obj_s.computesd_serial();
obj_s.pearson_correlation_coefficient_serial();
tick_count end_s=tick_count::now();
cout<<"n";
task_scheduler_init init;
cout<<"nParallel Part";
cout<<"n-------------";
tick_count start_p=tick_count::now();
obj_p.computemean_parallel();
obj_p.computesd_and_pearson_correlation_coefficient_parallel();
tick_count end_p=tick_count::now();
cout<<"n";
cout<<"nTime Estimates";
cout<<"n--------------";
cout<<"nSerial Time :"<<(end_s-start_s).seconds()<<" Seconds";
cout<<"nParallel time :"<<(end_p-start_p).seconds()<<" Secondsn";
}
好吧!它在装有酷睿i5的Windows机器上运行得很好。它为输出中的每个参数提供了绝对相同的值,并行代码比串行代码快。这是我的输出:
操作系统:Windows 7 Ultimate 64位处理器:核心i5
Serial Part
-----------
Mean of a :1.81203e-05
Mean of b :1.0324e-05
Standard deviation of a :0.707107
Standard deviation of b :0.707107
Pearson Correlation Coefficient: 3.65091e-07
Parallel Part
-------------
Mean of a :1.81203e-05
Mean of b :1.0324e-05
Standard deviation of a :0.707107
Standard deviation of b :0.707107
Pearson Correlation Coefficient: 3.65091e-07
Time Estimates
--------------
Serial Time : 0.0204829 Seconds
Parallel Time : 0.00939971 Seconds
那么其他机器呢?如果我说它会很好用,那么至少我的一些朋友会说:"伙计,等等!有点可疑。"在不同的机器中,答案(由并行代码和串行代码产生的答案之间)有微小的差异,尽管并行代码总是比串行代码快。那么,是什么造成了这些差异呢?我们得出的结论是,这种异常行为是以过度并行和处理器架构差异为代价的舍入误差。
这引出了我的问题:
- 当我们使用并行时,我们需要采取哪些预防措施处理我们代码中的库以利用多核处理器
- 在什么情况下,我们甚至不应该使用平行方法尽管有多个处理器可用
- 为了避免舍入误差,我们能做的最好的事情是什么?(让我来指定我不是在谈论强制执行互斥和屏障有时可能会限制平行度的延伸,但大约简单的编程技巧有时很方便)
我很高兴看到你对这些问题的建议。请随意回答如果你有时间限制,最适合你的部分。
编辑-我在此处包含了更多结果
操作系统:Linux Ubuntu 64位处理器:核心i5
Serial Part
-----------
Mean of a :1.81203e-05
Mean of b :1.0324e-05
Standard deviation of a :0.707107
Standard deviation of b :0.707107
Pearson Correlation Coefficient: 3.65091e-07
Parallel Part
-------------
Mean of a :-0.000233041
Mean of b :0.00414375
Standard deviation of a :2.58428
Standard deviation of b :54.6333
Pearson Correlation Coefficient: -0.000538456
Time Estimates
--------------
Serial Time :0.0161237 Seconds
Parallel Time :0.0103125 Seconds
操作系统:Linux Fedora 64位处理器:核心i3
Serial Part
-----------
Mean of a :1.81203e-05
Mean of b :1.0324e-05
Standard deviation of a :0.707107
Standard deviation of b :0.707107
Pearson Correlation Coefficient: 3.65091e-07
Parallel Part
-------------
Mean of a :-0.00197118
Mean of b :0.00124329
Standard deviation of a :0.707783
Standard deviation of b :0.703951
Pearson Correlation Coefficient: -0.129055
Time Estimates
--------------
Serial Time :0.02257 Seconds
Parallel Time :0.0107966 Seconds
编辑:更改后哪一天建议
操作系统:Linux Ubuntu 64位处理器:corei5
Serial Part
-----------
Mean of a :1.81203e-05
Mean of b :1.0324e-05
Standard deviation of a :0.707107
Standard deviation of b :0.707107
Pearson Correlation Coefficient: 3.65091e-07
Parallel Part
-------------
Mean of a :-0.000304446
Mean of b :0.00172593
Standard deviation of a :0.708465
Standard deviation of b :0.7039
Pearson Correlation Coefficient: -0.140716
Time Estimates
--------------
Serial Time :0.0235391 Seconds
Parallel time :0.00810775 Seconds
谨致问候。
注意1:我不能保证上面的代码是正确的。我相信是的。
注意2:这段代码也在Linux盒子上进行了测试
注意3:尝试了不同的粒度组合和自动分区选项
我对compute_mean( compute_mean& x, split)
构造函数中注释掉的/*,mean_a(0),mean_b(0)*/
深表怀疑。似乎您的差异可能是由于未初始化的数据污染了结果。我猜,在你得到一致结果的机器上,没有发生任务分割,或者这些成员恰好在零内存上。
类似地,您的compute_sd( compute_sd& x, split)
使store3
和store4
未初始化。
这引出了我的问题:
当我们在代码中使用并行处理库来利用多核处理器时,我们需要采取哪些预防措施?
除了timday答案中的要点之外,您的问题似乎并不是并行性特有的。使用浮点数进行计算的稳定算法很难设计;高效使用并行性所固有的较低的决定论暴露了不充分的算法总是存在的问题。我的意思见下文。在决定是并行性还是算法导致数值不稳定之前,您应该测试串行代码相对于输入数据顺序的稳健性。
在哪些情况下,即使有多个处理器可用,我们也不应该使用并行方法?
当循环中没有足够的操作来支付开销时。这取决于算法、硬件和问题大小。
为了避免舍入错误,我们能做的最好的事情是什么?(让我明确指出,我不是在谈论强制执行互斥和屏障,这可能会在某个时候限制并行性的扩展,而是谈论一些简单的编程技巧,这些技巧有时很方便)
无论是编写串行代码还是并行代码,都应该使用为数值稳定性而设计的算法。你在高中时教的那些东西是为了便于理解!:-)例如,请参见http://en.m.wikipedia.org/wiki/Algorithms_for_calculating_variance.
- C++ 创建包含链表和字符串的对象的链接列表时出错
- 在子集化后将包含索引号的列表列表映射到标准索引序列
- 范围 v3 可以包含初始值设定项列表的工作吗?
- 链接列表在 cpp 中包含不同的对象类
- 动态分配列表 - 创建一个函数,用于删除所有包含偶数值的元素
- 如何将包含括号的字符串列表平展为单个列表?
- 如何在两个列表中比较和获取非包含值
- 给定一个源文件,有没有办法要求 gcc 返回仅直接包含的头文件的列表?
- 编译包含指向模板函数的指针的初始值设定项列表时,gcc 出错,但 clang 不出错
- 生成包含给定类型的 N 个参数的可变参数列表的最佳方法?
- C++:如何初始化包含具有给定键的指针列表的映射
- 如何在C++中创建 2d 数组,其中一部分包含循环计数器,另一部分包含数字列表?
- 在包含该类列表的结构后定义的C 类
- 我有一个包裹的矢量.我该如何判断它包含哪种类型
- 如何在(C )构造函数参数列表中包含std:列表
- 如何显示地图 stl 中包含的列表
- 递归包含自身列表的对象
- 当此列表包含父列表时,如何遍历列表,它使用标准列表
- 填充到一个向量中,该向量包含指向列表的指针
- 是否可以键入一个结构,比如 A,它包含一个列表的迭代器<A>?