Add+Mul 使用 Intrinsics 变得更慢——我哪里错了？
Add+Mul become slower with Intrinsics - where am I wrong?
有这个数组：
alignas(16) double c[voiceSize][blockSize];
这是我要优化的功能：
inline void Process(int voiceIndex, int blockSize) {
double *pC = c[voiceIndex];
double value = start + step * delta;
double deltaValue = rate * delta;
for (int sampleIndex = 0; sampleIndex < blockSize; sampleIndex++) {
pC[sampleIndex] = value + deltaValue * sampleIndex;
}
}
这是我的内在函数 (SSE2) 尝试：
inline void Process(int voiceIndex, int blockSize) {
double *pC = c[voiceIndex];
double value = start + step * delta;
double deltaValue = rate * delta;
__m128d value_add = _mm_set1_pd(value);
__m128d deltaValue_mul = _mm_set1_pd(deltaValue);
for (int sampleIndex = 0; sampleIndex < blockSize; sampleIndex += 2) {
__m128d result_mul = _mm_setr_pd(sampleIndex, sampleIndex + 1);
result_mul = _mm_mul_pd(result_mul, deltaValue_mul);
result_mul = _mm_add_pd(result_mul, value_add);
_mm_store_pd(pC + sampleIndex, result_mul);
}
}
这比 "scalar"（即使自动优化）原始代码慢，不幸的是:)
您认为瓶颈在哪里？我哪里错了？
我正在使用 MSVC、Release/x86、/02 优化标志 (Favor fast code)。
编辑：这样做（由@wim 建议），似乎性能比 C 版本更好：
inline void Process(int voiceIndex, int blockSize) {
double *pC = c[voiceIndex];
double value = start + step * delta;
double deltaValue = rate * delta;
__m128d value_add = _mm_set1_pd(value);
__m128d deltaValue_mul = _mm_set1_pd(deltaValue);
__m128d sampleIndex_acc = _mm_set_pd(-1.0, -2.0);
__m128d sampleIndex_add = _mm_set1_pd(2.0);
for (int sampleIndex = 0; sampleIndex < blockSize; sampleIndex += 2) {
sampleIndex_acc = _mm_add_pd(sampleIndex_acc, sampleIndex_add);
__m128d result_mul = _mm_mul_pd(sampleIndex_acc, deltaValue_mul);
result_mul = _mm_add_pd(result_mul, value_add);
_mm_store_pd(pC + sampleIndex, result_mul);
}
}
为什么？ _mm_setr_pd贵吗？
在我的系统上，g++ test.cpp -march=native -O2 -c -o test
普通版本的输出（循环体提取）：
30: c5 f9 57 c0 vxorpd %xmm0,%xmm0,%xmm0
34: c5 fb 2a c0 vcvtsi2sd %eax,%xmm0,%xmm0
38: c4 e2 f1 99 c2 vfmadd132sd %xmm2,%xmm1,%xmm0
3d: c5 fb 11 04 c2 vmovsd %xmm0,(%rdx,%rax,8)
42: 48 83 c0 01 add [=10=]x1,%rax
46: 48 39 c8 cmp %rcx,%rax
49: 75 e5 jne 30 <_Z11ProcessAutoii+0x30>
对于内在函数版本：
88: c5 f9 57 c0 vxorpd %xmm0,%xmm0,%xmm0
8c: 8d 50 01 lea 0x1(%rax),%edx
8f: c5 f1 57 c9 vxorpd %xmm1,%xmm1,%xmm1
93: c5 fb 2a c0 vcvtsi2sd %eax,%xmm0,%xmm0
97: c5 f3 2a ca vcvtsi2sd %edx,%xmm1,%xmm1
9b: c5 f9 14 c1 vunpcklpd %xmm1,%xmm0,%xmm0
9f: c4 e2 e9 98 c3 vfmadd132pd %xmm3,%xmm2,%xmm0
a4: c5 f8 29 04 c1 vmovaps %xmm0,(%rcx,%rax,8)
a9: 48 83 c0 02 add [=11=]x2,%rax
ad: 48 39 f0 cmp %rsi,%rax
b0: 75 d6 jne 88 <_Z11ProcessSSE2ii+0x38>
简而言之：编译器自动从 C 版本生成 AVX 代码。
在使用标志进行更多操作后进行编辑，以便在两种情况下都只有 SSE2：
g++ test.cpp -msse2 -O2 -c -o test
编译器仍然会做一些与您使用内部函数生成的不同的事情。编译器版本：
30: 66 0f ef c0 pxor %xmm0,%xmm0
34: f2 0f 2a c0 cvtsi2sd %eax,%xmm0
38: f2 0f 59 c2 mulsd %xmm2,%xmm0
3c: f2 0f 58 c1 addsd %xmm1,%xmm0
40: f2 0f 11 04 c2 movsd %xmm0,(%rdx,%rax,8)
45: 48 83 c0 01 add [=12=]x1,%rax
49: 48 39 c8 cmp %rcx,%rax
4c: 75 e2 jne 30 <_Z11ProcessAutoii+0x30>
内在版本：
88: 66 0f ef c0 pxor %xmm0,%xmm0
8c: 8d 50 01 lea 0x1(%rax),%edx
8f: 66 0f ef c9 pxor %xmm1,%xmm1
93: f2 0f 2a c0 cvtsi2sd %eax,%xmm0
97: f2 0f 2a ca cvtsi2sd %edx,%xmm1
9b: 66 0f 14 c1 unpcklpd %xmm1,%xmm0
9f: 66 0f 59 c3 mulpd %xmm3,%xmm0
a3: 66 0f 58 c2 addpd %xmm2,%xmm0
a7: 0f 29 04 c1 movaps %xmm0,(%rcx,%rax,8)
ab: 48 83 c0 02 add [=13=]x2,%rax
af: 48 39 f0 cmp %rsi,%rax
b2: 75 d4 jne 88 <_Z11ProcessSSE2ii+0x38>
编译器不会在此处展开循环。取决于很多事情，它可能会更好或更坏。您可能希望同时使用这两个版本。
Why? Is _mm_setr_pd expensive?
有点；至少需要洗牌。更重要的是，在这种情况下，计算每个标量操作数都非常昂贵，正如@spectras 的回答所示，gcc 至少无法将其自动矢量化为 paddd / cvtdq2pd。相反，它从标量整数重新计算每个操作数，分别进行 int->double 转换，然后将它们混合在一起。
This is the function I'm trying to optimize:
您只是用线性函数填充数组。您每次在循环内都在重新乘以。这避免了对除整数循环计数器以外的任何东西的循环依赖，但是你 运行 因在循环内做这么多工作而陷入吞吐量瓶颈。
即您正在为每个步骤分别计算 a[i] = c + i*scale。但是 你可以将其强度降低到 a[i+n] = a[i] + (n*scale)。因此，每个结果向量只有一条 addpd 指令。
这将引入一些舍入误差，这些误差会累积而不是从头开始重做计算，但是 double 可能对您正在做的事情来说太过分了。
它也是以引入对 FP 加法而不是整数的串行依赖为代价的。但是你已经在你的 "optimized" 版本中有一个循环携带的 FP 添加依赖链，它在循环内使用 sampleIndex_acc = _mm_add_pd(sampleIndex_acc, sampleIndex_add);，使用 FP += 2.0 而不是从整数重新转换。
因此您需要展开多个向量以隐藏 FP 延迟，并同时保持至少 3 或 4 个 FP 添加在飞行中。 （Haswell：3 个周期延迟，每个时钟吞吐量一个。Skylake：4 个周期延迟，每个时钟吞吐量 2 个。）另请参阅 了解更多关于使用多个累加器展开以解决循环携带依赖性的类似问题（一个点产品）。
void Process(int voiceIndex, int blockSize) {
double *pC = c[voiceIndex];
double val0 = start + step * delta;
double deltaValue = rate * delta;
__m128d vdelta2 = _mm_set1_pd(2 * deltaValue);
__m128d vdelta4 = _mm_add_pd(vdelta2, vdelta2);
__m128d v0 = _mm_setr_pd(val0, val0 + deltaValue);
__m128d v1 = _mm_add_pd(v0, vdelta2);
__m128d v2 = _mm_add_pd(v0, vdelta4);
__m128d v3 = _mm_add_pd(v1, vdelta4);
__m128d vdelta8 = _mm_mul_pd(vdelta2, _mm_set1_pd(4.0));
double *endp = pC + blocksize - 7; // stop if there's only room for 7 or fewer doubles
// or use -8 and have your cleanup handle lengths of 1..8
// since the inner loop always calculates results for next iteration
for (; pC < endp ; pC += 8) {
_mm_store_pd(pC, v0);
v0 = _mm_add_pd(v0, vdelta8);
_mm_store_pd(pC+2, v1);
v1 = _mm_add_pd(v1, vdelta8);
_mm_store_pd(pC+4, v2);
v2 = _mm_add_pd(v2, vdelta8);
_mm_store_pd(pC+6, v3);
v3 = _mm_add_pd(v3, vdelta8);
}
// if (blocksize % 8 != 0) ... store final vectors
}
vdelta4/vdelta8的加法或乘法的选择意义不大；在第一家商店出现之前，我试图避免太长的依赖链。由于还需要计算 v0 到 v3，因此创建一个 vdelta4 而不是仅仅制作一个 v2 = v1+vdelta2 链似乎是有意义的。也许用 4.0*delta 的乘法创建 vdelta4 并将其加倍得到 vdelta8 会更好。这可能与非常小的块大小相关，特别是如果您通过仅根据需要生成该数组的小块来缓存块代码，就在它被读取之前。
无论如何，这会使用 gcc 和 MSVC (on the Godbolt compiler explorer) 编译成一个非常高效的内部循环。
;; MSVC -O2
$LL4@Process: ; do {
movups XMMWORD PTR [rax], xmm5
movups XMMWORD PTR [rax+16], xmm0
movups XMMWORD PTR [rax+32], xmm1
movups XMMWORD PTR [rax+48], xmm2
add rax, 64 ; 00000040H
addpd xmm5, xmm3 ; v0 += vdelta8
addpd xmm0, xmm3 ; v1 += vdelta8
addpd xmm1, xmm3 ; v2 += vdelta8
addpd xmm2, xmm3 ; v3 += vdelta8
cmp rax, rcx
jb SHORT $LL4@Process ; }while(pC < endp)
这有 4 个独立的依赖链，通过 xmm0、1、2 和 5。因此有足够的指令级并行性来保持 4 个 addpd 指令在运行中。这对Haswell来说绰绰有余，不过是Skylake能承受的一半。
不过，对于每个时钟 1 个矢量的存储吞吐量，每个时钟超过 1 addpd 是没有用的。 理论上，这可以 运行 每个时钟周期大约 16 个字节，并使存储吞吐量饱和。 即每个时钟 1 个矢量/2 doubles。
具有更宽向量 (4 doubles) 的 AVX 在 Haswell 及更高版本上仍可以每个时钟 1 个向量，即每个时钟 32 个字节。 （假设输出数组在 L1d 缓存或什至 L2 中是热的。）
更好的是：根本不要将这些数据存储在内存中；即时重新生成。
在需要时即时生成它，如果使用它的代码只读取它几次，并且也被手动矢量化。
有这个数组：
alignas(16) double c[voiceSize][blockSize];
这是我要优化的功能：
inline void Process(int voiceIndex, int blockSize) {
double *pC = c[voiceIndex];
double value = start + step * delta;
double deltaValue = rate * delta;
for (int sampleIndex = 0; sampleIndex < blockSize; sampleIndex++) {
pC[sampleIndex] = value + deltaValue * sampleIndex;
}
}
这是我的内在函数 (SSE2) 尝试：
inline void Process(int voiceIndex, int blockSize) {
double *pC = c[voiceIndex];
double value = start + step * delta;
double deltaValue = rate * delta;
__m128d value_add = _mm_set1_pd(value);
__m128d deltaValue_mul = _mm_set1_pd(deltaValue);
for (int sampleIndex = 0; sampleIndex < blockSize; sampleIndex += 2) {
__m128d result_mul = _mm_setr_pd(sampleIndex, sampleIndex + 1);
result_mul = _mm_mul_pd(result_mul, deltaValue_mul);
result_mul = _mm_add_pd(result_mul, value_add);
_mm_store_pd(pC + sampleIndex, result_mul);
}
}
这比 "scalar"（即使自动优化）原始代码慢，不幸的是:)
您认为瓶颈在哪里？我哪里错了？
我正在使用 MSVC、Release/x86、/02 优化标志 (Favor fast code)。
编辑：这样做（由@wim 建议），似乎性能比 C 版本更好：
inline void Process(int voiceIndex, int blockSize) {
double *pC = c[voiceIndex];
double value = start + step * delta;
double deltaValue = rate * delta;
__m128d value_add = _mm_set1_pd(value);
__m128d deltaValue_mul = _mm_set1_pd(deltaValue);
__m128d sampleIndex_acc = _mm_set_pd(-1.0, -2.0);
__m128d sampleIndex_add = _mm_set1_pd(2.0);
for (int sampleIndex = 0; sampleIndex < blockSize; sampleIndex += 2) {
sampleIndex_acc = _mm_add_pd(sampleIndex_acc, sampleIndex_add);
__m128d result_mul = _mm_mul_pd(sampleIndex_acc, deltaValue_mul);
result_mul = _mm_add_pd(result_mul, value_add);
_mm_store_pd(pC + sampleIndex, result_mul);
}
}
为什么？ _mm_setr_pd贵吗？
在我的系统上，g++ test.cpp -march=native -O2 -c -o test
普通版本的输出（循环体提取）：
30: c5 f9 57 c0 vxorpd %xmm0,%xmm0,%xmm0
34: c5 fb 2a c0 vcvtsi2sd %eax,%xmm0,%xmm0
38: c4 e2 f1 99 c2 vfmadd132sd %xmm2,%xmm1,%xmm0
3d: c5 fb 11 04 c2 vmovsd %xmm0,(%rdx,%rax,8)
42: 48 83 c0 01 add [=10=]x1,%rax
46: 48 39 c8 cmp %rcx,%rax
49: 75 e5 jne 30 <_Z11ProcessAutoii+0x30>
对于内在函数版本：
88: c5 f9 57 c0 vxorpd %xmm0,%xmm0,%xmm0
8c: 8d 50 01 lea 0x1(%rax),%edx
8f: c5 f1 57 c9 vxorpd %xmm1,%xmm1,%xmm1
93: c5 fb 2a c0 vcvtsi2sd %eax,%xmm0,%xmm0
97: c5 f3 2a ca vcvtsi2sd %edx,%xmm1,%xmm1
9b: c5 f9 14 c1 vunpcklpd %xmm1,%xmm0,%xmm0
9f: c4 e2 e9 98 c3 vfmadd132pd %xmm3,%xmm2,%xmm0
a4: c5 f8 29 04 c1 vmovaps %xmm0,(%rcx,%rax,8)
a9: 48 83 c0 02 add [=11=]x2,%rax
ad: 48 39 f0 cmp %rsi,%rax
b0: 75 d6 jne 88 <_Z11ProcessSSE2ii+0x38>
简而言之：编译器自动从 C 版本生成 AVX 代码。
在使用标志进行更多操作后进行编辑，以便在两种情况下都只有 SSE2：
g++ test.cpp -msse2 -O2 -c -o test
编译器仍然会做一些与您使用内部函数生成的不同的事情。编译器版本：
30: 66 0f ef c0 pxor %xmm0,%xmm0
34: f2 0f 2a c0 cvtsi2sd %eax,%xmm0
38: f2 0f 59 c2 mulsd %xmm2,%xmm0
3c: f2 0f 58 c1 addsd %xmm1,%xmm0
40: f2 0f 11 04 c2 movsd %xmm0,(%rdx,%rax,8)
45: 48 83 c0 01 add [=12=]x1,%rax
49: 48 39 c8 cmp %rcx,%rax
4c: 75 e2 jne 30 <_Z11ProcessAutoii+0x30>
内在版本：
88: 66 0f ef c0 pxor %xmm0,%xmm0
8c: 8d 50 01 lea 0x1(%rax),%edx
8f: 66 0f ef c9 pxor %xmm1,%xmm1
93: f2 0f 2a c0 cvtsi2sd %eax,%xmm0
97: f2 0f 2a ca cvtsi2sd %edx,%xmm1
9b: 66 0f 14 c1 unpcklpd %xmm1,%xmm0
9f: 66 0f 59 c3 mulpd %xmm3,%xmm0
a3: 66 0f 58 c2 addpd %xmm2,%xmm0
a7: 0f 29 04 c1 movaps %xmm0,(%rcx,%rax,8)
ab: 48 83 c0 02 add [=13=]x2,%rax
af: 48 39 f0 cmp %rsi,%rax
b2: 75 d4 jne 88 <_Z11ProcessSSE2ii+0x38>
编译器不会在此处展开循环。取决于很多事情，它可能会更好或更坏。您可能希望同时使用这两个版本。
Why? Is _mm_setr_pd expensive?
有点；至少需要洗牌。更重要的是，在这种情况下，计算每个标量操作数都非常昂贵，正如@spectras 的回答所示，gcc 至少无法将其自动矢量化为 paddd / cvtdq2pd。相反，它从标量整数重新计算每个操作数，分别进行 int->double 转换，然后将它们混合在一起。
This is the function I'm trying to optimize:
您只是用线性函数填充数组。您每次在循环内都在重新乘以。这避免了对除整数循环计数器以外的任何东西的循环依赖，但是你 运行 因在循环内做这么多工作而陷入吞吐量瓶颈。
即您正在为每个步骤分别计算 a[i] = c + i*scale。但是 你可以将其强度降低到 a[i+n] = a[i] + (n*scale)。因此，每个结果向量只有一条 addpd 指令。
这将引入一些舍入误差，这些误差会累积而不是从头开始重做计算，但是 double 可能对您正在做的事情来说太过分了。
它也是以引入对 FP 加法而不是整数的串行依赖为代价的。但是你已经在你的 "optimized" 版本中有一个循环携带的 FP 添加依赖链，它在循环内使用 sampleIndex_acc = _mm_add_pd(sampleIndex_acc, sampleIndex_add);，使用 FP += 2.0 而不是从整数重新转换。
因此您需要展开多个向量以隐藏 FP 延迟，并同时保持至少 3 或 4 个 FP 添加在飞行中。 （Haswell：3 个周期延迟，每个时钟吞吐量一个。Skylake：4 个周期延迟，每个时钟吞吐量 2 个。）另请参阅
void Process(int voiceIndex, int blockSize) {
double *pC = c[voiceIndex];
double val0 = start + step * delta;
double deltaValue = rate * delta;
__m128d vdelta2 = _mm_set1_pd(2 * deltaValue);
__m128d vdelta4 = _mm_add_pd(vdelta2, vdelta2);
__m128d v0 = _mm_setr_pd(val0, val0 + deltaValue);
__m128d v1 = _mm_add_pd(v0, vdelta2);
__m128d v2 = _mm_add_pd(v0, vdelta4);
__m128d v3 = _mm_add_pd(v1, vdelta4);
__m128d vdelta8 = _mm_mul_pd(vdelta2, _mm_set1_pd(4.0));
double *endp = pC + blocksize - 7; // stop if there's only room for 7 or fewer doubles
// or use -8 and have your cleanup handle lengths of 1..8
// since the inner loop always calculates results for next iteration
for (; pC < endp ; pC += 8) {
_mm_store_pd(pC, v0);
v0 = _mm_add_pd(v0, vdelta8);
_mm_store_pd(pC+2, v1);
v1 = _mm_add_pd(v1, vdelta8);
_mm_store_pd(pC+4, v2);
v2 = _mm_add_pd(v2, vdelta8);
_mm_store_pd(pC+6, v3);
v3 = _mm_add_pd(v3, vdelta8);
}
// if (blocksize % 8 != 0) ... store final vectors
}
vdelta4/vdelta8的加法或乘法的选择意义不大；在第一家商店出现之前，我试图避免太长的依赖链。由于还需要计算 v0 到 v3，因此创建一个 vdelta4 而不是仅仅制作一个 v2 = v1+vdelta2 链似乎是有意义的。也许用 4.0*delta 的乘法创建 vdelta4 并将其加倍得到 vdelta8 会更好。这可能与非常小的块大小相关，特别是如果您通过仅根据需要生成该数组的小块来缓存块代码，就在它被读取之前。
无论如何，这会使用 gcc 和 MSVC (on the Godbolt compiler explorer) 编译成一个非常高效的内部循环。
;; MSVC -O2
$LL4@Process: ; do {
movups XMMWORD PTR [rax], xmm5
movups XMMWORD PTR [rax+16], xmm0
movups XMMWORD PTR [rax+32], xmm1
movups XMMWORD PTR [rax+48], xmm2
add rax, 64 ; 00000040H
addpd xmm5, xmm3 ; v0 += vdelta8
addpd xmm0, xmm3 ; v1 += vdelta8
addpd xmm1, xmm3 ; v2 += vdelta8
addpd xmm2, xmm3 ; v3 += vdelta8
cmp rax, rcx
jb SHORT $LL4@Process ; }while(pC < endp)
这有 4 个独立的依赖链，通过 xmm0、1、2 和 5。因此有足够的指令级并行性来保持 4 个 addpd 指令在运行中。这对Haswell来说绰绰有余，不过是Skylake能承受的一半。
不过，对于每个时钟 1 个矢量的存储吞吐量，每个时钟超过 1 addpd 是没有用的。 理论上，这可以 运行 每个时钟周期大约 16 个字节，并使存储吞吐量饱和。 即每个时钟 1 个矢量/2 doubles。
具有更宽向量 (4 doubles) 的 AVX 在 Haswell 及更高版本上仍可以每个时钟 1 个向量，即每个时钟 32 个字节。 （假设输出数组在 L1d 缓存或什至 L2 中是热的。）
更好的是：根本不要将这些数据存储在内存中；即时重新生成。
在需要时即时生成它，如果使用它的代码只读取它几次，并且也被手动矢量化。