C 使用内联汇编加速矩阵乘法_C_Gcc_Matrix Multiplication_Inline Assembly_Sse2

C 使用内联汇编加速矩阵乘法

c gcc

C 使用内联汇编加速矩阵乘法,c,gcc,matrix-multiplication,inline-assembly,sse2,C,Gcc,Matrix Multiplication,Inline Assembly,Sse2,我一直在尝试加速矩阵乘法，这是一个老问题，可以追溯到我的HPC Cholesky分解例程开发的早期阶段。C代码已经过时，程序集完全不正确。后面的帖子遵循这个思路提供内联程序集的正确实现提供更好的C代码在编写GCC内联程序集时，需要注意状态标志的潜在更改。这对我来说是一个教训矢量化是HPC的关键。包含有关“英特尔SSE2/3”的一些讨论，同时包含有关“英特尔AVX”FMA指令的一些信息当然，所有这些都只与计算内核有关。还有许多其他工作与如何为最终的高性能Cholesky分解例程包装所有内

我一直在尝试加速矩阵乘法，这是一个老问题，可以追溯到我的HPC Cholesky分解例程开发的早期阶段。C代码已经过时，程序集完全不正确。后面的帖子遵循这个思路

提供内联程序集的正确实现

提供更好的C代码

在编写GCC内联程序集时，需要注意状态标志的潜在更改。这对我来说是一个教训

矢量化是HPC的关键。包含有关“英特尔SSE2/3”的一些讨论，同时包含有关“英特尔AVX”FMA指令的一些信息

当然，所有这些都只与计算内核有关。还有许多其他工作与如何为最终的高性能Cholesky分解例程包装所有内容有关。我的例行程序的第一个版本的性能正在测试中

