C++性能优化系列——矩阵转置(六)Intrinsic转置实现与Core Bound优化

Dear 丶 2023-02-28 05:39 8阅读 0赞

上一篇博客: [C++性能优化系列——矩阵转置(五)Intrinsic函数详解][C_Intrinsic] 中介绍了转置功能要应用到的Intrinsic函数。本篇开始具体的代码实现。

## Intrinsic Base版 ##

矩阵尺寸相关宏定义，其中为了提高运行结果的稳定性，将重复次数提高到10240次。

//总行数
    #define NROW 1024
    //总列数
    #define NCOL 1024
    #define NREALCOL (NCOL + 32)
    #define NSLICE NROW*NCOL
    #define REPEAT 10240
    #define BLOCK 128

Intrinsic版本的实现核心逻辑：  
1.加载内存至寄存器，读内存跳跃执行  
2.实现通过不同的粒度，将128bit的元素拆分和组合。  
3.将数据写入内存，写内存连续执行  
其中，包含内存访问的优化：做内存填充，使写内存时，对应位置的缓存行映射到不同的缓存组中，避免缓存抖动问题。

变量命名解释：行号命名按照A - P，每次内循环共加载16行，加载元素顺序 0-15 。如A0\_15 代表当前寄存器保存的是A行0-15的元素。  
Base版实现

