C++性能优化系列——3D高斯核卷积计算(四)Intrinsic实现一维卷积与循环展开

浅浅的花香味﹌ 2022-12-08 01:55 197阅读 0赞

基于 [C++性能优化系列——3D高斯核卷积计算(二)FMA向量化计算一维卷积][C_3D_FMA] 中实现，本文用Intrinsic实现向量化的一维卷积计算。

## 代码实现 ##

为了使执行时间统计结果稳定，增加执行次数

#define CONVREPEAT (100000*20)

构造向量化卷积核

const int KERNELSize = 31;
    float* pSimdKernel = new float[KERNELSize * 8];
    float* pSimdInit = pSimdKernel;
    for (int i = 0; i < KERNELSize; ++i)
    { 
    	for (int j = 0; j < 8; ++j)
    	{ 
    		*pSimdInit = Kernel[i];
    		++pSimdInit;
    	}
    }

代码实现

Conv1D_Ins_Cmb(float* pSrcLine, int iLength, float* pKernel, int kernelSize, float* pDstLine,float* pSimdKernel)
    { 
    
    	int iConvSize = iLength - kernelSize + 1;
    	float* pDstTemp = pDstLine + kernelSize / 2;
    	for (int kx = 0, start = 0; kx < kernelSize; kx++, start++)
    	{ 
    		__m256 ker = _mm256_loadu_ps(pSimdKernel + 8 * kx);
    		int x = 0;
    		for (; x < iConvSize - 8; x += 8)
    		{ 
    			__m256 src = _mm256_loadu_ps(pSrcLine + start + x);
    			__m256 dst = _mm256_loadu_ps(pDstTemp + x);
    			dst = _mm256_fmadd_ps(ker, src, dst);
    			_mm256_storeu_ps(pDstTemp + x, dst);
    		}
    		for (;x < iConvSize; ++x)
    		{ 
    			pDstTemp[x] += pSrcLine[start + x] * pKernel[kx];
    		}
    	}
    }

参数说明

pSrcLine原始一维数据指针
    iLength原始数据长度
    pKernel一维卷积核指针
    kernelSize卷积核长度
    pDstLine目标一维数据指针
    pSimdKernel向量化卷积核数据指针

执行时间

TestConv1D(Conv1D_Ins_Cmb_Test) cost total Time 1532
    TestConv1D cost Time 0.000766

实现逻辑不再叙述，这里主要说明一点：因为目标机器支持向量化长度为256bit（即8个float），做一维卷积时，无法保证数据的长度刚好是8的整数倍，因此，剩余的长度要进行标量计算。

## Intrinsic函数解释 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center]

## 性能分析 ##

通过指令实现的一维卷积计算时间比编译器向量化速度慢。通过VTune分析性能，查看原因。  
基于 [C++性能优化系列——3D高斯核卷积计算(二)FMA向量化计算一维卷积][C_3D_FMA] 中实现，同时增加执行次数，重新统计执行情况。耗时如下

TestConv1D(CONVOPT) cost total Time 1211
    TestConv1D cost Time 0.0006055

ICC版本  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 1]

Intrinsic版本  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 2]

Intrinsic版本for语句对应汇编  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 3]

可以看到：卷积计算部分，指令执行数量和耗时上Intrinsic版本都优于ICC优化版本。但是Intrinsic版本的for语句对应的汇编指令数量非常多，几乎相当于ICC向量化版本所用指令（计算语句和for语句）的总和。因此Intrinsic版本执行时间增加。本人暂时搞不清楚为什么for语句会执行这么多次，针对这个问题的优化处理措施希望各位博友赐教。

## 总结 ##

本文通过Intrinsic指令实现一维卷积计算。实际执行效果比ICC向量化版本差。目前**遗留两个问题**：  
1.原则上两个版本的for语句的指令执行次数不应该差距这么大，造成的原因目前还没调查清楚。  
2.是否存在规避这个问题的优化策略（经过试验，循环展开可以有效减少for指令执行次数）。

## 更新 ##

这里针对问题1：for语句指令过多的原因做出解释。  
ICC for模块部分汇编  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 4]  
可以看到ICC编译器已经使用FMA指令计算，并将循环做了2倍展开。因此，对比Intrinsic实现的，for语句对应的指令是2倍展开的数量，这也就能解释之前指令数的问题。

