c++ - MASM 使用 VS 击败未优化的 .cpp 但不是未优化的 .c

Question

我有一个非常简单的函数，它使用行主矩阵 (float**) 转换 vector (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) 并将浮点模式设置为快速，性能提升非常大 (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  

在这一点上，我不得不承认我看不出 yield 在哪里。我没有费心将代码重建为 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 指令展开循环来超越编译器。我可以根据要求提供这个，但它可能是不言自明的。

Answer 1

基准测试比这更棘手一些。

例如，使用 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 函数标记为文件静态，它甚至不会出现在列表中 :))。

但是，如果您要进行任何测量，请确保您使用的是统计上合理的分析，并且测量的是您认为正在测量的内容。

见汇编:

• 海湾合作委员会 5.3:https://goo.gl/wIvWsE
• gcc 5.3 调用评论:https://goo.gl/Z9hLsZ
• clang 3.7: https://goo.gl/xidrS6
• clang 3.7 调用评论:https://goo.gl/gUc4Ux

完整列表供引用

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; });
}