向量化实现矩阵运算优化(一)

xsimd简介

  xsimd是C++的一个开源simd库，实现了对常见simd指令的封装，从而使得simd的操作更为简单。接下来先从两个简单的例子来入门xsimd。

1. void average(const std::vector<double>& v1, const std::vector<double>& v2, std::vector<double>& v) {
2.     int n = v.size();
3.     int size = xsimd::batch<double, xsimd::avx>::size;
4.     int loop = n - n % size;
6.     for (int i = 0; i < loop; i += size) {
7.         auto a = xsimd::batch<double>::load_unaligned(&v1[i]);
8.         auto b = xsimd::batch<double>::load_unaligned(&v2[i]);
9.         auto res = a + b;
10.         res.store_unaligned(&v[i]);
11.     }
12.     for (int i = loop; i < n; ++i)
13.         v[i] = v1[i] + v2[i];
14. }

复制代码

  上述demo实现了两个向量相加的操作，由于每次都能从vector当中加载size个数据，因此对剩余的不能进行vectorize的数据进行了分别处理。比如说，有一百个数据，每次处理8个数据，到最后剩下4个数不能凑到8，所以用朴素的迭代方式进行求和。这个demo是非对齐内存的处理方式。

1. using vector_type = std::vector<double, xsimd::default_allocator<double>>;
2. std::vector<double> v1(1000000), v2(1000000), v(1000000);
3. vector_type s1(1000000), s2(1000000), s(1000000);
5. void average_aligned(const vector_type& s1, const vector_type& s2, vector_type& s) {
6.     int n = s.size();
7.     int size = xsimd::batch<double>::size;
8.     int loop = n - n % size;
10.     for (int i = 0; i < loop; i += size) {
11.         auto a = xsimd::batch<double>::load_aligned(&s1[i]);
12.         auto b = xsimd::batch<double>::load_aligned(&s2[i]);
13.         auto res = a + b;
14.         res.store_aligned(&s[i]);
15.     }
17.     for (int i = loop; i < n; ++i)
18.         s[i] = s1[i] + s2[i];
19. }

复制代码

  要实现对齐内存的操作方式，我们必须对vector指定特定的分配器，不然最后运行出来的代码会出现segment fault。
  总之，要记住常用的api，load_aligned, store_aligned, load_unaligned, store_unaligned，它们分别对应了内存对齐与否的处理方式。接下来我们再讲解另外一个demo，并且提供与openmp的性能对比。

1. auto sum(const std::vector<double>&v) {
2.     int n = v.size();
3.     int size = xsimd::batch<int>::size;
4.     int loop = n - n % size;
6.     double res{};
7.     for (int i = 0; i < loop; ++i) {
8.         auto tmp = xsimd::batch<int>::load_unaligned(&v[i]);
9.         res += xsimd::hadd(tmp);
10.     }
12.     for (int i = loop; i < n; ++i) {
13.         res += v[i];
14.     }
16.     return res;
17. }
19. auto aligned_sum(const std::vector<double, xsimd::default_allocator<double>>& v) {
20.     int n = v.size();
21.     int size = xsimd::batch<int>::size;
22.     int loop = n - n % size;
24.     double res{};
25.     for (int i = 0; i < loop; ++i) {
26.         auto tmp = xsimd::batch<int>::load_aligned(&v[i]);
27.         res += xsimd::hadd(tmp);
28.     }
30.     for (int i = loop; i < n; ++i) {
31.         res += v[i];
32.     }
33.    
34.     return res;
35. }

复制代码

  这个例子实现了对向量求和的功能。总体与前面基本一样，这里hadd是一个对向量求和的函数。
  对于openmp的向量化实现，则较为简单，只需要在for循环上面加上特定指令即可。不过需要注意的是，openmp支持C语法，有一些C++的新特性可能并不支持，而且需要把花括号放到下一行，我们来看具体操作。

1. auto parallel_sum(const std::vector<double>& v) {
2.     double res{};
4.     int n = v.size();
5.     #pragma omp simd
6.     for (int i = 0; i < n; ++i)
7.         res += v[i];
9.     return res;
10. }

复制代码

  不要忘记加上编译选项-fopenmp和-march=native，为了性能测试，我开启了O2优化，以下是简单的测试结果，数据规模是一千万。

  一般情况下进行了内存对齐都会比没有对齐的要快一些，同时可以看到openmp与xsimd也差了一个量级。当然不同平台的结果可能会有差异，需要用更专业的工具进行测量比较。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！