目前我正在升级内核例程以获得更高的性能。可能会有更多关于这个线程的帖子。特别感谢stack overflow社区，以及回答我的各种问题。在这个过程中，我学到了很多，感到非常高兴。[当然同时，我也学会了成为一名更好的SO成员。]
罗伯特·范德盖恩（Robert van de Geijn）有一本关于GEMM的不错的教程。我稍后会帮你查找链接。BLIS项目和关于它的论文也可能会有所帮助。这对我来说可能是一个无知的问题，但是你是否已经将C代码生成的程序集进行了不同程度的优化，以确定编译器从一开始是如何处理的？你可能已经知道了，但令人惊讶的是，人们常常不知道这一点——你是用
-O3
编译的，对吗？你走错了方向：你的C代码很难阅读，因为你把语句打包在一个只有很少空格的矩形矩阵中，好像它们会减慢执行时间。将程序集混入其中只会使实现更加混乱，将错误隐藏在更微妙的位置，并阻止编译器进一步优化未来具有更多寄存器、更宽向量的目标。。。使用各种优化设置对不同的编译器进行基准测试，查看高级库，当然还要研究您的算法以获得潜在的改进。@Alphabetagama:使用很少的空间，就好像它们会减慢执行时间一样。这是一种讽刺，想知道你的独特风格是从哪里来的。
#include <stdint.h> /* type define of "uintptr_t" */ #include <emmintrin.h> /* double precision computation support since SSE2 */ #include <R.h> /* use R's error handling error() */ void DGEBB_SSE2_x86 (int *NB, double *ALPHA, double *A, double *B, double *C) { /* check "nb", must be a multiple of 4 */ int TWO=2, FOUR=4, nb=*NB; if (nb%FOUR) error("error in DGEBB_SSE2_x86: nb is not a multiple of 4!\n"); /* check memory alignment of A, B, C, 16 Byte alignment is mandatory (as XMM registers are 128-bit in length) */ uintptr_t sixteen_bytes=0xF; if ((uintptr_t)A & sixteen_bytes) error("error in DGEBB_SSE2_x86: A is not 16 Bytes aligned in memory!"); if ((uintptr_t)B & sixteen_bytes) error("error in DGEBB_SSE2_x86: B is not 16 Bytes aligned in memory!"); if ((uintptr_t)C & sixteen_bytes) error("error in DGEBB_SSE2_x86: C is not 16 Bytes aligned in memory!"); /* define vector variables */ __m128d C1_vec_reg=_mm_setzero_pd(), C2_vec_reg=C1_vec_reg, C3_vec_reg=C1_vec_reg, C4_vec_reg=C1_vec_reg,A1_vec_reg, A2_vec_reg, B_vec_reg, U_vec_reg; /* define scalar variables */ int jj, kk, ii, nb2=nb+nb, nb_half=nb/TWO; double *B1_copy, *B1, *C1, *a, *b, *c, *c0; /* start triple loop nest */ C1=C;B1=B; /* initial column tile of C and B */ jj=nb_half; while (jj--) { c=C1;B1_copy=B1;C1+=nb2;B1+=nb2;b=B1_copy; for (ii=0; ii<nb; ii+=FOUR) { a=A+ii;b=B1_copy; kk=nb_half; while (kk--) { /* [kernel] amortize pointer arithmetic! */ A1_vec_reg=_mm_load_pd(a); /* [fetch] */ B_vec_reg=_mm_load1_pd(b); /* [fetch] */ U_vec_reg=_mm_mul_pd(A1_vec_reg,B_vec_reg);C1_vec_reg=_mm_add_pd(C1_vec_reg,U_vec_reg); /* [daxpy] */ A2_vec_reg=_mm_load_pd(a+TWO);a+=nb; /* [fetch] */ U_vec_reg=_mm_mul_pd(A2_vec_reg,B_vec_reg);C2_vec_reg=_mm_add_pd(C2_vec_reg,U_vec_reg); /* [daxpy] */ B_vec_reg=_mm_load1_pd(b+nb);b++; /* [fetch] */ U_vec_reg=_mm_mul_pd(A1_vec_reg,B_vec_reg);C3_vec_reg=_mm_add_pd(C3_vec_reg,U_vec_reg); /* [daxpy] */ A1_vec_reg=_mm_load_pd(a); /* [fetch] */ U_vec_reg=_mm_mul_pd(A2_vec_reg,B_vec_reg);C4_vec_reg=_mm_add_pd(C4_vec_reg,U_vec_reg); /* [daxpy]*/ B_vec_reg=_mm_load1_pd(b); /* [fetch] */ U_vec_reg=_mm_mul_pd(A1_vec_reg,B_vec_reg);C1_vec_reg=_mm_add_pd(C1_vec_reg,U_vec_reg); /* [daxpy] */ A2_vec_reg=_mm_load_pd(a+TWO);a+=nb; /* [fetch] */ U_vec_reg=_mm_mul_pd(A2_vec_reg,B_vec_reg);C2_vec_reg=_mm_add_pd(C2_vec_reg,U_vec_reg); /* [daxpy] */ B_vec_reg=_mm_load1_pd(b+nb);b++; /* [fetch] */ U_vec_reg=_mm_mul_pd(A1_vec_reg,B_vec_reg);C3_vec_reg=_mm_add_pd(C3_vec_reg,U_vec_reg); /* [daxpy] */ U_vec_reg=_mm_mul_pd(A2_vec_reg,B_vec_reg);C4_vec_reg=_mm_add_pd(C4_vec_reg,U_vec_reg); /* [daxpy] */ } /* [end of kk-loop] */ /* [write-back] amortize pointer arithmetic! */ A2_vec_reg=_mm_load1_pd(ALPHA); U_vec_reg=_mm_load_pd(c);c0=c+nb;C1_vec_reg=_mm_mul_pd(C1_vec_reg,A2_vec_reg); /* [fetch] */ A1_vec_reg=U_vec_reg;C1_vec_reg=_mm_add_pd(C1_vec_reg,A1_vec_reg);U_vec_reg=_mm_load_pd(c0); /* [fetch] */ C3_vec_reg=_mm_mul_pd(C3_vec_reg,A2_vec_reg);_mm_store_pd(c,C1_vec_reg);c+=TWO; /* [store] */ A1_vec_reg=U_vec_reg;C3_vec_reg=_mm_add_pd(C3_vec_reg,A1_vec_reg);U_vec_reg=_mm_load_pd(c); /* [fetch] */ C2_vec_reg=_mm_mul_pd(C2_vec_reg,A2_vec_reg);_mm_store_pd(c0,C3_vec_reg);c0+=TWO; /* [store] */ A1_vec_reg=U_vec_reg;C2_vec_reg=_mm_add_pd(C2_vec_reg,A1_vec_reg);U_vec_reg=_mm_load_pd(c0); /* [fetch] */ C4_vec_reg=_mm_mul_pd(C4_vec_reg,A2_vec_reg);_mm_store_pd(c,C2_vec_reg);c+=TWO; /* [store] */ C4_vec_reg=_mm_add_pd(C4_vec_reg,U_vec_reg);_mm_store_pd(c0,C4_vec_reg); /* [store] */ C1_vec_reg=_mm_setzero_pd();C3_vec_reg=C1_vec_reg;C2_vec_reg=C1_vec_reg;C4_vec_reg=C1_vec_reg; } /* [end of ii-loop] */ } /* [end of jj-loop] */ }

