☰

内核中可能的调用和不可能的调用有什么区别？

tag-icon • tag-icon linux kernel
内核中可能的调用和不可能的调用有什么区别？

内核中可能的调用和不可能的调用之间是什么？在搜索内核源代码时，我发现了这些语句。

# define likely(x)      __builtin_expect(!!(x), 1)
# define unlikely(x)    __builtin_expect(!!(x), 0)

有人可以解释一下吗？

答案1

它们是 GCC 的编译器提示。它们在条件语句中用于告诉编译器是否可能采用分支。它可以帮助编译器以最适合最常见结果的方式编写代码。

它们的用法如下：

if (likely(some_condition)) {
  // the compiler will try and make the code layout optimal for the case
  // where some_condition is true, i.e. where this block is run
  most_likely_action();
} else {
  // this block is less frequently used
  corner_case();
}

应谨慎使用它（即基于实际的分支分析结果）。错误的提示会降低性能（显然）。

通过搜索可以轻松找到一些如何优化代码的示例GCC __builtin_expect。这篇博文gcc 优化：__builtin_expect例如详细说明了它的拆卸。

可以完成的优化类型是特定于处理器的。一般的想法是，如果代码不到处分支/跳转，处理器通常会更快地运行代码。它越线性，分支越可预测，它的运行速度就越快。 （例如，对于具有深管道的处理器尤其如此。）

因此，编译器将发出代码，以便最有可能的分支不会涉及跳转（例如，如果目标 CPU 更喜欢跳转）。

答案2

我们来反编译看看 GCC 4.8 做了什么

没有预料到

#include "stdio.h"
#include "time.h"

int main() {
    /* Use time to prevent it from being optimized away. */
    int i = !time(NULL);
    if (i)
        printf("%d\n", i);
    puts("a");
    return 0;
}

使用GCC 4.8.2 x86_64 Linux编译和反编译：

gcc -c -O3 -std=gnu11 main.c
objdump -dr main.o

输出：

0000000000000000 <main>:
   0:       48 83 ec 08             sub    $0x8,%rsp
   4:       31 ff                   xor    %edi,%edi
   6:       e8 00 00 00 00          callq  b <main+0xb>
                    7: R_X86_64_PC32        time-0x4
   b:       48 85 c0                test   %rax,%rax
   e:       75 14                   jne    24 <main+0x24>
  10:       ba 01 00 00 00          mov    $0x1,%edx
  15:       be 00 00 00 00          mov    $0x0,%esi
                    16: R_X86_64_32 .rodata.str1.1
  1a:       bf 01 00 00 00          mov    $0x1,%edi
  1f:       e8 00 00 00 00          callq  24 <main+0x24>
                    20: R_X86_64_PC32       __printf_chk-0x4
  24:       bf 00 00 00 00          mov    $0x0,%edi
                    25: R_X86_64_32 .rodata.str1.1+0x4
  29:       e8 00 00 00 00          callq  2e <main+0x2e>
                    2a: R_X86_64_PC32       puts-0x4
  2e:       31 c0                   xor    %eax,%eax
  30:       48 83 c4 08             add    $0x8,%rsp
  34:       c3                      retq

内存中的指令顺序没有改变：首先是printf，然后puts是retq返回。

带着期待

现在替换if (i)为：

if (__builtin_expect(i, 0))

我们得到：

0000000000000000 <main>:
   0:       48 83 ec 08             sub    $0x8,%rsp
   4:       31 ff                   xor    %edi,%edi
   6:       e8 00 00 00 00          callq  b <main+0xb>
                    7: R_X86_64_PC32        time-0x4
   b:       48 85 c0                test   %rax,%rax
   e:       74 11                   je     21 <main+0x21>
  10:       bf 00 00 00 00          mov    $0x0,%edi
                    11: R_X86_64_32 .rodata.str1.1+0x4
  15:       e8 00 00 00 00          callq  1a <main+0x1a>
                    16: R_X86_64_PC32       puts-0x4
  1a:       31 c0                   xor    %eax,%eax
  1c:       48 83 c4 08             add    $0x8,%rsp
  20:       c3                      retq
  21:       ba 01 00 00 00          mov    $0x1,%edx
  26:       be 00 00 00 00          mov    $0x0,%esi
                    27: R_X86_64_32 .rodata.str1.1
  2b:       bf 01 00 00 00          mov    $0x1,%edi
  30:       e8 00 00 00 00          callq  35 <main+0x35>
                    31: R_X86_64_PC32       __printf_chk-0x4
  35:       eb d9                   jmp    10 <main+0x10>

printf(compiled to ) 被移至函数__printf_chk的最末尾，然后puts返回以改进分支预测，如其他答案所述。

所以它基本上与：

int i = !time(NULL);
if (i)
    goto printf;
puts:
puts("a");
return 0;
printf:
printf("%d\n", i);
goto puts;

此优化不是用-O0.

但祝你好运，编写一个运行速度__builtin_expect比没有运行速度更快的示例，那时候的CPU真的很智能。我天真的尝试在这里。

C++20[[likely]]和[[unlikely]]

C++20 已经标准化了这些 C++ 内置函数：https://stackoverflow.com/questions/51797959/how-to-use-c20s-likely-unlikely-attribute-in-if-else-statement他们很可能（双关语！）做同样的事情。

相关内容