假设我有两个向量a和b，存储为向量。我想提出a += b或a +=b * k，其中k是一个数字。
我可以肯定做到以下几点，
while (size--) {
(*a++) += (*b++) * k;
}
但是，有哪些方法可以轻松利用SSD2等SIMD指令？
答案 0 :(得分：7)
例如，使用GCC（5.2.0）-O3编译代码（假设为float）会产生此主循环
L8:
movups (%rsi,%rax), %xmm1
addl $1, %r11d
mulps %xmm2, %xmm1
addps (%rdi,%rax), %xmm1
movaps %xmm1, (%rdi,%rax)
addq $16, %rax
cmpl %r11d, %r10d
ja .L8
Clang也会对循环进行矢量化，但也会展开四次。即使没有依赖链especially on Haswell，展开也可能对某些处理器有所帮助。实际上，您可以通过添加-funroll-loops来展示GCC。在这种情况下，海湾合作委员会将展开八次独立行动unlike in the case when there is a dependency chain。
您可能遇到的一个问题是，您的编译器可能需要添加一些代码来确定数组是否重叠，并且当它们重叠时使两个分支没有矢量化，而一个分支在不重叠时使用矢量化。 GCC和Clang都这样做。但是ICC没有对循环进行矢量化。
ICC 13.0.01 -O3
..B1.4: # Preds ..B1.2 ..B1.4
movss (%rsi), %xmm1 #3.21
incl %ecx #2.5
mulss %xmm0, %xmm1 #3.28
addss (%rdi), %xmm1 #3.11
movss %xmm1, (%rdi) #3.11
movss 4(%rsi), %xmm2 #3.21
addq $8, %rsi #3.21
mulss %xmm0, %xmm2 #3.28
addss 4(%rdi), %xmm2 #3.11
movss %xmm2, 4(%rdi) #3.11
addq $8, %rdi #3.11
cmpl %eax, %ecx #2.5
jb ..B1.4 # Prob 63% #2.5
要解决此问题，您需要使用__restrict关键字告诉编译器数组不重叠。
void foo(float * __restrict a, float * __restrict b, float k, int size) {
while (size--) {
(*a++) += (*b++) * k;
}
}
在这种情况下，ICC产生两个分支。一个用于当数组是16字节对齐时，一个用于何时不对齐。这是对齐的分支
..B1.16: # Preds ..B1.16 ..B1.15
movaps (%rsi), %xmm2 #3.21
addl $8, %r8d #2.5
movaps 16(%rsi), %xmm3 #3.21
addq $32, %rsi #1.6
mulps %xmm1, %xmm2 #3.28
mulps %xmm1, %xmm3 #3.28
addps (%rdi), %xmm2 #3.11
addps 16(%rdi), %xmm3 #3.11
movaps %xmm2, (%rdi) #3.11
movaps %xmm3, 16(%rdi) #3.11
addq $32, %rdi #1.6
cmpl %ecx, %r8d #2.5
jb ..B1.16 # Prob 82% #2.5
ICC在两种情况下展开两次。尽管GCC和Clang生成了一个没有__restrict的向量化和非向量化分支，但您仍然可以使用__restrict来删除代码的开销以确定要使用的分支。
你可以尝试的最后一件事是告诉编译器阵列是否对齐。这适用于GCC和Clang（3.6）
void foo(float * __restrict a, float * __restrict b, float k, int size) {
a = (float*)__builtin_assume_aligned (a, 32);
b = (float*)__builtin_assume_aligned (b, 32);
while (size--) {
(*a++) += (*b++) * k;
}
}
GCC在这种情况下生成
.L4:
movaps (%rsi,%r8), %xmm1
addl $1, %r10d
mulps %xmm2, %xmm1
addps (%rdi,%r8), %xmm1
movaps %xmm1, (%rdi,%r8)
addq $16, %r8
cmpl %r10d, %eax
ja .L4
最后，如果您的编译器支持OpenMP 4.0，您可以像这样使用OpenMP
void foo(float * __restrict a, float * __restrict b, float k, int size) {
#pragma omp simd aligned(a:32) aligned(b:32)
for(int i=0; i<size; i++) {
a[i] += k*b[i];
}
}
GCC在这种情况下生成与使用__builtin_assume_aligned时相同的代码。这适用于更新版本的ICC（我没有）。
我没有检查过MSVC。我希望它也会对这个循环进行矢量化。
有关restrict和编译器生成具有和不具有重叠的不同分支以及对齐和未对齐的更多详细信息，请参阅
sum-of-overlapping-arrays-auto-vectorization-and-restrict
这是另外一个需要考虑的建议。如果您知道循环的范围是SIMD宽度的倍数，则编译器不必使用清理代码。以下代码
// gcc -O3
// n = size/8
void foo(float * __restrict a, float * __restrict b, float k, int n) {
a = (float*)__builtin_assume_aligned (a, 32);
b = (float*)__builtin_assume_aligned (b, 32);
//#pragma omp simd aligned(a:32) aligned(b:32)
for(int i=0; i<n*8; i++) {
a[i] += k*b[i];
}
}
生成最简单的组件。
foo(float*, float*, float, int):
sall $2, %edx
testl %edx, %edx
jle .L1
subl $4, %edx
shufps $0, %xmm0, %xmm0
shrl $2, %edx
xorl %eax, %eax
xorl %ecx, %ecx
addl $1, %edx
.L4:
movaps (%rsi,%rax), %xmm1
addl $1, %ecx
mulps %xmm0, %xmm1
addps (%rdi,%rax), %xmm1
movaps %xmm1, (%rdi,%rax)
addq $16, %rax
cmpl %edx, %ecx
jb .L4
.L1:
rep ret
我使用了多个8和32字节对齐，因为只需使用编译器开关-mavx，编译器就会产生很好的AVX向量化。
foo(float*, float*, float, int):
sall $3, %edx
testl %edx, %edx
jle .L5
vshufps $0, %xmm0, %xmm0, %xmm0
subl $8, %edx
xorl %eax, %eax
shrl $3, %edx
xorl %ecx, %ecx
addl $1, %edx
vinsertf128 $1, %xmm0, %ymm0, %ymm0
.L4:
vmulps (%rsi,%rax), %ymm0, %ymm1
addl $1, %ecx
vaddps (%rdi,%rax), %ymm1, %ymm1
vmovaps %ymm1, (%rdi,%rax)
addq $32, %rax
cmpl %edx, %ecx
jb .L4
vzeroupper
.L5:
rep ret
我不确定序言如何变得更简单，但我看到的唯一改进就是删除其中一个迭代器并进行比较。即，addl $1, %ecx指令不是必需的。 Niether应该cmpl %edx, %ecx是必要的。我不知道如何让GCC解决这个问题。我遇到过像GCC一样的问题（Produce loops without cmp instruction in GCC）。
答案 1 :(得分：1)
函数SAXPY（单精度），DAXPY（双精度），CAXPY（复数单精度）和ZAXPY（复数双精度） ）准确计算你想要的表达式：
Y = a * X + Y
其中a是标量常量，X和Y是向量。
这些功能由BLAS库提供，并针对所有实际平台进行了优化：对于CPU，最佳BLAS实现是OpenBLAS，Intel MKL（仅针对Intel x86处理器和Xeon Phi协处理器进行了优化）， BLIS和Apple Accelerate（仅限OS X）;对于nVidia GPU，请查看cuBLAS（CUDA SDK的一部分），适用于任何GPU - ArrayFire。
这些库经过了很好的优化，可以提供比您可以快速解决的任何实现更好的性能。