具有此数组：
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);
}
}
不幸的是，这比“标量”（即使是自动优化的）原始代码要慢：）
您认为瓶颈在哪里？我在哪里错了？
我正在使用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贵吗？
答案 0 :(得分：3)
在我的系统上，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 $0x1,%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 $0x2,%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 $0x1,%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 $0x2,%rax
af: 48 39 f0 cmp %rsi,%rax
b2: 75 d4 jne 88 <_Z11ProcessSSE2ii+0x38>
编译器不会在此处展开循环。取决于很多事情，它可能是好是坏。您可能想同时使用两个版本。
答案 1 :(得分：3)
为什么？ _mm_setr_pd价格昂贵吗？
有点；它至少需要洗牌。在这种情况下，更重要的是，计算每个标量操作数是昂贵的，并且正如@spectras的答案所示，gcc至少无法将其自动矢量化为paddd / cvtdq2pd。相反，它从标量整数重新计算每个操作数，分别进行int-> double转换，然后将它们洗牌在一起。
这是我要优化的功能：
您只是用线性函数填充数组。您每次在循环中都要进行乘法运算。这样可以避免对整数循环计数器以外的任何东西进行循环携带的依赖，但是您会在循环内部进行大量工作时遇到吞吐量瓶颈。
即您正在为每个步骤分别计算a[i] = c + i*scale。但是，您可以将其强度降低到a[i+n] = a[i] + (n*scale)。因此，每个结果向量只有一条addpd指令。
这将引入一些舍入误差，这些误差会与从头开始重做与重新计算一样，但是double可能对您正在做的事情来说是过大的。
这还以引入对FP add而不是整数的串行依赖性为代价。但是您已经在“优化”版本中使用了循环携带的FP add依赖链，该链在循环内使用sampleIndex_acc = _mm_add_pd(sampleIndex_acc, sampleIndex_add);，使用FP + = 2.0而不是从整数重新转换。
因此，您需要展开多个向量来隐藏FP延迟，并一次至少运行3到4个FP添加。 （Haswell：3个周期延迟，每个时钟吞吐量一个。Skylake：4个周期延迟，每个时钟吞吐量2个。）另请参阅Why does mulss take only 3 cycles on Haswell, different from Agner's instruction tables?，以了解更多关于使用多个累加器展开的类似问题，这些问题带有循环承载的依赖关系（点产品）。
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链似乎很有意义。也许最好将vdelta4乘以4.0*delta，然后将其加倍以得到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 double s。
具有更宽矢量（4 double）的AVX在Haswell及更高版本上仍可以每个时钟1个矢量运行，即每个时钟32字节。 （假设输出阵列在L1d缓存甚至在L2中处于高温状态。）
如果使用它的代码只能读取几次，并且也需要手动矢量化，则可以在需要时即时生成它。