拥有此数组：
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)。
EDIT：这样做(@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贵吗？
为什么？_mm_setr_pd贵吗？
一些；它至少需要一次洗牌。在这种情况下，更重要的是，计算每个标量操作数是昂贵的，正如@sspectras的回答所示，gcc至少无法将其自动向量化为paddd/cvtdq2pd。相反，它从标量整数重新计算每个操作数，分别进行int->double转换，然后将它们混洗在一起。
这是我试图优化的功能：
您只是用线性函数填充数组。循环中的每一次都在重新相乘。这避免了循环携带对除整数循环计数器之外的任何东西的依赖，但在循环内做这么多工作会遇到吞吐量瓶颈。
即，您为每一步单独计算CCD_ 10。但您可以将其强度降低为a[i+n] = a[i] + (n*scale)。因此，每个结果向量只有一个addpd指令
与从头开始重新进行计算相比，这将引入一些累积的舍入误差，但无论如何，double可能对您所做的工作来说是过度的。
它还以引入对FP加法而不是整数的串行依赖为代价。但是，在您的"优化"版本中，您已经有了一个循环携带的FP-add依赖链，它在循环中使用sampleIndex_acc = _mm_add_pd(sampleIndex_acc, sampleIndex_add);，使用FP+=2.0而不是从整数重新转换。
因此，您需要使用多个矢量展开以隐藏FP延迟，并同时保持至少3或4个FP添加。(Haswell：3个周期延迟，每个时钟一个吞吐量。Skylake：4个周期延迟、每个时钟2个吞吐量。)另请参阅为什么mulss在Haswell上只需要3个周期，与Agner'；s指令表？了解更多关于使用多个累加器展开循环携带依赖项(点积)的类似问题的信息。
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
}
构建CCD_ 15/CCD_；在第一家商店开业之前，我尽量避免依赖链过长。由于v0到v3也需要计算，因此创建一个vdelta4而不仅仅是创建一个链v2 = v1+vdelta2似乎是有意义的。也许用4.0*delta的乘积创建vdelta4，并将其加倍以获得vdelta8会更好。这可能与非常小的块大小有关，特别是如果您在读取代码之前仅根据需要生成该数组的小块来缓存代码块。
无论如何，这将使用gcc和MSVC(在Godbolt编译器资源管理器上)编译成一个非常高效的内部循环。
;; 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指令的运行。这对哈斯韦尔来说已经足够了，但只有斯凯莱克所能维持的一半。
尽管如此，对于每个时钟1个矢量的存储吞吐量，每个时钟超过1个addpd是没有用的理论上，这可以以每个时钟周期大约16字节的速度运行，并使存储吞吐量饱和即每时钟1个矢量/2个CCD_ 26秒。
具有更宽矢量(4个doubles)的AVX在Haswell及以后仍然可以以每个时钟1个矢量进行，即每个时钟32个字节。(假设输出数组在L1d缓存中是热的，甚至可能是L2。)
甚至更好：根本不要将这些数据存储在内存中；动态重新生成
如果使用它的代码只读取几次，并且还手动向量化，则在需要时动态生成它。
在我的系统上，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>
Intrnsics版本：
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>
编译器不会在此处展开循环。情况可能会更好，也可能更糟，这取决于许多因素。你可能想把两个版本都放在板凳上。