void SimdTransposeBlock16Pad(unsigned char* pSource, unsigned char* pTarget)
    	{ 
    		//SSE Instruct
    		//xmm ymm zmm 寄存器都只有16个，因此全部用ymm寄存器实现，理论上会发生corebound
    		
    
    		/* SimdTransposeBlock16Pad 10240 Time 750 SimdTransposeBlock16Pad each Time (ms) 0.0732422 */
    
    
    		clock_t begin = clock();
    		int iblock = 128;
    		int iwsize = NCOL / iblock;
    		int ihsize = NROW / iblock;
    		for (int i = 0; i < REPEAT; ++i)
    		{ 
    			for (int ibcol = 0; ibcol < iwsize; ++ibcol)
    			{ 
    				for (int ibrow = 0; ibrow < ihsize; ++ibrow)
    				{ 
    					for (int icol = 0; icol < iblock; icol += 16)
    					{ 
    //#pragma distribute_point
    						for (int irow = 0; irow < iblock; irow += 16)
    						{ 
    							__m128i A0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 0) * NREALCOL + ibcol*iblock + icol));
    							__m128i B0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 1) * NREALCOL + ibcol*iblock + icol));
    							__m128i C0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 2) * NREALCOL + ibcol*iblock + icol));
    							__m128i D0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 3) * NREALCOL + ibcol*iblock + icol));
    							__m128i E0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 4) * NREALCOL + ibcol*iblock + icol));
    							__m128i F0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 5) * NREALCOL + ibcol*iblock + icol));
    							__m128i G0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 6) * NREALCOL + ibcol*iblock + icol));
    							__m128i H0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 7) * NREALCOL + ibcol*iblock + icol));
    							__m128i I0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 8) * NREALCOL + ibcol*iblock + icol));
    							__m128i J0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 9) * NREALCOL + ibcol*iblock + icol));
    							__m128i K0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 10) * NREALCOL + ibcol*iblock + icol));
    							__m128i L0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 11) * NREALCOL + ibcol*iblock + icol));
    							__m128i M0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 12) * NREALCOL + ibcol*iblock + icol));
    							__m128i N0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 13) * NREALCOL + ibcol*iblock + icol));
    							__m128i O0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 14) * NREALCOL + ibcol*iblock + icol));
    							__m128i P0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow*iblock + irow + 15) * NREALCOL + ibcol*iblock + icol));
    
    							//unpack2
    							__m128i AB0_7 = _mm_unpacklo_epi8(A0_15, B0_15);
    							__m128i CD0_7 = _mm_unpacklo_epi8(C0_15, D0_15);
    							__m128i EF0_7 = _mm_unpacklo_epi8(E0_15, F0_15);
    							__m128i GH0_7 = _mm_unpacklo_epi8(G0_15, H0_15);
    							__m128i IJ0_7 = _mm_unpacklo_epi8(I0_15, J0_15);
    							__m128i KL0_7 = _mm_unpacklo_epi8(K0_15, L0_15);
    							__m128i MN0_7 = _mm_unpacklo_epi8(M0_15, N0_15);
    							__m128i OP0_7 = _mm_unpacklo_epi8(O0_15, P0_15);
    							__m128i AB8_15 = _mm_unpackhi_epi8(A0_15, B0_15);
    							__m128i CD8_15 = _mm_unpackhi_epi8(C0_15, D0_15);
    							__m128i EF8_15 = _mm_unpackhi_epi8(E0_15, F0_15);
    							__m128i GH8_15 = _mm_unpackhi_epi8(G0_15, H0_15);
    							__m128i IJ8_15 = _mm_unpackhi_epi8(I0_15, J0_15);
    							__m128i KL8_15 = _mm_unpackhi_epi8(K0_15, L0_15);
    							__m128i MN8_15 = _mm_unpackhi_epi8(M0_15, N0_15);
    							__m128i OP8_15 = _mm_unpackhi_epi8(O0_15, P0_15);
    							//unpack4
    							__m128i ABCD0_3 = _mm_unpacklo_epi16(AB0_7, CD0_7);
    							__m128i EFGH0_3 = _mm_unpacklo_epi16(EF0_7, GH0_7);
    							__m128i IJKL0_3 = _mm_unpacklo_epi16(IJ0_7, KL0_7);
    							__m128i MNOP0_3 = _mm_unpacklo_epi16(MN0_7, OP0_7);
    							__m128i ABCD4_7 = _mm_unpackhi_epi16(AB0_7, CD0_7);
    							__m128i EFGH4_7 = _mm_unpackhi_epi16(EF0_7, GH0_7);
    							__m128i IJKL4_7 = _mm_unpackhi_epi16(IJ0_7, KL0_7);
    							__m128i MNOP4_7 = _mm_unpackhi_epi16(MN0_7, OP0_7);
    							__m128i ABCD8_11 = _mm_unpacklo_epi16(AB8_15, CD8_15);
    							__m128i EFGH8_11 = _mm_unpacklo_epi16(EF8_15, GH8_15);
    							__m128i IJKL8_11 = _mm_unpacklo_epi16(IJ8_15, KL8_15);
    							__m128i MNOP8_11 = _mm_unpacklo_epi16(MN8_15, OP8_15);
    							__m128i ABCD12_15 = _mm_unpackhi_epi16(AB8_15, CD8_15);
    							__m128i EFGH12_15 = _mm_unpackhi_epi16(EF8_15, GH8_15);
    							__m128i IJKL12_15 = _mm_unpackhi_epi16(IJ8_15, KL8_15);
    							__m128i MNOP12_15 = _mm_unpackhi_epi16(MN8_15, OP8_15);
    							//unpack8
    							__m128i A_H0_1 = _mm_unpacklo_epi32(ABCD0_3, EFGH0_3);
    							__m128i I_P0_1 = _mm_unpacklo_epi32(IJKL0_3, MNOP0_3);
    							__m128i A_H2_3 = _mm_unpackhi_epi32(ABCD0_3, EFGH0_3);
    							__m128i I_P2_3 = _mm_unpackhi_epi32(IJKL0_3, MNOP0_3);
    							__m128i A_H4_5 = _mm_unpacklo_epi32(ABCD4_7, EFGH4_7);
    							__m128i I_P4_5 = _mm_unpacklo_epi32(IJKL4_7, MNOP4_7);
    							__m128i A_H6_7 = _mm_unpackhi_epi32(ABCD4_7, EFGH4_7);
    							__m128i I_P6_7 = _mm_unpackhi_epi32(IJKL4_7, MNOP4_7);
    							__m128i A_H8_9 = _mm_unpacklo_epi32(ABCD0_3, EFGH8_11);
    							__m128i I_P8_9 = _mm_unpacklo_epi32(IJKL8_11, MNOP8_11);
    							__m128i A_H10_11 = _mm_unpackhi_epi32(ABCD8_11, EFGH8_11);
    							__m128i I_P10_11 = _mm_unpackhi_epi32(IJKL8_11, MNOP8_11);
    							__m128i A_H12_13 = _mm_unpacklo_epi32(ABCD12_15, EFGH12_15);
    							__m128i I_P12_13 = _mm_unpacklo_epi32(IJKL12_15, MNOP12_15);
    							__m128i A_H14_15 = _mm_unpackhi_epi32(ABCD12_15, EFGH12_15);
    							__m128i I_P14_15 = _mm_unpackhi_epi32(IJKL12_15, MNOP12_15);
    							//unpack16 
    							__m128i AP0 = _mm_unpacklo_epi64(A_H0_1, I_P0_1);
    							__m128i AP1 = _mm_unpackhi_epi64(A_H0_1, I_P0_1);
    							__m128i AP2 = _mm_unpacklo_epi64(A_H2_3, I_P2_3);
    							__m128i AP3 = _mm_unpackhi_epi64(A_H2_3, I_P2_3);
    							__m128i AP4 = _mm_unpacklo_epi64(A_H4_5, I_P4_5);
    							__m128i AP5 = _mm_unpackhi_epi64(A_H4_5, I_P4_5);
    							__m128i AP6 = _mm_unpacklo_epi64(A_H6_7, I_P6_7);
    							__m128i AP7 = _mm_unpackhi_epi64(A_H6_7, I_P6_7);
    							__m128i AP8 = _mm_unpacklo_epi64(A_H8_9, I_P8_9);
    							__m128i AP9 = _mm_unpackhi_epi64(A_H8_9, I_P8_9);
    							__m128i AP10 = _mm_unpacklo_epi64(A_H10_11, I_P10_11);
    							__m128i AP11 = _mm_unpackhi_epi64(A_H10_11, I_P10_11);
    							__m128i AP12 = _mm_unpacklo_epi64(A_H12_13, I_P12_13);
    							__m128i AP13 = _mm_unpackhi_epi64(A_H12_13, I_P12_13);
    							__m128i AP14 = _mm_unpacklo_epi64(A_H14_15, I_P14_15);
    							__m128i AP15 = _mm_unpackhi_epi64(A_H14_15, I_P14_15);
    
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 0) * NROW + ibrow*iblock +irow), AP0);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 1) * NROW + ibrow*iblock +irow), AP1);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 2) * NROW + ibrow*iblock +irow), AP2);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 3) * NROW + ibrow*iblock +irow), AP3);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 4) * NROW + ibrow*iblock +irow), AP4);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 5) * NROW + ibrow*iblock +irow), AP5);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 6) * NROW + ibrow*iblock +irow), AP6);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 7) * NROW + ibrow*iblock +irow), AP7);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 8) * NROW + ibrow*iblock +irow), AP8);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 9) * NROW + ibrow*iblock +irow), AP9);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 10) * NROW + ibrow*iblock +irow), AP10);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 11) * NROW + ibrow*iblock +irow), AP11);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 12) * NROW + ibrow*iblock +irow), AP12);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 13) * NROW + ibrow*iblock +irow), AP13);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 14) * NROW + ibrow*iblock +irow), AP14);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol*iblock + icol + 15) * NROW + ibrow*iblock +irow), AP15);
    
    						}
    					}
    				}
    			}
    		}
    		clock_t end = clock();
    		std::cout << "SimdTransposeBlock16Pad 10240 Time " << (end - begin) << std::endl;
    		std::cout << "SimdTransposeBlock16Pad each Transpose (ms) " << ((float)(end - begin)) / (float)REPEAT << std::endl;
    	}

