GCC 生成的 64 位代码比 32 位慢 3 倍

Question

我注意到我的代码在 64 位 Linux 上运行比在 32 位 Linux 或 64 位 Window 或 64 位 Mac 上慢得多。这是最小的测试用例。

#include <stdlib.h>

typedef unsigned char UINT8;

void
stretch(UINT8 * lineOut, UINT8 * lineIn, int xsize, float *kk)
{
    int xx, x;

    for (xx = 0; xx < xsize; xx++) {
        float ss = 0.0;
        for (x = 0; x < xsize; x++) {
            ss += lineIn[x] * kk[x];
        }
        lineOut[xx] = (UINT8) ss;
    }
}

int
main( int argc, char** argv )
{
    int i;
    int xsize = 2048;

    UINT8 *lineIn = calloc(xsize, sizeof(UINT8));
    UINT8 *lineOut = calloc(xsize, sizeof(UINT8));
    float *kk = calloc(xsize, sizeof(float));

    for (i = 0; i < 1024; i++) {
        stretch(lineOut, lineIn, xsize, kk);
    }

    return 0;
}

还有它的运行方式：

$ cc --version
cc (Ubuntu 4.8.2-19ubuntu1) 4.8.2
$ cc -O2 -Wall -m64 ./tt.c -o ./tt && time ./tt
user  14.166s
$ cc -O2 -Wall -m32 ./tt.c -o ./tt && time ./tt
user  5.018s

如您所见，32 位版本的运行速度几乎快了 3 倍（我在 32 位和 64 位 Ubuntu 上都进行了测试，结果相同）。更奇怪的是什么性能取决于 C 标准：

$ cc -O2 -Wall -std=c99 -m32 ./tt.c -o ./tt && time ./tt
user  15.825s
$ cc -O2 -Wall -std=gnu99 -m32 ./tt.c -o ./tt && time ./tt
user  5.090s

怎么可能？我该如何解决这个问题以加快 GCC 生成的 64 位版本。

更新 1

我比较了快速 32 位（默认和 gnu99）和慢速（c99）生成的汇编程序，发现如下：

.L5:
  movzbl    (%ebx,%eax), %edx   # MEM[base: lineIn_10(D), index: _72, offset: 0B], D.1543
  movl  %edx, (%esp)    # D.1543,
  fildl (%esp)  #
  fmuls (%esi,%eax,4)   # MEM[base: kk_18(D), index: _72, step: 4, offset: 0B]
  addl  $1, %eax    #, x
  cmpl  %ecx, %eax  # xsize, x
  faddp %st, %st(1) #,
  fstps 12(%esp)    #
  flds  12(%esp)    #
  jne   .L5 #,

在快速情况下没有fstps 和flds 命令。因此，GCC 在每一步都从内存中存储和加载值。我试过register float 类型，但这没有帮助。

更新 2

我在 gcc-4.9 上进行了测试，看起来它为 64 位生成了最佳代码。并且-ffast-math（由@jch 建议）修复了两个GCC 版本的-m32 -std=c99。我仍在寻找 gcc-4.8 上 64 位的解决方案，因为它是现在比 4.9 更常见的版本。

Answer 1

旧版本 GCC 生成的代码中存在部分依赖关系停滞。

movzbl (%rsi,%rax), %r8d
cvtsi2ss %r8d, %xmm0  ;; all upper bits in %xmm0 are false dependency

依赖可以被xorps打破。

#ifdef __SSE__
float __attribute__((always_inline)) i2f(int v) {
    float x;
    __asm__("xorps %0, %0; cvtsi2ss %1, %0" : "=x"(x) : "r"(v) );
    return x;
}
#else
float __attribute__((always_inline)) i2f(int v) { return (float) v; }
#endif

void stretch(UINT8* lineOut, UINT8* lineIn, int xsize, float *kk)
{
    int xx, x;

    for (xx = 0; xx < xsize; xx++) {
        float ss = 0.0;
        for (x = 0; x < xsize; x++) {
            ss += i2f(lineIn[x]) * kk[x];
        }
        lineOut[xx] = (UINT8) ss;
    }
}

结果

$ cc -O2 -Wall -m64 ./test.c -o ./test64 && time ./test64
./test64  4.07s user 0.00s system 99% cpu 4.070 total
$ cc -O2 -Wall -m32 ./test.c -o ./test32 && time ./test32
./test32  3.94s user 0.00s system 99% cpu 3.938 total

Answer 2

这是我尝试过的：我将 ss 声明为 volatile。这阻止了编译器对其进行优化。 32 位和 64 位版本的时间相似。

64 位稍慢，但这是正常的，因为 64 位代码较大且 uCode 缓存大小有限。所以一般来说 64bit 应该比 32 慢很多（

回到问题上来，我认为在 32 位模式下，编译器会对 ss 进行更积极的优化。

更新 1：

查看 64 位代码，它会生成一条 CVTTSS2SI 指令，并搭配一条 CVTSI2SS 指令用于浮点到整数的转换。这具有更高的延迟。 32 位代码只使用 FMULS 指令，直接在浮点数上操作。需要寻找一个编译器选项来阻止这些转换。

Answer 3

在 32 位模式下，编译器正在努力保持严格的 IEEE 754 浮点语义。您可以通过使用-ffast-math 进行编译来避免这种情况：

$ gcc -m32 -O2 -std=c99 test.c && time ./a.out 

real    0m13.869s
user    0m13.884s
sys     0m0.000s
$ gcc -m32 -O2 -std=c99 -ffast-math test.c && time ./a.out 

real    0m4.477s
user    0m4.480s
sys     0m0.000s

我无法在 64 位模式下重现您的结果，但我非常有信心 -ffast-math 会解决您的问题。更一般地说，除非您真的需要可重现的 IEEE 754 舍入行为，否则 -ffast-math 就是您想要的。

Answer 4

看起来像是限制的情况。三个数组不能重叠吧？