20

我想计算两个 IEEE 754 binary64 数字的总和,四舍五入。为此,我编写了下面的 C99 程序:

#include <stdio.h>
#include <fenv.h>
#pragma STDC FENV_ACCESS ON

int main(int c, char *v[]){
  fesetround(FE_UPWARD);
  printf("%a\n", 0x1.0p0 + 0x1.0p-80);
}

但是,如果我使用各种编译器编译和运行我的程序:

$ gcc -v
…
gcc 版本 4.2.1(Apple Inc. build 5664)
$ gcc -Wall -std=c99 add.c && ./a.out
add.c:3:警告:忽略#pragma STDC FENV_ACCESS
0x1p+0
$ 铿锵 -v
苹果 clang 版本 1.5 (tags/Apple/clang-60)
目标:x86_64-apple-darwin10
线程模型:posix
$ clang -Wall -std=c99 add.c && ./a.out
add.c:3:14:警告:不支持编译指示 STDC FENV_ACCESS ON,忽略
      pragma [-Wunknown-pragmas]
#pragma STDC FENV_ACCESS ON
             ^
生成 1 个警告。
0x1p+0

它不起作用!(我期待结果0x1.0000000000001p0)。

实际上,计算是在编译时以默认的舍入到最近模式完成的:

$ clang -Wall -std=c99 -S add.c && cat add.s
add.c:3:14:警告:不支持编译指示 STDC FENV_ACCESS ON,忽略
      pragma [-Wunknown-pragmas]
#pragma STDC FENV_ACCESS ON
             ^
生成 1 个警告。
…
LCPI1_0:
    .quad 4607182418800017408
…
    callq _fesetround
    移动 $1, %cl
    movsd LCPI1_0(%rip), %xmm0
    leaq L_.str(%rip), %rdx
    movq %rdx, %rdi
    移动 %cl, %al
    callq _printf
…
L_.str:
    .asciz "%a\n"

是的,我确实看到了每个编译器发出的警告。我知道在生产线的规模上打开或关闭适用的优化可能很棘手。如果可能的话,我仍然希望以文件的比例关闭它们,这足以解决我的问题。

我的问题是:我应该在 GCC 或 Clang 中使用什么命令行选项来编译包含旨在以 FPU 舍入模式而不是默认模式执行的代码的 C99 编译单元?

题外话

在研究这个问题时,我发现了这个GCC C99 合规性页面,其中包含以下条目,我将离开这里以防其他人觉得它很有趣。呸呸呸。

浮点数 | |
环境访问 | 不适用 | 库功能,无需编译器支持。
在 <fenv.h> | |
4

2 回答 2

4

我找不到任何可以满足您需求的命令行选项。但是,我确实找到了一种重写代码的方法,这样即使进行了最大优化(甚至是架构优化),GCC 和 Clang 也不会在编译时计算值。相反,这迫使他们输出将在运行时计算值的代码。

C:

#include <fenv.h>
#include <stdio.h>

#pragma STDC FENV_ACCESS ON

// add with rounding up
double __attribute__ ((noinline)) addrup (double x, double y) {
  int round = fegetround ();
  fesetround (FE_UPWARD);
  double r = x + y;
  fesetround (round);   // restore old rounding mode
  return r;
}

int main(int c, char *v[]){
  printf("%a\n", addrup (0x1.0p0, 0x1.0p-80));
}

这会导致 GCC 和 Clang 的这些输出,即使在使用最大和架构优化时也是如此:

gcc -S -x c -march=corei7 -O3上帝螺栓 GCC):

addrup:
        push    rbx
        sub     rsp, 16
        movsd   QWORD PTR [rsp+8], xmm0
        movsd   QWORD PTR [rsp], xmm1
        call    fegetround
        mov     edi, 2048
        mov     ebx, eax
        call    fesetround
        movsd   xmm1, QWORD PTR [rsp]
        mov     edi, ebx
        movsd   xmm0, QWORD PTR [rsp+8]
        addsd   xmm0, xmm1
        movsd   QWORD PTR [rsp], xmm0
        call    fesetround
        movsd   xmm0, QWORD PTR [rsp]
        add     rsp, 16
        pop     rbx
        ret
.LC2:
        .string "%a\n"
main:
        sub     rsp, 8
        movsd   xmm1, QWORD PTR .LC0[rip]
        movsd   xmm0, QWORD PTR .LC1[rip]
        call    addrup
        mov     edi, OFFSET FLAT:.LC2
        mov     eax, 1
        call    printf
        xor     eax, eax
        add     rsp, 8
        ret
.LC0:
        .long   0
        .long   988807168
.LC1:
        .long   0
        .long   1072693248

clang -S -x c -march=corei7 -O3上帝螺栓 GCC):

addrup:                                 # @addrup
        push    rbx
        sub     rsp, 16
        movsd   qword ptr [rsp], xmm1   # 8-byte Spill
        movsd   qword ptr [rsp + 8], xmm0 # 8-byte Spill
        call    fegetround
        mov     ebx, eax
        mov     edi, 2048
        call    fesetround
        movsd   xmm0, qword ptr [rsp + 8] # 8-byte Reload
        addsd   xmm0, qword ptr [rsp]   # 8-byte Folded Reload
        movsd   qword ptr [rsp + 8], xmm0 # 8-byte Spill
        mov     edi, ebx
        call    fesetround
        movsd   xmm0, qword ptr [rsp + 8] # 8-byte Reload
        add     rsp, 16
        pop     rbx
        ret

