并行优化是代码优化的基本方法,从大到小一共可以分成三级:异步框架;任务并行;数据并行。在实际工作中,一般是先设计异步框架,包括异步处理任务以及异步任务的异构化等;第二步一般是做数据并行优化(SIMD),利用CPU的向量指令来对多条数据并行处理;这两步是代码优化的重心,一般做完这两步,系统性能会有明显的提升。今天要讨论的是第三步,for循环的并行优化。与前两者不同的是,for循环往往是处理同一类任务,且通常会涉及到对同一个变量的读写,所以异步是不能用,而且for循环中往往包含多种结构比如逻辑判断和算术过程等,所以通常也很难用数据并行的方式来优化,那么怎么对for循环进行优化呢?
直接看两个例子
void testfuc(int num){
int a = 0;
for (int i = 0; i != num; i++) {
int *b = new int[10]();
delete [] b;
}
for循环的目的是申请一段内存空间然后释放,假设num = 1e7;一千万次内存操作在我的机器上(2.6 GHz Intel Core i5双核)运行耗时在900ms左右。
为了对这个for循环进行优化,首先将for循环拆分成若干部分,比如两部分:
void testfuc(int num){
int a = 0;
int num2 = num >> 1;
for (int i = 0; i != num2; i++) {
int *b = new int[10]();
delete [] b;
}
for (int i = num2; i != num; i++) {
int *b = new int[10]();
delete [] b;
}
}
然后使用c11的future+async来启动两个异步任务分别处理一个子循环:
void testfuc2(int num){
int a = 0;
int num2 = num/2;
future ft1 = async(std::launch::async, [&]{
for (int i = 0; i != num2; i++) {
int *b = new int[10]();
delete [] b;
}
});
future ft2 = async(std::launch::async, [&]{
for (int i = num2; i != num; i++) {
int *b = new int[10]();
delete [] b;
}
});
ft1.wait();
ft2.wait();
}
将testfunc1和testfunc2放在一起测试,运行结果如下:
time1 = 992.360000
time2 = 475.182000
显然testfunc2要明显比testfunc1快,在本次运行结果中,时间少了一半,但是这个时间不一定每次都是一半,由于线程切换和CPU状态的影响,testfunc2的时间会比testfunc1节省40%-50%。
原函数为:
void testfuc1(int num){
for (int i = 0; i != num; i++) {
a = cos(tan(i));
}
}
优化后函数为:
void testfuc2(int num){
int num2 = num/2;
future ft1 = async(std::launch::async, [&]{
for (int i = 0; i != num2; i++) {
b = cos(tan(i));
}
});
future ft2 = async(std::launch::async, [&]{
for (int j = num2; j != num; j++) {
c = cos(tan(j));
}
});
ft1.wait();
ft2.wait();
}
运行结果为:
time1 = 806.438000
time2 = 407.875000
前面两个例子,for循环内部都是局部变量,也就是说使用多线程异步处理并不涉及数据竞争,但是现实中我们遇到的for循环大多都包含一个或多个for循环外部变量,在使用多线程异步处理这些变量的时候,要谨慎处理数据竞争,否则会引发未定义操作进而程序崩溃。处理异步任务最常见的是加互斥锁来保护有竞争的数据,那么在for循环的并行优化中是否可行呢,我们感受一下
原函数为
void testfuc1(int num){
for (int i = 0; i != num; i++) {
global = cos(tan(i));
}
}
优化版本:
void testfuc2(int num){
int num2 = num/2;
future ft1 = async(std::launch::async, [&]{
for (int i = 0; i != num2; i++) {
unique_lock lock(mtx);
global = cos(tan(i));
}
});
future ft2 = async(std::launch::async, [&]{
for (int j = num2; j != num; j++) {
unique_lock lock(mtx);
global = cos(tan(j));
}
});
ft1.wait();
ft2.wait();
}
运行结果
time1 = 802.468000
time2 = 46057.028000
是不是大跌眼镜?一个小小的锁,会带来如此大的影响,其实这个也是必然的,因为高频for循环中加锁,会导致CPU频繁切换,甚至可能会导致内存总线被锁住。有关锁的讨论不是本文重点,所以不加讨论。我们关注的是,怎么避免这种情况,或者怎么减少这种情况带来的影响。
有两种思路可以尝试,一是从理论上避免数据竞争,可以给每条线程一个独立的变量,用来保存该线程的结果,然后在各条线程运行结束之后将结果恢复到一个全局变量中;二是从代码上考虑,使用原子数据或者无锁结构,来保证过程中的无锁,对方法1再举个例子:
原函数:
void testfuc1(int num){
for (int i = 0; i != num; i++) {
global += cos(tan(i));
}
}
优化函数:
void testfuc2(int num){
int num2 = num/2;
future ft1 = async(std::launch::async, [&]{
for (int i = 0; i != num2; i++) {
unique_lock lock(mtx);
local1 = cos(tan(i));
}
});
future ft2 = async(std::launch::async, [&]{
for (int j = 0; j != num2; j++) {
unique_lock lock(mtx);
local2 = cos(tan(j));
}
});
global = ft1.get() + ft2.get();
}
futrue参考
数据竞争参考