执行时间

SimdTransposeBlock16Pad 10240 Time 750
    SimdTransposeBlock16Pad each Transpose (ms) 0.0732422

对比[C++性能优化系列——矩阵转置(三)内存填充避免缓存抖动][C]中c++实现的矩阵转置执行速度0.367 ms，Intrinsic Base版本得到5倍的加速效果。

## VTune分析 ##

通过VTune抓包分析性能瓶颈。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center]

程序内存性能瓶颈在两个地方，L3 Cache与Port Utilization。  
具体执行情况：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 1]  
对比[C++性能优化系列——矩阵转置(三)内存填充避免缓存抖动][C]中执行结果， Intrinsic Base版本在循环次数增加10倍至10240次的情况下，执行指令次数为6.1亿，因此单次转置的指令数量仅仅是c++版本的十分之一（因为c++版本一次加载内存只加载一个byte，Intrinsic 版本一次加载内存加载16个bytes），所以 Intrinsic Base版本速度比c++快了5倍左右是可解释的。

Intrinsic Base版本存在内存与向量化的问题。提示信息：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 2]

可以看到L3 Latency与Port Utilization为主要瓶颈。  
VTune对相关名词的提供的解释如下：

**Core Bound**  
This metric represents how much Core non-memory issues were of a bottleneck. Shortage in hardware compute resources, or dependencies software’s instructions are both categorized under Core Bound.Hence it may indicate the machine ran out of an OOO resources, certain execution units are overloaded or dependencies in program’s data- or instruction- flow are limiting the performance (e.g. FP-chained long-latency arithmetic operations).  
核心执行问题取决于计算部件资源不足，程序逻辑存在依赖或者指令本身延迟高等因素。  
**Port Utilization**  
This metric represents a fraction of cycles during which an application was stalled due to Core non-divider-related issues. For example, heavy data-dependency between nearby instructions, or a sequence of instructions that overloads specific ports. Hint: Loop Vectorization - most compilers feature auto-Vectorization options today - reduces pressure on the execution ports as multiple elements are calculated with same uop.