.LCPI1_0:
        .quad   4607182418800017408     # double 1
.LCPI1_1:
        .quad   4246894448610377728     # double 8.2718061255302767E-25
main:                                   # @main
        push    rax
        movsd   xmm0, qword ptr [rip + .LCPI1_0] # xmm0 = mem[0],zero
        movsd   xmm1, qword ptr [rip + .LCPI1_1] # xmm1 = mem[0],zero
        call    addrup
        mov     edi, .L.str
        mov     al, 1
        call    printf
        xor     eax, eax
        pop     rcx
        ret

.L.str:
        .asciz  "%a\n"

现在来看更有趣的部分:为什么会这样?

好吧,当他们(GCC 和/或 Clang)编译代码时,他们会尝试查找和替换可以在运行时计算的值。这称为恒定传播。如果您只是简单地编写了另一个函数,则不会发生持续传播,因为它不应该跨函数。

但是,如果他们看到一个理论上可以用代码代替函数调用的函数,他们可能会这样做。这称为函数内联。如果函数内联对一个函数起作用,我们说这个函数是(惊奇的)可内联的。

如果一个函数总是为给定的一组输入返回相同的结果,那么它被认为是的。我们还说它没有副作用(这意味着它不会改变环境)。

现在,如果一个函数是完全可内联的(意味着它不会对外部库进行任何调用,不包括 GCC 和 Clang - 等中包含的一些默认值libclibm并且是纯函数,那么它们将对函数应用常量传播。

换句话说,如果我们不希望它们通过函数调用传播常量,我们可以做以下两件事之一:

  • 使函数显得不纯:
    • 使用文件系统
    • 用来自某个地方的一些随机输入做一些废话魔术
    • 使用网络
    • 使用某种系统调用
    • 从 GCC 和/或 Clang 未知的外部库调用某些内容
  • 使函数不完全可内联
    • 从 GCC 和/或 Clang 未知的外部库调用某些内容
    • 利用__attribute__ ((noinline))

现在,最后一个是最简单的。正如您可能已经猜到的那样,__attribute__ ((noinline))将函数标记为不可内联。由于我们可以利用这一点,我们所要做的就是创建另一个函数来执行我们想要的任何计算,用 标记它__attribute__ ((noinline)),然后调用它。

当它被编译时,它们不会违反内联规则,并且通过扩展,不会违反常量传播规则,因此,该值将在运行时使用适当的舍入模式集进行计算。

于 2014-10-11T22:18:54.323 回答
1

clang 或 gcc-frounding-math告诉他们代码可能以非默认舍入模式运行。 它不是完全安全的(它假设相同的舍入模式一直处于活动状态),但总比没有好。在某些情况下,您可能仍需要使用volatile来避免CSE,或者可能来自其他答案的 noinline 包装技巧,如果您将其限制为单个操作,实际上可能会更好。


正如您所注意到的,GCC 不支持#pragma STDC FENV_ACCESS ON. 默认行为就像FENV_ACCESS OFF. 相反,您必须使用命令行选项(或者可能是每个函数的属性)来控制 FP 优化。

https://gcc.gnu.org/wiki/FloatingPointMath中所述,默认情况-frounding-math启用,因此 GCC 在编译时进行常量传播和其他优化时假定默认舍入模式。

但是随着gcc -O3 -frounding-math,不断传播被阻止。即使你打电话fesetround;实际发生的是,如果舍入模式在 main 被调用之前已经设置为其他值,那么 GCC 会生成安全的 asm。

但不幸的是,正如 wiki 所指出的,GCC 仍然假设相同的舍入模式在任何地方都有效(GCC bug #34678)。这意味着它将调用之前/之后对相同的输入进行 CSE 两次计算fesetround,因为它不被fesetround视为特殊。

#include <fenv.h>
#pragma STDC FENV_ACCESS ON

void foo(double *restrict out){
    out[0] = 0x1.0p0 + 0x1.0p-80;
    fesetround(FE_UPWARD);
    out[1] = 0x1.0p0 + 0x1.0p-80;
}

使用 gcc10.2编译如下(Godbolt)(与 clang10.1 基本相同)。还包括 your main,它确实可以制作您想要的 asm。

foo:
        push    rbx
        mov     rbx, rdi
        sub     rsp, 16
        movsd   xmm0, QWORD PTR .LC1[rip]
        addsd   xmm0, QWORD PTR .LC0[rip]     # runtime add
        movsd   QWORD PTR [rdi], xmm0         # store out[0]
        mov     edi, 2048
        movsd   QWORD PTR [rsp+8], xmm0       # save a local temporary for later
        call    fesetround
        movsd   xmm0, QWORD PTR [rsp+8]
        movsd   QWORD PTR [rbx+8], xmm0       # store the same value, not recalc
        add     rsp, 16
        pop     rbx
        ret

这是@Marc Glisse 在另一个答案下的评论中警告过的相同问题,以防您的 noinline 函数在更改舍入模式之前和之后进行相同的数学运算。

(而且,GCC 选择在第一次调用之前fesetround不做数学运算部分是幸运的,所以它只需要溢出结果而不是两个输入。x86-64 System V 没有任何保留调用的 XMM regs .)

于 2020-10-04T06:57:48.803 回答