数值计算优化方法C/C++(三)——SIMD

SIMD

1、概述

SIMD全称Single Instruction Multiple Data，单指令多数据流，能够读取多个操作数，并把它们打包在大型寄存器的一组指令集。一次获取多个操作数后，存放于一个大型寄存器，再进行运算，从而达到一条指令完成对多个对象计算的效果，实现加速。目前常见编译器对X86-64的CPU上128bit的SIMD计算支持比较好，基本对于大多简单的计算都可以做到使用SIMD做一个简单的优化，但是对于较为复杂的操作依旧需要手动编写相应的C/C++或者汇编代码。

Intel官网上SIMD指令使用的相关指南
https://software.intel.com/sites/landingpage/IntrinsicsGuide/#

2、简单使用

SIMD这个东西我到现在也不是很会用，包括测试一些例子可能用了SIMD更慢了，而且我的CPU比较老了，只支持AVX2.0(AVX-512好像现在的i9和i7 9800x都已经支持了，不过我这个还在用四代i7的也买不起这玩意)。因此对于双精度浮点型运算，只能一次打包256bit的数据，即四个双精度浮点数。对了这里需要注意的一点是，在使用gcc编译带有immintrin.h头文件函数的代码时，根据你使用的函数类别，需要添加相应的编译选项(老的SSE是默认支持的通常不需要额外添加选项)，如AVX2.0就需要使用-mavx2、FMA需要使用-mfma等等，否则编译会报错。如果你不知道用了什么指令集，但是你确定你的电脑支持这个操作，那么直接-march=native就可以了。其实如果你使用了AVX-512F指令集，那么-mavx512f也可以成功编译，不过如果你的CPU不支持AVX-512F那么你运行编译出来的文件的时候就会提示非法指令(#滑稽)。

矢量加法

没错又是矢量相加，这次我们也不搞什么花哨的了，就是C的矢量相加

#include 
using namespace std;
#define N 20000000
int main(){
    double *x,*y,*z;
    x=(double*)malloc(sizeof(double)*N);
    y=(double*)malloc(sizeof(double)*N);
    z=(double*)malloc(sizeof(double)*N);
    for(int i=0;i

然后我们再用SIMD写一个，要使用SIMD技术需要Intrinsics头文件，这其中有好多不同的头文件，具体哪个有什么用我也不是特别清楚，不过一般计算用immintrin.h基本就可以了。

#include 
#include 
#define N 20000000
using namespace std;
int main(){
    double *x,*y,*z,*px,*py,*pz;
    x=(double*)_mm_malloc(sizeof(double)*N,16);//申请内存并且按照2的4次方对齐地址
    y=(double*)_mm_malloc(sizeof(double)*N,16);
    z=(double*)_mm_malloc(sizeof(double)*N,16);
    px=x;py=y;pz=z;
    __m128d vx,vy,vz;// __m128d是SSE指令集中操作双精度浮点数对应的数据类型
    for(int i=0;i

好了程序写好接下来就是测试了，经过测试两个程序的计算结果都是正确的，由于测计算结果还要写赋值我嫌麻烦就不写了，有兴趣的可以自己赋个值看一下结果对不对。这里就测一下效率，首先依旧是g++的O0条件下的测试。

未使用SIMD的用时

real	0m0.167s
user	0m0.092s
sys		0m0.075s

使用SIMD的用时

real	0m0.175s
user	0m0.122s
sys		0m0.053s

可以看到O0优化下SIMD较慢，不过二者用时差距也不大，多次测试感觉基本就是这个范围上下波动，可以认为两个效率相当，或者SIMD略慢一点。

接下来是O3条件下测试
未使用SIMD时

real	0m0.112s
user	0m0.040s
sys		0m0.072s

使用SIMD时

real	0m0.113s
user	0m0.044s
sys		0m0.068s

二者基本没有区别，我尝试过加大数组维度，但是由于内存只有4G所以增加的也不多，我也尝试过反复相加，最后测试结果都是不论是否使用编译器优化使用SIMD始终没有提高效率。也就是说在这个示例中SIMD是没有作用的，甚至使得计算变慢。

后来看了一些网上的帖子也有人遇到了与我类似的情况。

有人提到了在进行一些简单运算时，编译器会在你没有主动使用SIMD的情况下通过一些优化技术自动转换为SIMD的代码，所以你自己写的使用SIMD的代码最快也不会超过编译器自动优化的结果。

还有一些人说是SIMD的额外开销是比较大的，对于这种简单加法，使用SIMD带来的计算上的效率提升，掩盖不了使用SIMD带来的额外性能损失，可能计算比较复杂时SIMD才有加速的效果。

另外还有一种说法是XMM寄存器总共有8个，而这里并没有把8个寄存器都用上，从而并没有发挥出全部的性能，所以没有效果。

通过g++的-S选项生成汇编代码可以看到，编译器自动优化这部分代码，不论是使用immintrin.h头文件中的函数，还是使用循环直接计算，生成的汇编代码基本相同，也就是说编译器已经自动优化了这部分的运算，因此并没有什么效果。

---

复数数组乘法

复数数组的乘法是我在写一个快速傅里叶变换的实现的时候测试的，发现使用AVX2.0之后效率确实有明显提升，这里简单展示一下

首先是计算的原理，因为复数计算不同于实数，根据实部和虚部的关系，在计算时常常会因为浮点数的位置不同而需要采用不同的运算方式，所以在使用SIMD加速时也需要做一些处理和变化。这里使用AVX2.0指令，一次操作256bit的数据，即4个双精度浮点数，2个双精度复数。因此，这里测试时采用z1[2]与z2[2]两个复数数组进行相乘。具体的计算如下：

为了方便我们记：
z1中的两个复数为a0 + i * b0和a1 + i * b1
z2中的两个复数为c0 + i * d0和c1 + i * d1

这时计算结果就表示为：
(a0 * c0 - b0 * d0) + i * (a0 * d0 + b0 * c0)和(a1 * c1 - b1 * d1) + i * (a1 * d1+b1 * c1)

对于计算结果可以拆解为两部分：
{a0 * c0 , a0 * d0 , a1 * c1 , a1 * d1}
{b0 * d0 , b0 * c0 , b1 * d1 , b1 * c1}
将这两部分的偶数下标位相减，奇数下标位相加就可以得到最终的计算结果，恰好AVX2.0为我们提供了这条指令。

再进一步分解：
{a0 , a0 , a1 , a1}
{c0 , d0 , c1 , d1}
相乘可以得到第一部分而
{b0 , b0 , b1 , b1}
{d0 , c0 , d1 , c1}
相乘可以得到第二部分

可以看出，复数乘法计算可以通过将z1中的实部取出与z2直接做乘法，再将z1中的虚部取出与z2的实部虚部交换之后的排列做乘法，最终再交错进行加减得到最终结果。

尽管看起来操作十分繁琐，不过幸运的是其实这些操作都可以找到相应的指令的来完成。

在immintrin.h头文件中，有一个__m256d _mm256_permute_pd (__m256d a, int imm8)函数。

这个函数接收一个__m256d变量和一个4位的即时数(0-15的十进制字面值)，根据imm8的每一个二进制位上的数来决定该a中的对应位置的数是保持不变还是替换为其前后的数。最终得到一个新的__m256d变量，并返回。具体的规则如下：
IF (imm8[0] == 0) dst[63:0] := a[63:0]
IF (imm8[0] == 1) dst[63:0] := a[127:64]
IF (imm8[1] == 0) dst[127:64] := a[63:0]
IF (imm8[1] == 1) dst[127:64] := a[127:64]
IF (imm8[2] == 0) dst[191:128] := a[191:128]
IF (imm8[2] == 1) dst[191:128] := a[255:192]
IF (imm8[3] == 0) dst[255:192] := a[191:128]
IF (imm8[3] == 1) dst[255:192] := a[255:192]
基本原理就是两个数为一组，00,01,10,11分别代表这两个数交换、保持不变或者前一个覆盖后一个，后一个覆盖前一个。

前面已经提到了，我们需要一个只包含z1实部的__m256d变量和一个只包含z1虚部的__m256d变量。

这里令imm8=15即可完成由虚部覆盖实部的替换，而实部覆盖虚部可以通过令imm8=0来实现，不过这里用_mm256_movedup_pd函数也可以达到相同的效果(这里吐槽一下，在SSE3中，通过_mm_moveldup_ps可以直接完成4个单精度数中由奇数下标覆盖偶数下标的操作，但是这个指令只有操作4个单精度浮点数才有，其他情况都只支持偶数下标覆盖奇数下标，反过来就不支持，难道4个单精度浮点数操作在硬件实现上有优势？)这样我们就可以得到相应的只包含实部和只包含虚部的_mm256d变量

接下来令imm8=10即可将z2中的两个复数的实部和虚部调转，这样就成功得到了计算需要的四个_mm256d变量，然后就可以计算了。

FMA乘加融合可以一次性完成a * b + c的操作，这一指令相对于分开计算拥有更快的速度和更高的精度，同时在immintrin.h中还提供了_mm256_fmaddsub_pd可以完成对偶数下标位相加，奇数下标位相减的操作。

具体的实现如下：

void mul(complex *x,complex *y){
    __m256d tx,ty,r;
    tx=_mm256_loadu_pd((double*)(x));
    ty=_mm256_loadu_pd((double*)(y));
    r=_mm256_permute_pd(ty,5)*_mm256_permute_pd(tx,15);
    _mm256_storeu_pd((double*)(x),_mm256_fmaddsub_pd(ty,_mm256_movedup_pd(tx),r));
}

接下来测试一下效率

#define N 10000
int main(){
    complex x[2],y[2];
    x[0]=complex(1,0);
    x[1]=complex(-1,0);
    y[0]=complex(0,1);
    y[1]=complex(0,-1);
    for(int j=0;j

使用g++ -O3优化，直接用标准库中重载的 * 进行相乘用时为：

(1,-0)	(-1,-0)

real	0m0.714s
user	0m0.714s
sys		0m0.000s

使用SIMD加速之后的mul函数的用时为：

(1,-0)	(-1,-0)

real	0m0.489s
user	0m0.485s
sys		0m0.004s

可以看到使用SIMD加速之后复数计算的效率有了明显的提高，因此也从侧面说明对于数组相加的那个例子，由于计算简单，编译器早已做了相应的SIMD加速，自己去写相应的操作并不能使速度加快。

---

矩阵转置

最近测试了一下用SIMD实现矩阵转置法现加速效果不错
这里先说一下算法，利用AVX指令集可以一次操作4个双精度浮点数，因此通过读取四个__m256d的数据，一次做一个4x4的方阵转置，而对于大于4x4的方阵则可以先完成每一个小块的转置，再把子块的位置进行转置，对于非原址的转置，直接把转置完的子块写到对应的位置就可以了。

以4x4矩阵为例，假设原始矩阵是
a0,a1,a2,a3
b0,b1,b2,b3
c0,c1,c2,c3
d0,d1,d2,d3
转置完成后就应该是
a0,b0,c0,d0
a1,b1,c1,d1
a2,b2,c2,d2
a3,b3,c3,d3

这里我们需要用到AVX和AVX2指令集中_mm256_unpacklo_pd、_mm256_unpackhi_pd、 _mm256_permute4x64_pd、 _mm256_blend_pd四个操作。

_mm256_unpacklo_pd接受两个__m256d参数，并且将两个传入的参数中的第一、第三个数按顺序组成新的__m256d返回，例如当传入a0,a1,a2,a3和b0,b1,b2,b3时，则返回a0,b0,a2,b2

_mm256_unpackhi_pd与_mm256_unpacklo_pd基本相似，只不过是取得传入值的第二、第四个数组合返回

_mm256_permute4x64_pd接受一个__m256d参数和一个8位二进制数，8位二进制数每两个一组根据其在相应的8位二进制数中的位置，将传入的__m256d的第几位赋到返回的__m256d的第几位，例如传入a0,a1,a2,a3和0b11100100(转换为四个十进制数是3,2,1,0)，那么返回的值就是a3,a2,a1,a0，这里需要注意一点是寄存器中的数据排列问题，如果我们要倒置内存中的整个序列实际上应该给的二进制数是0b00011011

_mm256_blend_pd接受两个__m256d参数a和b，和一个四位二进制数，根据二进制数中每一位是1还是0，确定生成的新的__m256d对应位置是取a的值还是b的值，例如传入a0,a1,a2,a3和b0,b1,b2,b3和0b0101则生成的数据应该a0,b1,a2,b3，同样这里也需要注意寄存器中数据的排列。

有了这四个函数我们就可以设计转置的算法了，首先我们倒过来推
要得到a0,b0,c0,d0和a1,b1,c1,d1
我们考虑使用_mm256_unpacklo_pd和_mm256_unpackhi_pd同时生成两个转置后的序列
那么我们就应该有a0,a1,c0,c1和b0,b1,d0,d1
我们发现a0,a1,c0,c1而可以将a0,a1,a2,a3和c2,c3,c0,c1通过_mm256_blend_pd生成
而a0,a1,a2,a3就是原始序列，c2,c3,c0,c1可以通过_mm256_permute4x64_pd来对c0,c1,c2,c3重排得到，而b0,b1,d0,d1也可以用同样的方法得到。通过这样重排、混洗我们就可以实现一个4x4的矩阵转置，具体的代码如下：

			double* x=(double*)_mm_malloc(sizeof(double)*4*4,32);
    		double* y=(double*)_mm_malloc(sizeof(double)*4*4,32);
			double *p1=x,*p2=x+4,*p3=x+8,*p4=x+12;
   			double *d1=x,*d2=x+4,*d3=x+8,*d4=x+12,
   			int k=0;    
	    	for(int i=0;i<4;i++)
	    	{
    	    	for(int j=0;j<4;j++)
  	      		{
 	           		x[k++]=i;
        		}
    		}
			__m256d s1,s2,s3,s4,t1,t2,t3,t4,t5,t6,t7,t8;
			s1=_mm256_load_pd(p1);
            s2=_mm256_load_pd(p2);
            s3=_mm256_load_pd(p3);
            s4=_mm256_load_pd(p4);
            t1=_mm256_permute4x64_pd(s1,0b01001110);//先对四个序列进行重排，把前两位和后两位调换a2,a3,a0,a1
            t2=_mm256_permute4x64_pd(s2,0b01001110);//b2,b3,b0,b1
            t3=_mm256_permute4x64_pd(s3,0b01001110);//c2,c3,c0,c1
            t4=_mm256_permute4x64_pd(s4,0b01001110);//d2,d3,d0,d1
            t5=_mm256_blend_pd(s1,t3,0b1100);//将一个调换过的序列和一个原序列进行合并用以完成最后一步混洗a0,a1,c0,c1
            t6=_mm256_blend_pd(s2,t4,0b1100);//b0,b1,d0,d1
            t7=_mm256_blend_pd(t1,s3,0b1100);//a2,a3,c2,c3
            t8=_mm256_blend_pd(t2,s4,0b1100);//b2,b3,d2,d3
            s1=_mm256_unpacklo_pd(t5,t6);//将合并的序列进行混洗，得到转置序列a0,b0,c0,d0
            s2=_mm256_unpackhi_pd(t5,t6);//a1,b1,c1,d1
            s3=_mm256_unpacklo_pd(t7,t8);
            s4=_mm256_unpackhi_pd(t7,t8);
            _mm256_store_pd(d1,s1);
            _mm256_store_pd(d2,s2);
            _mm256_store_pd(d3,s3);
            _mm256_store_pd(d4,s4);
            k=0
            for(int i=0;i

这样就完成了4x4的矩阵转置，接下来就是进行大规模矩阵转置测试一下性能了，以4096的方阵为例，SIMD的转置代码如下

#include 
#include 
using namespace std;
#define N 4096
int main()
{
    double* x=(double*)_mm_malloc(sizeof(double)*N*N,32);
    double* y=(double*)_mm_malloc(sizeof(double)*N*N,32);
    int k=0;    
    for(int i=0;i<16;i++)
    {
        for(int j=0;j<16;j++)
        {
            x[k++]=i;
        }
    }
    double *p1,*p2,*p3,*p4;
    double *d1,*d2,*d3,*d4,*t=y;
    d1=y;d2=y+N;d3=y+2*N;d4=y+3*N;
    p1=x;p2=x+N;p3=x+2*N;p4=x+3*N;
    t+=4;
    for(int i=0;i

而原始代码如下：

#include 
#include 
using namespace std;
#define N 4096
int main()
{
    double* x=(double*)_mm_malloc(sizeof(double)*N*N,32);
    double* y=(double*)_mm_malloc(sizeof(double)*N*N,32);
    int k=0;    
    for(int i=0;i

测试均使用-O2优化编译，最终测试结果如下：
未使用SIMD

real	0m0.453s
user	0m0.393s
sys		0m0.061s

使用SIMD

real	0m0.147s
user	0m0.087s
sys		0m0.060s

可以看到通过SIMD加速，4096的方阵转置的性能提高了将近3倍。

由于本人水平也有限，不能保证测试一定正确。最近也在学习SIMD，后续有时间我也会考虑再加上一些别的简单使用的测试，补充完善一些。另外我在看张先轶老师的一个openblas矩阵乘法优化讲座时，看到了SIMD的使用，我跟着也写过一个，实测是有一定的效率提升的，具体代码和测试在我会写在后面的文章中的。

上一篇：数值计算优化方法C/C++(二)——表达式模板
下一篇：数值计算优化方法C/C++(四)——矩阵乘法优化示例(访存优化和SIMD的使用)