对于**Port Utilization**问题，尝试用工具Advisor对程序做进一步分析。

## Advisor分析与代码调整 ##

通过Advisor分析程序运行时情况，发现当前的实现存在问题 Vector Register Spilling。软件对问题的描述如下：  
Possible register spilling was detected and all vector registers are in use. This may negatively impact performance, because the spilled variable must be loaded to and unloaded from main memory. Improve performance by decreasing vector register pressure.  
向量寄存器xmm使用压力过大，导致数据无法全部保存在寄存器中，溢出部分保存在内存里。  
查阅Intel提供手册，核心架构实现上，每个核心上向量寄存器 xmm ymm zmm的个数都是16。Intrinsic Base版本中，一次内层循环内对xmm寄存器的使用过多，大于16个。因此出现该问题。同时，联系上一部分VTune提供的信息，Port Utilization表示的问题也能够和spiling 问题相呼应。

### Advance1版本实现 ###

为了减小xmm寄存器的使用压力，减小最内层转置数据块的大小，调整后尺寸8\*16（Byte），调整的Advance版代码实现如下：

void SimdTransposeBlock8ColPad(unsigned char* pSource, unsigned char* pTarget)
    	{ 
    		//SSE Instruct
    		//xmm ymm zmm 寄存器都只有16个，因此全部用ymm寄存器实现，理论上会发生corebound
    		//
    		clock_t begin = clock();
    		int iblock = 128;
    		int iwsize = NCOL / iblock;
    		int ihsize = NROW / iblock;
    		__m128i MaskZero = _mm_set1_epi8(0);
    		/* SimdTransposeBlock8ColPad 1024 Time 828 SimdTransposeBlock8ColPad each Transpose (ms) 0.0808594 */
    		for (int i = 0; i < REPEAT; ++i)
    		{ 
    			for (int ibcol = 0; ibcol < iwsize; ++ibcol)
    			{ 
    				for (int ibrow = 0; ibrow < ihsize; ++ibrow)
    				{ 
    					for (int icol = 0; icol < iblock; icol += 16)
    					{ 
    						for (int irow = 0; irow < iblock; irow += 8)
    						{ 
    							__m128i A0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow * iblock + irow + 0) * NREALCOL + ibcol * iblock + icol));
    							__m128i B0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow * iblock + irow + 1) * NREALCOL + ibcol * iblock + icol));
    							__m128i C0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow * iblock + irow + 2) * NREALCOL + ibcol * iblock + icol));
    							__m128i D0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow * iblock + irow + 3) * NREALCOL + ibcol * iblock + icol));
    							__m128i E0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow * iblock + irow + 4) * NREALCOL + ibcol * iblock + icol));
    							__m128i F0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow * iblock + irow + 5) * NREALCOL + ibcol * iblock + icol));
    							__m128i G0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow * iblock + irow + 6) * NREALCOL + ibcol * iblock + icol));
    							__m128i H0_15 = _mm_loadu_si128((__m128i*)(pSource + (ibrow * iblock + irow + 7) * NREALCOL + ibcol * iblock + icol));
    
    							//unpack2
    							__m128i AB0_7 = _mm_unpacklo_epi8(A0_15, B0_15);
    							__m128i CD0_7 = _mm_unpacklo_epi8(C0_15, D0_15);
    							__m128i EF0_7 = _mm_unpacklo_epi8(E0_15, F0_15);
    							__m128i GH0_7 = _mm_unpacklo_epi8(G0_15, H0_15);
    							__m128i AB8_15 = _mm_unpackhi_epi8(A0_15, B0_15);
    							__m128i CD8_15 = _mm_unpackhi_epi8(C0_15, D0_15);
    							__m128i EF8_15 = _mm_unpackhi_epi8(E0_15, F0_15);
    							__m128i GH8_15 = _mm_unpackhi_epi8(G0_15, H0_15);
    
    							//unpack4
    							__m128i ABCD0_3 = _mm_unpacklo_epi16(AB0_7, CD0_7);
    							__m128i EFGH0_3 = _mm_unpacklo_epi16(EF0_7, GH0_7);
    							__m128i ABCD4_7 = _mm_unpackhi_epi16(AB0_7, CD0_7);
    							__m128i EFGH4_7 = _mm_unpackhi_epi16(EF0_7, GH0_7);
    							__m128i ABCD8_11 = _mm_unpacklo_epi16(AB8_15, CD8_15);
    							__m128i EFGH8_11 = _mm_unpacklo_epi16(EF8_15, GH8_15);
    							__m128i ABCD12_15 = _mm_unpackhi_epi16(AB8_15, CD8_15);
    							__m128i EFGH12_15 = _mm_unpackhi_epi16(EF8_15, GH8_15);
    
    							//unpack8
    							__m128i A_H0_1 = _mm_unpacklo_epi32(ABCD0_3, EFGH0_3);
    							__m128i A_H2_3 = _mm_unpackhi_epi32(ABCD0_3, EFGH0_3);
    							__m128i A_H4_5 = _mm_unpacklo_epi32(ABCD4_7, EFGH4_7);
    							__m128i A_H6_7 = _mm_unpackhi_epi32(ABCD4_7, EFGH4_7);
    							__m128i A_H8_9 = _mm_unpacklo_epi32(ABCD0_3, EFGH8_11);
    							__m128i A_H10_11 = _mm_unpackhi_epi32(ABCD8_11, EFGH8_11);
    							__m128i A_H12_13 = _mm_unpacklo_epi32(ABCD12_15, EFGH12_15);
    							__m128i A_H14_15 = _mm_unpackhi_epi32(ABCD12_15, EFGH12_15);
    
    							//store
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 0) * NROW + ibrow * iblock + irow), A_H0_1);
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 1) * NROW + ibrow * iblock + irow), _mm_srli_si128(A_H0_1, 8));
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 2) * NROW + ibrow * iblock + irow), A_H2_3);
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 3) * NROW + ibrow * iblock + irow), _mm_srli_si128(A_H2_3, 8));
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 4) * NROW + ibrow * iblock + irow), A_H4_5);
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 5) * NROW + ibrow * iblock + irow), _mm_srli_si128(A_H4_5, 8));
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 6) * NROW + ibrow * iblock + irow), A_H6_7);
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 7) * NROW + ibrow * iblock + irow), _mm_srli_si128(A_H6_7, 8));
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 8) * NROW + ibrow * iblock + irow), A_H8_9);
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 9) * NROW + ibrow * iblock + irow), _mm_srli_si128(A_H8_9, 8));
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 10) * NROW + ibrow * iblock + irow), A_H10_11);
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 11) * NROW + ibrow * iblock + irow), _mm_srli_si128(A_H10_11, 8));
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 12) * NROW + ibrow * iblock + irow), A_H12_13);
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 13) * NROW + ibrow * iblock + irow), _mm_srli_si128(A_H12_13, 8));
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 14) * NROW + ibrow * iblock + irow), A_H14_15);
    							_mm_storel_epi64((__m128i*)(pTarget + (ibcol * iblock + icol + 15) * NROW + ibrow * iblock + irow), _mm_srli_si128(A_H14_15, 8));
    
    
    							prefetch 加上prefetch性能反而更差了
    							//_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 0) * NCOL + ibcol * iblock + icol + 16), _MM_HINT_T0);
    							//_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 1) * NCOL + ibcol * iblock + icol + 16), _MM_HINT_T0);
    							//_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 2) * NCOL + ibcol * iblock + icol + 16), _MM_HINT_T0);
    							//_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 3) * NCOL + ibcol * iblock + icol + 16), _MM_HINT_T0);
    							//_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 4) * NCOL + ibcol * iblock + icol + 16), _MM_HINT_T0);
    							//_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 5) * NCOL + ibcol * iblock + icol + 16), _MM_HINT_T0);
    							//_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 6) * NCOL + ibcol * iblock + icol + 16), _MM_HINT_T0);
    							//_mm_prefetch((const char*)(pSource + (ibrow * iblock + irow + 7) * NCOL + ibcol * iblock + icol + 16), _MM_HINT_T0);
    						}
    					}
    				}
    			}
    		}
    		clock_t end = clock();
    		std::cout << "SimdTransposeBlock8ColPad 1024 Time " << (end - begin) << std::endl;
    		std::cout << "SimdTransposeBlock8ColPad each Transpose (ms) " << ((float)(end - begin)) / (float)REPEAT << std::endl;
    	}