针对问题2：for语句指令过多问题，循环展开可以对其优化。将前文中Intrinsic实现的版本做2倍展开，一次循环刚好处理512bit数据，保证数据适应cacheline的尺寸。

ICC展开，代码实现

void Conv1D_Ins_ICCUnroll2(float* pSrcLine, int iLength, float* pKernel, int iKernelSize, float* pDstLine,float* pSimdKernel)
    	{ 
    
    		int iConvSize = iLength - iKernelSize + 1;
    		float* pDstTemp = pDstLine + iKernelSize / 2;
    		for (int kx = 0, start = 0; kx < iKernelSize; kx++, start++)
    		{ 
    			__m256 ker = _mm256_loadu_ps(pSimdKernel + 8 * kx);
    			int x = 0;
    #pragma unroll(2)
    			for (; x < iConvSize - 8; x += 8)
    			{ 
    				__m256 src = _mm256_loadu_ps(pSrcLine + start + x);
    				__m256 dst = _mm256_loadu_ps(pDstTemp + x);
    				dst = _mm256_fmadd_ps(ker, src, dst);
    				_mm256_storeu_ps(pDstTemp + x, dst);
    			}
    			for (;x < iConvSize; ++x)
    			{ 
    				pDstTemp[x] += pSrcLine[start + x] * pKernel[kx];
    			}
    		}
    	}

执行时间

TestConv1D(Conv1D_Ins_Cmb_ICCUnroll2_Test) cost total Time 74
    TestConv1D cost Time 0.00074

手动2倍展开代码实现，同时将最内层循环64字节对齐。

void Conv1D_Ins_Cmb_Unroll2(float* pSrcLine, int iLength, float* pKernel, int iKernelSize, float* pDstLine, float* pSimdKernel)
    	{ 
    
    		int iConvSize = iLength - iKernelSize + 1;
    			float* pDstTemp = pDstLine + iKernelSize / 2;
    
    			for (int kx = 0, start = 0; kx < iKernelSize; kx++, start++)
    			{ 
    				__m256 ker = _mm256_loadu_ps(pSimdKernel + 8 * kx);
    				int x = 0;
    #pragma code_align(64)
    				for (; x < iConvSize - 16; x += 16)
    				{ 
    					__m256 src1 = _mm256_loadu_ps(pSrcLine + start + x);
    					__m256 dst1 = _mm256_loadu_ps(pDstTemp + x);
    					dst1 = _mm256_fmadd_ps(ker, src1, dst1);
    					_mm256_storeu_ps(pDstTemp + x, dst1);
    					__m256 src2 = _mm256_loadu_ps(pSrcLine + start + x + 8);
    					__m256 dst2 = _mm256_loadu_ps(pDstTemp + x + 8);
    					dst2 = _mm256_fmadd_ps(ker, src2, dst2);
    					_mm256_storeu_ps(pDstTemp + x + 8, dst2);
    				}
    				for (; x < iConvSize; ++x)
    				{ 
    					pDstTemp[x] += pSrcLine[start + x] * pKernel[kx];
    				}
    	}

执行时间

TestConv1D(Conv1D_Ins_Cmb_Unroll2_Test) cost total Time 1364
    TestConv1D cost Time 0.000682

指令执行情况  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 5]

可以看到for语句指令总数量减少了差不多四倍。  
for语句对应汇编  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 6]

**小结**：编译器做2倍循环展开对执行速度几乎没有效果，手动2倍循环展开有效减少了for语句的执行次数，整体执行速度有所提升。但是最终执行速度依然是ICC向量化版本最快。Intrinsic手动展开2倍，性能瓶颈集中在FMA操作的寄存器。

[C_3D_FMA]: https://blog.csdn.net/yan31415/article/details/108152011
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/f9acf0fae4214f19973ac2a746ada2f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/2396f028280d465cb8245c66a57155f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/4af0c04627ab48bfa6a5afeca22e0781.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/5b809613bb864185802f67a3556a7cdb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/1729c72142e5463e88425e467787fdd6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/fba6ee8b71444459865dd84ab76dd04b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/9437699eeb094f88a93eeccc47cf4e53.png