我只是在研究 C++ 和 Fortran 中的递归函数，我意识到 Fortran 中的一个简单递归函数几乎是与其等效的 C++ 函数一样快。现在，在进入这个之前，我知道这里有类似的问题，特别是:

1. Why does adding assembly comments cause such radical change in generated code?
2. Working of asm volatile (“” : : : “memory”)
3. Equivalent to asm volatile in gfortran

但是，我有一点更具体和困惑，因为 Fortran 编译器似乎正在做你可以用 gcc 中的 asm volatile 实现的事情。为了给您一些上下文，让我们考虑以下递归 Fibonacci number 实现:

Fortran 代码:

module test
implicit none
private
public fib

contains

! Fibonacci function
integer recursive function fib(n) result(r)
    integer, intent(in) :: n
    if (n < 2) then
        r = n
    else
        r = fib(n-1) + fib(n-2)
    end if
end function  ! end of Fibonacci function
end module

program fibonacci
use test, only: fib
implicit none
integer :: r,i 
integer :: n = 1e09
real(8) :: start, finish, cum_time

cum_time=0
do i= 1,n 
    call cpu_time(start)
    r = fib(20)
    call cpu_time(finish) 
    cum_time = cum_time + (finish - start)
    if (cum_time >0.5) exit
enddo  

print*,i,'runs, average elapsed time is', cum_time/i/1e-06, 'us' 
end program

编译:

gfortran -O3 -march=native

C++代码:

#include <iostream>
#include <chrono>
using namespace std;

// Fib function
int fib(const int n)
{
    int r;
    if (n < 2)
        r = n;
    else
        r = fib(n-1) + fib(n-2);
    return r;
} // end of fib

template<typename T, typename ... Args>
double timeit(T (*func)(Args...), Args...args)
{
    double counter = 1.0;
    double mean_time = 0.0;
    for (auto iter=0; iter<1e09; ++iter){
        std::chrono::time_point<std::chrono::system_clock> start, end;
        start = std::chrono::system_clock::now();

        func(args...);

        end = std::chrono::system_clock::now();
        std::chrono::duration<double> elapsed_seconds = end-start;

        mean_time += elapsed_seconds.count();
        counter++;

        if (mean_time > 0.5){
            mean_time /= counter;
            std::cout << static_cast<long int>(counter)
            << " runs, average elapsed time is "
            << mean_time/1.0e-06 << " \xC2\xB5s" << std::endl; 
            break;
        }
    }
    return mean_time;
}

int main(){
    timeit(fib,20);
    return 0;
}

编译:

g++ -O3 -march=native

时间:

Fortran: 24991 runs, average elapsed time is 20.087 us
C++    : 12355 runs, average elapsed time is 40.471 µs

所以 gfortran 的速度是 gcc 的两倍。查看汇编代码，我明白了

程序集(Fortran):

.L28:
    cmpl    $1, %r13d
    jle .L29
    leal    -8(%rbx), %eax
    movl    %ecx, 12(%rsp)
    movl    %eax, 48(%rsp)
    leaq    48(%rsp), %rdi
    leal    -9(%rbx), %eax
    movl    %eax, 16(%rsp)
    call    __bench_MOD_fib
    leaq    16(%rsp), %rdi
    movl    %eax, %r13d
    call    __bench_MOD_fib
    movl    12(%rsp), %ecx
    addl    %eax, %r13d

汇编(C++):

.L28:
    movl    72(%rsp), %edx
    cmpl    $1, %edx
    movl    %edx, %eax
    jle .L33
    subl    $3, %eax
    movl    $0, 52(%rsp)
    movl    %eax, %esi
    movl    %eax, 96(%rsp)
    movl    92(%rsp), %eax
    shrl    %eax
    movl    %eax, 128(%rsp)
    addl    %eax, %eax
    subl    %eax, %esi
    movl    %edx, %eax
    subl    $1, %eax
    movl    %esi, 124(%rsp)
    movl    %eax, 76(%rsp)

两个汇编代码都是由几乎相似的 block /标签一遍又一遍地重复组成的。如您所见，Fortran 程序集对 fib 函数进行了两次调用，而在 C++ 程序集中，gcc 可能展开了所有可能需要更多堆栈的递归调用 push/pop 和尾部跳跃。

现在如果我像这样在 C++ 代码中放置一个内联汇编注释

修改后的 C++ 代码:

// Fib function
int fib(const int n)
{
    int r;
    if (n < 2)
        r = n;
    else
        r = fib(n-1) + fib(n-2);
    asm("");
    return r;
} // end of fib