执行时间

SimdTransposeBlock8ColPad 1024 Time 828
    SimdTransposeBlock8ColPad each Transpose (ms) 0.0808594

对每次循环迭代处理的数据块调整后，执行速度并没有提升，反而变慢了。  
通过Advisor抓取运行数据， Vector Register Spilling的问题确实不存在了，说明代码的调整针对这个问题是**有效的**，但是解决spiling问题并不等价于性能提升。那么导致的性能下降原因是什么呢？

### Advance1版本 VTune分析 ###

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

通过对比上一版本的总体执行情况，可以看淡Port Utilization指标是得到改善的。但是L3缓存的问题并没有得到改善。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 4]

由于每次处理块变小，总循环次数增加，总的指令数增加。同时CPI升高。因此总执行时间增加。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 5]

在这里尝试用我的理解解释这个现象。因为Advance版本最内层循环迭代的实现逻辑是将8 \* 16 数据转置成 16 \* 8，因此一次循环执行16次写内存操作，每次写8个字节的内容。因为写操作的效率比Base版本低，导致CPI升高，同时总的指令数量增加，因此总执行时间增加。

### Advance2版本实现 ###

针对该问题，尝试提高写内存的效率，每次转置内存块尺寸更改为 16 \* 8 。  
代码实现如下：