while (kk--) { asm("movapd %0, %%xmm3\n\t" /* C1_vec_reg -> xmm3 */ "movapd %1, %%xmm1\n\t" /* C2_vec_reg -> xmm1 */ "movapd %2, %%xmm2\n\t" /* C3_vec_reg -> xmm2 */ "movapd %3, %%xmm0\n\t" /* C4_vec_reg -> xmm0 */ "movl %4, %%eax\n\t" /* pointer a -> %eax */ "movl %5, %%edx\n\t" /* pointer b -> %edx */ "movl %6, %%ecx\n\t" /* block size nb -> %ecx */ "movapd (%%eax), %%xmm5\n\t" /* A1_vec_reg -> xmm5 */ "movsd (%%edx), %%xmm4\n\t" /* B_vec_reg -> xmm4 */ "unpcklpd %%xmm4, %%xmm4\n\t" "movapd %%xmm5, %%xmm6\n\t" /* xmm5 -> xmm6 */ "mulpd %%xmm4, %%xmm6\n\t" /* xmm6 *= xmm4 */ "addpd %%xmm6, %%xmm3\n\t" /* xmm3 += xmm6 */ "movapd 16(%%eax), %%xmm7\n\t" /* A2_vec_reg -> xmm7 */ "movapd %%xmm7, %%xmm6\n\t" /* xmm7 -> xmm6 */ "mulpd %%xmm4, %%xmm6\n\t" /* xmm6 *= xmm4 */ "addpd %%xmm6, %%xmm1\n\t" /* xmm1 += xmm6 */ "movsd (%%edx,%%ecx), %%xmm4\n\t" /* B_vec_reg -> xmm4 */ "addl $8, %%edx\n\t" /* b++ */ "movsd (%%edx), %%xmm4\n\t" /* B_vec_reg -> xmm4 */ "unpcklpd %%xmm4, %%xmm4\n\t" "movapd %%xmm5, %%xmm6\n\t" /* xmm5 -> xmm6 */ "mulpd %%xmm4, %%xmm6\n\t" /* xmm6 *= xmm4 */ "addpd %%xmm6, %%xmm2\n\t" /* xmm2 += xmm6 */ "addl %%ecx, %%eax\n\t" /* a+=nb */ "movapd (%%eax), %%xmm5\n\t" /* A1_vec_reg -> xmm5 */ "movapd %%xmm7, %%xmm6\n\t" /* xmm7 -> xmm6 */ "mulpd %%xmm4, %%xmm6\n\t" /* xmm6 *= xmm4 */ "addpd %%xmm6, %%xmm0\n\t" /* xmm0 += xmm6 */ "movsd (%%edx), %%xmm4\n\t" /* B_vec_reg -> xmm4 */ "unpcklpd %%xmm4, %%xmm4\n\t" "movapd %%xmm5, %%xmm6\n\t" /* xmm5 -> xmm6 */ "mulpd %%xmm4, %%xmm6\n\t" /* xmm6 *= xmm4 */ "addpd %%xmm6, %%xmm3\n\t" /* xmm3 += xmm6 */ "movapd 16(%%eax), %%xmm7\n\t" /* A2_vec_reg -> xmm7 */ "movapd %%xmm7, %%xmm6\n\t" /* xmm7 -> xmm6 */ "mulpd %%xmm4, %%xmm6\n\t" /* xmm6 *= xmm4 */ "addpd %%xmm6, %%xmm1\n\t" /* xmm1 += xmm6 */ "movsd (%%edx,%%ecx), %%xmm4\n\t" /* B_vec_reg -> xmm4 */ "addl $8, %%edx\n\t" /* b++ */ "movsd (%%edx), %%xmm4\n\t" /* B_vec_reg -> xmm4 */ "unpcklpd %%xmm4, %%xmm4\n\t" "movapd %%xmm5, %%xmm6\n\t" /* xmm5 -> xmm6 */ "mulpd %%xmm4, %%xmm6\n\t" /* xmm6 *= xmm4 */ "addpd %%xmm6, %%xmm2\n\t" /* xmm2 += xmm6 */ "movapd %%xmm7, %%xmm6\n\t" /* xmm7 -> xmm6 */ "mulpd %%xmm4, %%xmm6\n\t" /* xmm6 *= xmm4 */ "addpd %%xmm6, %%xmm0\n\t" /* xmm0 += xmm6 */ "addl %%ecx, %%eax" : "+x"(C1_vec_reg), "+x"(C2_vec_reg), "+x"(C3_vec_reg), "+x"(C4_vec_reg), "+m"(a), "+m"(b) : "x"(C1_vec_reg), "x"(C2_vec_reg), "x"(C3_vec_reg), "x"(C4_vec_reg), "4"(a), "5"(b), "rm"(nb)); }

Unrolling out loops to expose a micro "dger" kernel for register resue: (c11 c12) += (a1) * (b1 b2) (c21 c22) (a2) (c31 c32) (a3) (c41 c42) (a4) This can be implemented as 4 vectorized "daxpy": (c11) += (a1) * (b1) , (c31) += (a3) * (b1) , (c12) += (a1) * (b2) , (c32) += (a3) * (b2) . (c21) (a2) (b1) (c41) (a4) (b1) (c22) (a2) (b2) (c42) (a4) (b2) 4 micor C-vectors are held constantly in XMM registers named C1_vec_reg, C2_vec_reg, C3_vec_reg, C4_vec_reg. 2 micro A-vectors are loaded into XMM registers named A1_vec_reg, A2_vec_reg. 2 micro B-vectors can reuse a single XMM register named B_vec_reg. 1 additional XMM register, U_vec_reg, will store temporary values. The above scheduling exploits all 8 XMM registers on x84 architectures with SIMD unit, and each XMM is used twice after loaded.