这种内联结果是否常见？

Question

由于大学工作，我必须研究一个简单的优化，即内联。

基本代码如下：

#include <stdio.h>
#include <sys/time.h>
#include <stdlib.h>

#define ITER 1000
#define N 3000000

int i, j;
float x[N], y[N], z[N];

void add(float x, float y, float *z){
    *z = x + y;
}

void initialVersion(){
    struct timeval inicio, final;
    double time;

    gettimeofday(&inicio, 0);
    for(j = 0; j < ITER; j++){
        for(i = 0; i < N; i++){
            add(x[i], y[i], &z[i]);
        }
    }

    gettimeofday(&final, 0);

    time = (final.tv_sec - inicio.tv_sec + (final.tv_usec - inicio.tv_usec)/1.e6);

    printf("Time: %f\n", time);

}

这是带有内联的代码：

#include <stdio.h>
#include <sys/time.h>
#include <stdlib.h>

#define ITER 1000
#define N 3000000

int i, j;
float x[N], y[N], z[N];

void inliningVersion(){
    struct timeval inicio, final;
    double time;

    gettimeofday(&inicio, 0);
    for(j = 0; j < ITER; j++){
        for(i = 0; i < N; i++){
            z[i] = x[i] + y[i];
        }
    }

    gettimeofday(&final, 0);

    time = (final.tv_sec - inicio.tv_sec + (final.tv_usec - inicio.tv_usec)/1.e6);

    printf("Time: %f\n", time);

}

在 gcc 中使用选项 -O0 进行编译，基本版本的结果为 14.27 秒，内联版本的结果为 4.45 秒。这很常见吗？我执行了程序 10 次，结果总是相似的。你怎么看？

然后，使用选项 -O1 进行编译，两个版本的结果相似，大约 1.5 秒，所以我假设 gcc 使用 O1 为我进行内联。

顺便说一句，我知道 gettimeofday 计算的是总时间，而不仅仅是程序本身使用的时间，但我需要专门使用该功能。

提前致谢！

Answer 1

让我们分析一下 GCC 7.2（O0）为两个版本的代码生成的汇编输出。

没有内联

首先，让我们检查一下计算机需要完成多少工作才能实现具有单独功能的任务：

void add(float x, float y, float *z){
    *z = x + y;
}

int main ()
{
    float x[100], y[100], z[100];
    for(int i = 0; i < 100; i++){
             add(x[i], y[i], &z[i]);
        }
}

对于上述代码，GCC 生成如下所示的程序集：

add(float, float, float*):
        pushq   %rbp
        movq    %rsp, %rbp
        movss   %xmm0, -4(%rbp)
        movss   %xmm1, -8(%rbp)
        movq    %rdi, -16(%rbp)
        movss   -4(%rbp), %xmm0
        addss   -8(%rbp), %xmm0
        movq    -16(%rbp), %rax
        movss   %xmm0, (%rax)
        nop
        popq    %rbp
        ret
main:
        pushq   %rbp
        movq    %rsp, %rbp
        subq    24, %rsp
        movl    [=11=], -4(%rbp)
.L4:
        cmpl    , -4(%rbp)
        jg      .L3
        leaq    -1216(%rbp), %rax
        movl    -4(%rbp), %edx
        movslq  %edx, %rdx
        salq    , %rdx
        addq    %rax, %rdx
        movl    -4(%rbp), %eax
        cltq
        movss   -816(%rbp,%rax,4), %xmm0
        movl    -4(%rbp), %eax
        cltq
        movl    -416(%rbp,%rax,4), %eax
        movq    %rdx, %rdi
        movaps  %xmm0, %xmm1
        movl    %eax, -1220(%rbp)
        movss   -1220(%rbp), %xmm0
        call    add(float, float, float*)
        addl    , -4(%rbp)
        jmp     .L4
.L3:
        movl    [=11=], %eax
        leave
        ret

代码的处理部分大约需要32条指令（L4和L3之间的指令以及add函数的指令）。

大部分指令用于进行函数调用。

了解函数调用工作原理的一种简化方法是：

参数被压入调用堆栈
return 地址被压入调用栈
函数被调用
复制帧指针
在堆栈上为本地人腾出空间
执行实际功能代码
恢复函数调用前的状态
return 转给来电者

以上步骤（第 6 步除外）需要额外的指令来完成所需的处理。这称为函数调用开销。

有内联

现在让我们检查一下如果函数是内联的，计算机需要做多少工作。

int main ()
{
    float x[100], y[100], z[100];
    for(int i = 0; i < 100; i++){
            z[i] = x[i] + y[i];
        }
}

对于上述代码，GCC 生成如下所示的汇编输出：

main:
        pushq   %rbp
        movq    %rsp, %rbp
        subq    96, %rsp
        movl    [=13=], -4(%rbp)
.L3:
        cmpl    , -4(%rbp)
        jg      .L2
        movl    -4(%rbp), %eax
        cltq
        movss   -416(%rbp,%rax,4), %xmm1
        movl    -4(%rbp), %eax
        cltq
        movss   -816(%rbp,%rax,4), %xmm0
        addss   %xmm1, %xmm0
        movl    -4(%rbp), %eax
        cltq
        movss   %xmm0, -1216(%rbp,%rax,4)
        addl    , -4(%rbp)
        jmp     .L3
.L2:
        movl    [=13=], %eax
        leave
        ret

处理代码（标签L3和L2之间的指令）大约有14条指令。在此汇编输出中，不存在负责进行函数调用的所有指令，从而节省了大量 CPU 个周期。

一般来说，当你的函数的运行时间是函数调用开销的几倍以上时，函数调用的开销是无关紧要的。在您的代码中，函数的运行时间非常小，因此函数调用开销变得很重要。

如果您使用 O1 标志，编译器确实会为您进行内联。您可以通过检查使用 O1 生成的程序集来找出答案，或者您可以直接查看 GCC 手册中的 list of optimizations 尝试使用 O1.

您可以使用 -S 标志生成程序集输出，或者您可以使用 GodBolt 在线生成（此 post 的程序集输出取自此处）。

这种内联结果是否常见？

Are this inlining results common?

c

optimization

inline

inlining

没有内联

有内联