我有一个非常简单的函数，可以使用行主矩阵（float**）转换向量（float*）：
int vector_by_matrix(float** m, float* v, float* out, int size)
{
int i, j;
float temp;
if (!m || !v || !out) return -1;
for (i = 0; i < size; i++)
{
temp = 0;
for (j = 0; j < size; j++)
{
temp += m[i][j] * v[j];
}
//out[i] = temp * v[i]; MISTAKE DURING COPYING - SHOULD'VE BEEN...
out[i] = temp;``
}
return 0;
}
代码最初使用 Visual Studio (2013) C++ 编译器编译为 C++ (x64)；如果没有优化，速度相当慢（该函数在运行期间被调用数百/数千次，并且系统的大小通常很大，c.size = 10000）。通过将优化设置为高 (O2) 并将浮点模式设置为 fast，性能增益是巨大的 (x20)。然而，我决定将该文件转换为 .c 源文件，并再次使用 VS 编译为 C - 无论如何，这都是简单的程序代码。无论有没有优化，性能都会再次提高（相对于优化的 C++ 编译）。事实上，优化设置对性能影响不大。
我不明白为什么 C 代码总是更快（优化/未优化）。我反汇编了 C(/C++) 编译器的输出，它看起来很可怕 - 我最初在 MASM 中编写了相同的函数，它大约是代码的五分之一，但在速度方面无法竞争。 VS 总是优化编译的 C 代码吗？从反汇编代码来看它确实很像，但我不能确定。我的 MASM 代码（如果有帮助）：
mul_vector_by_martix proc
mov r10, r9
sub rsp, 8
mov qword ptr[rsp], r11
LI:
MOV rbx, qword ptr[r10*8+rcx[0]-8]
XORPS xmm0, xmm0
mov r11, r9
LJ:
MOVSS xmm1, dword ptr[r11*4+rbx[0]-4]
MULSS xmm1, dword ptr[r11*4+rdx[0]-4]
ADDSS xmm0, xmm1
sub r11, 1
jnz LJ
MOVSS dword ptr[r10*4+r8[0]-4], xmm0
sub r10, 1
jnz LI
mov r11, qword ptr[rsp]
add rsp, 8
ret
mul_vector_by_martix endp
我不会提供反汇编代码 - 问题足够长;)
预先感谢您的帮助。
今天我抽出时间再次研究这个问题。我已经实现了打包指令（当前实现仅适用于系统大小为 4 的倍数的情况，否则您可能会崩溃）：
mul_opt_vector_by_martix proc
sub rsp, 8
mov qword ptr[rsp], r12
sub rsp, 8
mov qword ptr[rsp], r13
; copy rdx for arithmetic operations
mov r10, rdx
; init static global
mov r12, LSTEP
cmp VSIZE, r9
je LOOPS
; get sizeof(vector)
mov rax, 4
mul r9
mov r12, rax
; get the number of steps in inner loop
mov r11, 16
mov rax, r12
div r11
mov r11, rax
mov r12, r11
mov rax, 16
mul r12
mov r12, rax
sub r12, 16
mov VSIZE, r9
mov LSTEP, r12
LOOPS:
LI:
MOV rbx, qword ptr[r9*8+rcx[0]-8]
XORPS xmm0, xmm0
mov r13, r12
LJ:
MOVAPS xmm1, xmmword ptr[r13+rbx[0]]
MULPS xmm1, xmmword ptr[r13+r10[0]]
; add the packed single floating point numbers together
MOVHLPS xmm2, xmm1
ADDPS xmm2, xmm1
MOVAPS xmm1, xmm2
SHUFPS xmm2, xmm2, 1 ; imm8 = 00 00 00 01
ADDSS xmm2, xmm1
ADDSS xmm0, xmm2
sub r13, 16
cmp r13, 0
JGE LJ
MOVSS dword ptr[r9*4+r8[0]-4], xmm0
sub r9, 1
jnz LI
mov r13, qword ptr[rsp]
add rsp, 8
mov r12, qword ptr[rsp]
add rsp, 8
ret
mul_opt_vector_by_martix endp
它改进了大约 20-30%，但仍然无法与未优化的编译 C 代码竞争。内循环的反汇编代码：
sum += v[j] * m[i][j];
movsxd rax,r8d
add rdx,8
movups xmm0,xmmword ptr [rbx+rax*4]
movups xmm1,xmmword ptr [r10+rax*4]
lea eax,[r8+4]
movsxd rcx,eax
add r8d,8
mulps xmm1,xmm0
movups xmm0,xmmword ptr [rbx+rcx*4]
addps xmm2,xmm1
movups xmm1,xmmword ptr [r10+rcx*4]
mulps xmm1,xmm0
addps xmm3,xmm1
cmp r8d,r9d
jl vector_by_matrix+90h (07FEDD321440h)
addps xmm2,xmm3
movaps xmm1,xmm2
movhlps xmm1,xmm2
addps xmm1,xmm2
movaps xmm0,xmm1
shufps xmm0,xmm1,0F5h
addss xmm1,xmm0
在这一点上我不得不承认我看不到收益在哪里。我没有费心将代码重建为 C++ 来查看程序集是否不同，但我怀疑在未优化模式下，C++ 无法像 C 与 VS 编译器一样提供快速代码。也许 Frankie_C 的观点是中肯的。但令人担忧的是，如果编译器正在做一些不应该做的事情——但我看不出有什么问题；根据我的经验，任何半像样的手写程序集都会胜过未优化的 C，但在这个编译器中则不然。浮点运算需要严格控制精度问题，否则结果可能因一台机器而异，并且需要收敛的方法甚至可能由于不稳定性而在一台机器上失败，而在另一台机器上则不会失败。
更新2================================================= =======================
看起来这一切已经变得非常安静，但我想如果我有任何进一步的改进，我会让大家知道。好吧，我可以通过重新排列循环中的一些操作来匹配编译器，如上次更新所示。很明显，只需将打包的改组和添加移至内循环之外即可。同样，由于“向量化”的隐式大小，系统的大小必须是 4 的倍数（否则会崩溃）。
LOOPS:
LI:
MOV rbx, qword ptr[r9*8+rcx[0]-8]
XORPS xmm0, xmm0
mov r13, r12
LJ:
MOVAPS xmm1, xmmword ptr[r13+rbx[0]]
MULPS xmm1, xmmword ptr[r13+r10[0]]
; just add and accrue
ADDPS xmm0, xmm1
sub r13, 16
cmp r13, 0
jge LJ
;------------ moved this block to the outside --------------;
; add the packed single floating point numbers together
MOVHLPS xmm1, xmm0
ADDPS xmm1, xmm0
MOVAPS xmm0, xmm1
SHUFPS xmm1, xmm1, 1 ; imm8 = 00 00 00 01
ADDSS xmm0, xmm1
;--------------------end block---------------------------
MOVSS dword ptr[r9*4+r8[0]-4], xmm0
sub r9, 1
jnz LI
仍然无法击败编译器，但已经非常接近于它了。我想结论是，即使是未优化的 C，也很难击败 VS 编译器 - 这不是我对其他编译器（例如 gcc）（未优化的代码）的经验。 我可以通过使用带有更多 xmm 寄存器的 SIMD 指令展开循环来超越编译器。我可以根据要求提供此内容，但这可能是不言自明的。
基准测试比这更棘手一些。
例如，使用 clang，以下代码编译为完全相同与 main 中的代码相同，无论对
vector_by_matrix#include <algorithm>
#include <numeric>
int main() {
using namespace std;
auto constexpr N = 512;
float* m[N];
generate_n(m, N, []{return new float[N];});
float v[N], out[N];
float start = 0.0;
for(auto& col : m) iota(col, col+N, start += 0.1);
iota(begin(v), end(v), -1.0f);
//vector_by_matrix(m, v, out, N);
for_each(begin(m), end(m), [](float*p) { delete[] p; });
}
编译器认识到没有可观察到的行为发生改变，因此可以忽略该内容。
当然，只要你实际检查一下装配情况，应该没问题。 （虽然，如果
vector_by_matrix但是，如果您正在进行任何测量，请确保使用可靠的统计分析并测量您认为正在测量的内容。
参见组装：
int vector_by_matrix(float** m, float *const v, float *out, int size) {
int i, j;
float temp;
if (!m || !v || !out)
return -1;
for (i = 0; i < size; i++) {
temp = 0;
for (j = 0; j < size; j++) {
temp += m[i][j] * v[j];
}
out[i] = temp * v[i];
}
return 0;
}
#include <algorithm>
#include <numeric>
int main() {
using namespace std;
auto constexpr N = 512;
float* m[N];
generate_n(m, N, []{return new float[N];});
float v[N], out[N];
float start = 0.0;
for(auto& col : m) iota(col, col+N, start += 0.1);
iota(begin(v), end(v), -1.0f);
vector_by_matrix(m, v, out, N); // NO DIFFERENCE IF COMMENTED
for_each(begin(m), end(m), [](float*p) { delete[] p; });
}