生成的汇编代码，修改为

程序集(C++ 修改版):

.L7:
    cmpl    $1, %edx
    jle .L17
    leal    -4(%rbx), %r13d
    leal    -5(%rbx), %edx
    cmpl    $1, %r13d
    jle .L19
    leal    -5(%rbx), %r14d
    cmpl    $1, %r14d
    jle .L55
    leal    -6(%rbx), %r13d
    movl    %r13d, %edi
    call    _Z3fibi
    leal    -7(%rbx), %edi
    movl    %eax, %r15d
    call    _Z3fibi
    movl    %r13d, %edi
    addl    %eax, %r15d

您现在可以看到对 fib 函数的两次调用。计时他们给了我

时间:

Fortran: 24991 runs, average elapsed time is 20.087 us
C++    : 25757 runs, average elapsed time is 19.412 µs

我知道没有输出的 asm 和 asm volatile 的效果是抑制积极的编译器优化，但在这种情况下，gcc 认为它太聪明了，但最终最终生成了效率较低的代码。

那么问题是:

• 为什么 gcc 看不到这种“优化”，而 gfortan 显然可以？
• 内联 assembly 线必须在返回语句之前。放在别处，它不会有任何影响。为什么？
• 此行为是否特定于编译器？例如，您可以使用 clang/MSVC 模仿相同的行为吗？
• 在 C 或 C++ 中是否有更安全的方法来加 express 归速度(不依赖于内联汇编或迭代式编码)？也许可变参数模板？

更新:

• 上面显示的结果都是用gcc 4.8.4。我也尝试用 gcc 4.9.2 和 gcc 5.2 编译它，我得到了相同的结果。
• 问题也可以重现(修复？)，如果不是将 asm 声明为 volatile，即 (volatile int n) 而不是 (const int n)，虽然这会导致我机器上的运行时间稍微慢一些。
• 作为Michael Karcher已经提到，我们可以改为传递 -fno-optimize-sibling-calls 标志来解决这个问题。由于此标志在 -O2 级别及更高级别被激活，因此即使使用 -O1 进行编译也可以解决此问题。
• 我用 -O3 -march=native 运行了同样的例子，clang 3.5.1 虽然情况不一样，clang 似乎也可以用 asm 生成更快的代码。

Clang 计时:

clang++ w/o asm    :  8846 runs, average elapsed time is 56.4555 µs
clang++ with asm   : 10427 runs, average elapsed time is 47.8991 µs 

最佳答案

请参阅此答案末尾的粗体字，了解如何获得 gcc 生成的快速程序。阅读四个问题的答案。

您的第一个问题假设 gfortran能够看到 gcc 的优化可能性没看到。事实上，情况正好相反。 gcc确定了它认为是优化可能性的东西，而 gfortran错过了。唉，gcc是错误的，它应用的优化结果是你的系统有 100% 的速度损失(与我的相比)。

要解决您的第二个问题:asm声明阻止了内部转换，使 gcc看到错误的优化可能性。没有 asm声明，您的代码已(有效)转换为:

int fib(const int n)
{
    if (n < 2)
        return n;
    else
        return fib(n-1) + fib(n-2);
}

包含递归调用的返回语句会触发使您的代码悲观的“同级调用优化”。包含 asm 语句可防止在其中移动返回指令。

目前，我手头只有 gcc，所以我无法尝试其他编译器的行为来通过证据回答你的第三个问题，但这似乎绝对依赖于编译器。您遇到了 gcc 的一个怪癖(或错误，无论您怎么调用它)，它在尝试优化它时生成了错误的代码。不同编译器的优化器非常不同，因此很可能其他一些编译器不会错误优化您的代码，如 gcc做。另一方面，用于优化的代码转换是一个经过深入研究的主题，大多数编译器都在实现类似的优化方法，因此另一个编译器可能会陷入与 gcc 相同的陷阱。 .

最后一个问题:这不是关于 C/C++ 与 Fortan 的问题，而是关于 gcc 的问题。这搞砸了这个示例程序(以及可能类似的生产程序)。所以没有办法在C++中使递归更快，但在 gcc 中有一种方法可以加快此示例的速度 ，通过禁用有问题的优化: -fno-optimize-sibling-calls ，这导致(在我的系统上，在一次测试运行中)比仅插入 asm 更快的代码声明。

关于c++ - gcc 的 asm volatile 是否等同于递归的 gfortran 默认设置？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32974625/