void SimdTransposeBlock8RowPad(unsigned char* pSource, unsigned char* pTarget)
    	{ 
    		//SSE Instruct
    		//xmm ymm zmm 寄存器都只有16个，因此全部用ymm寄存器实现，理论上会发生corebound
    		//
    		clock_t begin = clock();
    		int iblock = 128;
    		int iwsize = NCOL / iblock;
    		int ihsize = NROW / iblock;
    		__m128i MaskZero = _mm_set1_epi8(0);
    		for (int i = 0; i < REPEAT; ++i)
    		{ 
    			for (int ibcol = 0; ibcol < iwsize; ++ibcol)
    			{ 
    				for (int ibrow = 0; ibrow < ihsize; ++ibrow)
    				{ 
    					for (int icol = 0; icol < iblock; icol += 8)
    					{ 
    						for (int irow = 0; irow < iblock; irow += 16)
    						{ 
    							__m128i A0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 0) * NREALCOL + ibcol * iblock + icol));
    							__m128i B0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 1) * NREALCOL + ibcol * iblock + icol));
    							__m128i C0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 2) * NREALCOL + ibcol * iblock + icol));
    							__m128i D0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 3) * NREALCOL + ibcol * iblock + icol));
    							__m128i E0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 4) * NREALCOL + ibcol * iblock + icol));
    							__m128i F0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 5) * NREALCOL + ibcol * iblock + icol));
    							__m128i G0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 6) * NREALCOL + ibcol * iblock + icol));
    							__m128i H0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 7) * NREALCOL + ibcol * iblock + icol)); 
    							__m128i I0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 8) * NREALCOL + ibcol * iblock + icol));
    							__m128i J0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 9) * NREALCOL + ibcol * iblock + icol));
    							__m128i K0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 10) * NREALCOL + ibcol * iblock + icol));
    							__m128i L0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 11) * NREALCOL + ibcol * iblock + icol));
    							__m128i M0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 12) * NREALCOL + ibcol * iblock + icol));
    							__m128i N0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 13) * NREALCOL + ibcol * iblock + icol));
    							__m128i O0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 14) * NREALCOL + ibcol * iblock + icol));
    							__m128i P0_7 = _mm_loadl_epi64((__m128i*)(pSource + (ibrow * iblock + irow + 15) * NREALCOL + ibcol * iblock + icol));
    							
    
    							//unpack2
    							__m128i AB0_7 = _mm_unpacklo_epi8(A0_7, B0_7);
    							__m128i CD0_7 = _mm_unpacklo_epi8(C0_7, D0_7);
    							__m128i EF0_7 = _mm_unpacklo_epi8(E0_7, F0_7);
    							__m128i GH0_7 = _mm_unpacklo_epi8(G0_7, H0_7);
    							__m128i IJ0_7 = _mm_unpacklo_epi8(I0_7, J0_7);
    							__m128i KL0_7 = _mm_unpacklo_epi8(K0_7, L0_7);
    							__m128i MN0_7 = _mm_unpacklo_epi8(M0_7, N0_7);
    							__m128i OP0_7 = _mm_unpacklo_epi8(O0_7, P0_7);
    
    
    							//unpack4
    							__m128i ABCD0_3 = _mm_unpacklo_epi16(AB0_7, CD0_7);
    							__m128i EFGH0_3 = _mm_unpacklo_epi16(EF0_7, GH0_7);
    							__m128i IJKL0_3 = _mm_unpacklo_epi16(IJ0_7, KL0_7);
    							__m128i MNOP0_3 = _mm_unpacklo_epi16(MN0_7, OP0_7);
    							__m128i ABCD4_7 = _mm_unpackhi_epi16(AB0_7, CD0_7);
    							__m128i EFGH4_7 = _mm_unpackhi_epi16(EF0_7, GH0_7);
    							__m128i IJKL4_7 = _mm_unpackhi_epi16(IJ0_7, KL0_7);
    							__m128i MNOP4_7 = _mm_unpackhi_epi16(MN0_7, OP0_7);
    
    							//unpack8
    							__m128i A_H0_1 = _mm_unpacklo_epi32(ABCD0_3, EFGH0_3);
    							__m128i I_P0_1 = _mm_unpacklo_epi32(IJKL0_3, MNOP0_3);
    							__m128i A_H2_3 = _mm_unpackhi_epi32(ABCD0_3, EFGH0_3);
    							__m128i I_P2_3 = _mm_unpackhi_epi32(IJKL0_3, MNOP0_3);
    							__m128i A_H4_5 = _mm_unpacklo_epi32(ABCD4_7, EFGH4_7);
    							__m128i I_P4_5 = _mm_unpacklo_epi32(IJKL4_7, MNOP4_7);
    							__m128i A_H6_7 = _mm_unpackhi_epi32(ABCD4_7, EFGH4_7);
    							__m128i I_P6_7 = _mm_unpackhi_epi32(IJKL4_7, MNOP4_7);
    
    							//unpack16 
    							__m128i AP0 = _mm_unpacklo_epi64(A_H0_1, I_P0_1);
    							__m128i AP1 = _mm_unpackhi_epi64(A_H0_1, I_P0_1);
    							__m128i AP2 = _mm_unpacklo_epi64(A_H2_3, I_P2_3);
    							__m128i AP3 = _mm_unpackhi_epi64(A_H2_3, I_P2_3);
    							__m128i AP4 = _mm_unpacklo_epi64(A_H4_5, I_P4_5);
    							__m128i AP5 = _mm_unpackhi_epi64(A_H4_5, I_P4_5);
    							__m128i AP6 = _mm_unpacklo_epi64(A_H6_7, I_P6_7);
    							__m128i AP7 = _mm_unpackhi_epi64(A_H6_7, I_P6_7);
    
    							//store
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 0) * NROW + ibrow * iblock + irow), AP0);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 1) * NROW + ibrow * iblock + irow), AP1);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 2) * NROW + ibrow * iblock + irow), AP2);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 3) * NROW + ibrow * iblock + irow), AP3);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 4) * NROW + ibrow * iblock + irow), AP4);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 5) * NROW + ibrow * iblock + irow), AP5);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 6) * NROW + ibrow * iblock + irow), AP6);
    							_mm_storeu_si128((__m128i*)(pTarget + (ibcol * iblock + icol + 7) * NROW + ibrow * iblock + irow), AP7);
    							
    
    						}
    					}
    				}
    			}
    		}
    		clock_t end = clock();
    		std::cout << "SimdTransposeBlock8RowPad 1024 Time " << (end - begin) << std::endl;
    		std::cout << "SimdTransposeBlock8RowPad each Transpose (ms) " << ((float)(end - begin)) / (float)REPEAT << std::endl;
    	}

