gcc - gcc 与 ICC 中最快的复杂除法

Question

考虑这个简单的代码:

#include <complex.h>
complex double f(complex double x, complex double y) {
  return x/y;
}

在 gcc 7.1 中使用 -O3 -march=core-avx2 -ffast-math 你会得到:

f:
        vmulsd  xmm4, xmm1, xmm3
        vmovapd xmm6, xmm0
        vmulsd  xmm5, xmm3, xmm3
        vmulsd  xmm6, xmm6, xmm3
        vfmadd231sd     xmm4, xmm0, xmm2
        vfmadd231sd     xmm5, xmm2, xmm2
        vfmsub132sd     xmm1, xmm6, xmm2
        vdivsd  xmm0, xmm4, xmm5
        vdivsd  xmm1, xmm1, xmm5
        ret

这是有道理的，而且很容易理解。然而，英特尔 C 编译器给出:

f:
        fld1                                                    #3.12
        vmovsd    QWORD PTR [-24+rsp], xmm2                     #3.12
        fld       QWORD PTR [-24+rsp]                           #3.12
        vmovsd    QWORD PTR [-24+rsp], xmm3                     #3.12
        fld       st(0)                                         #3.12
        fmul      st, st(1)                                     #3.12
        fld       QWORD PTR [-24+rsp]                           #3.12
        fld       st(0)                                         #3.12
        fmul      st, st(1)                                     #3.12
        vmovsd    QWORD PTR [-24+rsp], xmm0                     #3.12
        faddp     st(2), st                                     #3.12
        fxch      st(1)                                         #3.12
        fdivp     st(3), st                                     #3.12
        fld       QWORD PTR [-24+rsp]                           #3.12
        vmovsd    QWORD PTR [-24+rsp], xmm1                     #3.12
        fld       st(0)                                         #3.12
        fmul      st, st(3)                                     #3.12
        fxch      st(1)                                         #3.12
        fmul      st, st(2)                                     #3.12
        fld       QWORD PTR [-24+rsp]                           #3.12
        fld       st(0)                                         #3.12
        fmulp     st(4), st                                     #3.12
        fxch      st(3)                                         #3.12
        faddp     st(2), st                                     #3.12
        fxch      st(1)                                         #3.12
        fmul      st, st(4)                                     #3.12
        fstp      QWORD PTR [-16+rsp]                           #3.12
        fxch      st(2)                                         #3.12
        fmulp     st(1), st                                     #3.12
        vmovsd    xmm0, QWORD PTR [-16+rsp]                     #3.12
        fsubrp    st(1), st                                     #3.12
        fmulp     st(1), st                                     #3.12
        fstp      QWORD PTR [-16+rsp]                           #3.12
        vmovsd    xmm1, QWORD PTR [-16+rsp]                     #3.12
        ret 

Can anyone explain what it is doing and whether it is in fact faster than gcc's approach?

我无法自己对代码进行基准测试，因为我没有 ICC。 ICC 程序集是使用 https://godbolt.org/g/ZXZGy2 创建的.

Answer 1

根据问题和一些评论的要求，我运行了一个快速基准测试来比较 GCC 和 ICC 编译器在这段 C 代码上的性能。

硬件设置

用于运行测试的机器配备AMD A8-5550M APU四核处理器，频率为2.1 GHz。 L1i 的缓存大小为 16k，L1d 的缓存大小为 64k，L2 的缓存大小为 2048K。

实验设置

我没有 ICC 编译器的副本，因此问题中列出的汇编代码直接用于此基准测试。两个汇编输出是使用 NASM 汇编器编译的。为了使 ICC 版本兼容，需要进行一些小的语法更改，但当然不会以任何方式更改功能或影响性能。编写了一个小型 C 包装器来调用两个汇编函数并监视计时。

下面是与此简单基准测试中使用的代码类似的代码版本:

#include <stdio.h> 
#include <complex.h>
#include <time.h>

extern complex double gcc_f(complex double x, complex double y);
extern complex double icc_f(complex double x, complex double y);

int main() {
    struct timespec stop, start;
    complex double z1 = 1.0654575 + 3.0678788768 * I;
    complex double z2 = 2.225 - 8.0 * I;

    clock_gettime(CLOCK_MONOTONIC_RAW, &start);
    for(int i =0; i < 1000000000; ++i) {
        icc_f(z1, z2);
        // gcc_f(z1, z2);
    }
    clock_gettime(CLOCK_MONOTONIC_RAW, &stop);

    printf("Execution took %luns\n", ((stop.tv_sec - start.tv_sec) * 1000000000 + (stop.tv_nsec - start.tv_nsec)));
    return 0;
}

结果

这两个时间都是十亿次执行的平均值。

GCC 版本每次执行平均需要 8.8ns。

ICC 版本每次执行平均花费17.3ns。

因此，GCC 编译器的性能明显优于 ICC 编译器，至少在上述特定硬件设置下是如此。在这种情况下，GCC 似乎更巧妙地利用了 AVX 指令集。

<小时/>

顺便说一句，非常有趣的是，如果您使用 -Ofast 而不是 -O3 进行编译，ICC 版本看起来与 GCC 版本更相似:

f:
        vunpcklpd xmm4, xmm2, xmm3                              #2.54
        vunpcklpd xmm6, xmm0, xmm1                              #2.54
        vunpckhpd xmm5, xmm4, xmm4                              #3.12
        vmulpd    xmm10, xmm4, xmm4                             #3.12
        vmulpd    xmm8, xmm5, xmm6                              #3.12
        vmovddup  xmm9, xmm4                                    #3.12
        vshufpd   xmm7, xmm6, xmm6, 1                           #3.12
        vshufpd   xmm11, xmm10, xmm10, 1                        #3.12
        vfmaddsub213pd xmm9, xmm7, xmm8                         #3.12
        vaddpd    xmm13, xmm10, xmm11                           #3.12
        vshufpd   xmm12, xmm9, xmm9, 1                          #3.12
        vdivpd    xmm0, xmm12, xmm13                            #3.12
        vunpckhpd xmm1, xmm0, xmm0                              #3.12
        ret 

这个替代的 ICC 版本明显更快，每次执行平均 9.0ns，但仍略落后于 GCC 版本。然而，如此小的差异可能与实验设置有关。