c++ 对for循环的并行优化例子

什么是并行优化？

并行优化是代码优化的基本方法，从大到小一共可以分成三级：异步框架；任务并行；数据并行。在实际工作中，一般是先设计异步框架，包括异步处理任务以及异步任务的异构化等；第二步一般是做数据并行优化(SIMD)，利用CPU的向量指令来对多条数据并行处理；这两步是代码优化的重心，一般做完这两步，系统性能会有明显的提升。今天要讨论的是第三步，for循环的并行优化。与前两者不同的是，for循环往往是处理同一类任务，且通常会涉及到对同一个变量的读写，所以异步是不能用，而且for循环中往往包含多种结构比如逻辑判断和算术过程等，所以通常也很难用数据并行的方式来优化，那么怎么对for循环进行优化呢？

怎么对for循环并行优化？

直接看两个例子

例1 内存操作

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<void> ft1 = async(std::launch::async, [&]{
        for (int i = 0; i != num2; i++) {
            int *b = new int[10]();
            delete [] b;
        }
    });
    
    future<void> 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%。

例2 复杂计算

原函数为：

void testfuc1(int num){
    for (int i = 0; i != num; i++) {
        a = cos(tan(i));
    }
}

优化后函数为：

void testfuc2(int num){
    int num2 = num/2;
    future<void> ft1 = async(std::launch::async, [&]{
        for (int i = 0; i != num2; i++) {
            b = cos(tan(i));
        }
    });
    
    future<void> 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循环的并行优化中是否可行呢，我们感受一下

例3 互斥锁带来的竞争消耗

原函数为

void testfuc1(int num){
    for (int i = 0; i != num; i++) {
        global = cos(tan(i));
    }
}

优化版本：

void testfuc2(int num){
    int num2 = num/2;
    future<void> ft1 = async(std::launch::async, [&]{
        for (int i = 0; i != num2; i++) {
            unique_lock<mutex> lock(mtx);
            global = cos(tan(i));
        }
    });
    
    future<void> ft2 = async(std::launch::async, [&]{
        for (int j = num2; j != num; j++) {
            unique_lock<mutex> lock(mtx);
            global = cos(tan(j));
        }
    });
    
    ft1.wait();
    ft2.wait();
}

运行结果

time1 = 802.468000
time2 = 46057.028000

是不是大跌眼镜？一个小小的锁，会带来如此大的影响，其实这个也是必然的，因为高频for循环中加锁，会导致CPU频繁切换，甚至可能会导致内存总线被锁住。有关锁的讨论不是本文重点，所以不加讨论。我们关注的是，怎么避免这种情况，或者怎么减少这种情况带来的影响。
有两种思路可以尝试，一是从理论上避免数据竞争，可以给每条线程一个独立的变量，用来保存该线程的结果，然后在各条线程运行结束之后将结果恢复到一个全局变量中；二是从代码上考虑，使用原子数据或者无锁结构，来保证过程中的无锁，对方法1再举个例子：

例子4 局部变量替代全局变量

原函数：

void testfuc1(int num){
    for (int i = 0; i != num; i++) {
        global += cos(tan(i));
    }
}

优化函数：

void testfuc2(int num){
    int num2 = num/2;
    future<double> ft1 = async(std::launch::async, [&]{
        for (int i = 0; i != num2; i++) {
            unique_lock<mutex> lock(mtx);
            local1 = cos(tan(i));
        }
    });
    
    future<double> ft2 = async(std::launch::async, [&]{
        for (int j = 0; j != num2; j++) {
            unique_lock<mutex> lock(mtx);
            local2 = cos(tan(j));
        }
    });
    
    global = ft1.get() + ft2.get();
}

参考

futrue参考
数据竞争参考