执行时间

SimdTransposeBlock8RowPad 1024 Time 712
    SimdTransposeBlock8RowPad each Transpose (ms) 0.0695312

可以看到通过调整转置块尺寸，执行速度得到提升。

### Advance2版本VTune分析 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 6]  
对比Advance1 和Advance2版本，后者在最内层循环中，使用的XMM寄存器是比前者多的。因此Port Utilization指标更高。  
同时，对比两个版本在内存访问和寄存器使用两方面优化策略的取舍产生的执行速度差异，可以看到寄存器方面的优化得到收益小于内存优化。

## 总结 ##

基于之前c++实现中用到的内存访问模式，在保证一定内存访问性能的前提下，本文通过Intrinsic函数实现矩阵转置功能。  
其中，为了优化向量寄存器xmm使用，解决spilling问题，减小了每次循环迭代处理数据块尺寸。从实际运行的情况来看spilling问题是得到了解决，但是总的性能收益不太理想。

[C_Intrinsic]: https://blog.csdn.net/yan31415/article/details/107618964
[C]: https://blog.csdn.net/yan31415/article/details/107816040
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center]: /images/20230209/16cba4e285524fd5b470b0c25a90f46b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230209/8c1835bff8964542ac3fa92bf17a1df5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20230209/2850e1be5841491880566d20d5837618.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20230209/c523e6c43ce64c93b396fcfb097a3042.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20230209/0a21acd5452e420691b8c9eb7b61dd16.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20230209/72f8653305144eb0be3f018e218055e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbjMxNDE1_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20230209/af51ccf46dcc4b02b49842161e5c5fc3.png