devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

likely(x)与unlikely(x)函数，即__builtin_expect的使用_#define unlikely(x) __builtin_expect(!!(x), 0)

作者：笔触狂放9 | 2024-03-29 04:42:15

赞

踩

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

目录

1.引言

2. 函数声明

2.1. 功能描述

2.2. 参数详解

　　① exp

　　 ② c

2.3. 返回值

2.4. 使用方法

 3. RATIONALE(原理)

4. likely()和unlikely()

1.引言

在很多源码如Linux内核、Glib等,我们都能看到likely()和unlikely()这两个宏,通常这两个宏定义是下面这样的形式。

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

可以看出这2个宏都是使用函数 __builtin_expect()实现的, __builtin_expect()函数是GCC的一个内建函数(build-in function).

 

2. 函数声明

函数__builtin_expect()是GCC v2.96版本引入的, 其声明如下:
long __builtin_expect(long exp, long c);

2.1. 功能描述

由于大部分程序员在分支预测方面做得很糟糕，所以GCC 提供了这个内建函数来帮助程序员处理分支预测.

你期望 exp 表达式的值等于常量 c, 看 c 的值, 如果 c 的值为0(即期望的函数返回值), 那么 执行 if 分支的的可能性小, 否则执行 else 分支的可能性小(函数的返回值等于第一个参数 exp).

GCC在编译过程中，会将可能性更大的代码紧跟着前面的代码，从而减少指令跳转带来的性能上的下降, 达到优化程序的目的.

通常，你也许会更喜欢使用 gcc 的一个参数 '-fprofile-arcs' 来收集程序运行的关于执行流程和分支走向的实际反馈信息,但是对于很多程序来说,数据是很难收集的。

2.2. 参数详解

　　① exp

　　　　exp 为一个整型表达式, 例如: (ptr != NULL)

　　 ② c

　　　　 c 必须是一个编译期常量, 不能使用变量

2.3. 返回值

　　返回值等于 第一个参数 exp

2.4. 使用方法

与关键字if一起使用.首先要明确一点就是 if (value) 等价于 if (__builtin_expert(value, x)), 与x的值无关.

例子如下:

例子1 : 期望 x == 0, 所以执行func()的可能性小

  1. if (__builtin_expect(x, 0))
  2. {
  3.     func();
  4. }
  5. else
  6. {
  7. 　　//do someting
  8. }

例子2 : 期望 ptr !=NULL这个条件成立(1), 所以执行func()的可能性小

  1. if (__builtin_expect(ptr != NULL, 1))
  2. {　　
  3. 　　//do something
  4. }
  5. else
  6. {
  7. 　　func();
  8. } 

例子3 : 引言中的likely()和unlikely()宏

　　首先,看第一个参数!!(x), 他的作用是把(x)转变成"布尔值", 无论(x)的值是多少 !(x)得到的是true或false, !!(x)就得到了原值的"布尔值"

　　使用 likely() ，执行 if 后面的语句 的机会更大，使用 unlikely()，执行 else 后面的语句的机会更大。

  1. #define likely(x)    __builtin_expect(!!(x), 1)
  2. #define unlikely(x)  __builtin_expect(!!(x), 0)
  3.  
  4. int main(char *argv[], int argc)
  5. {
  6.    int a;
  7.  
  8.    /* Get the value from somewhere GCC can't optimize */
  9.    a = atoi (argv[1]);
  10.  
  11.    if (unlikely (a == 2))
  12. 　 {
  13.       a++;
  14.    }
  15.    else
  16. 　 {
  17. 　　  a--;
  18. 　 }
  19.    printf ("%d\n", a);
  20.  
  21.    return 0;
  22. }

 3. RATIONALE(原理)

if else 句型编译后, 一个分支的汇编代码紧随前面的代码,而另一个分支的汇编代码需要使用JMP指令才能访问到.

很明显通过JMP访问需要更多的时间, 在复杂的程序中,有很多的if else句型,又或者是一个有if else句型的库函数,每秒钟被调用几万次,

通常程序员在分支预测方面做得很糟糕, 编译器又不能精准的预测每一个分支,这时JMP产生的时间浪费就会很大,

函数__builtin_expert()就是用来解决这个问题的.

具体从汇编角度来分析其原理的例子,大家可以参照http://kernelnewbies.org/FAQ/LikelyUnlikely,

其对应的中文翻译版见http://velep.com/archives/795.html

本文讲的likely()和unlikely()两个宏，在linux内核代码和一些应用中可常见到它们的身影。实质上，这两个宏是关于GCC编译器内置宏__builtin_expect的使用。

顾名思义，likely()指“很有可能”之意，而unlikely()指“不太可能”之意。那么，在实际应用中，它们代表什么？又是怎么使用的呢？下面是一篇外文翻译（加上了本人的一些理解），给出了详细答案。

 

4. likely()和unlikely()

对于linux内核代码，在条件判断语句中经常看到likely()和unlikely()的调用，如下代码所示：

  1. #define likely(x)      __builtin_expect(!!(x), 1)
  2. #define unlikely(x)    __builtin_expect(!!(x), 0)
  3.  
  4. bvl = bvec_alloc(gfp_mask, nr_iovecs, &idx);
  5. if (unlikely(!bvl)) 
  6. {
  7.   mempool_free(bio, bio_pool);
  8.   bio = NULL;
  9.   goto out;
  10.  
  11. }

在这里，调用likely()或unlikely()告诉编译器这个条件很有可能或者不太有可能发生，好让编译器对这个条件判断进行正确地优化。这两个宏在include/linux/compiler.h文件中可以找到：

在GCC文档中可找到上述代码中__builtin_expect的说明，摘录如下：

  1. -- Built-in Function: long __builtin_expect (long EXP, long C)
  2.     You may use `__builtin_expect' to provide the compiler with branch
  3.     prediction information.  In general, you should prefer to use
  4.     actual profile feedback for this (`-fprofile-arcs'), as
  5.     programmers are notoriously bad at predicting how their programs
  6.     actually perform.  However, there are applications in which this
  7.     data is hard to collect.
  9.     The return value is the value of EXP, which should be an integral
  10.     expression.  The value of C must be a compile-time constant.  The
  11.     semantics of the built-in are that it is expected that EXP == C.
  12.     For example:
  14.          if (__builtin_expect (x, 0))
  15.            foo ();
  17.     would indicate that we do not expect to call `foo', since we
  18.     expect `x' to be zero.  Since you are limited to integral
  19.     expressions for EXP, you should use constructions such as
  21.          if (__builtin_expect (ptr != NULL, 1))
  22.            error ();
  24.     when testing pointer or floating-point values.

__builtin_expect说明中给出了两示例：

if (__builtin_expect (x, 0)) foo ();

表示期望x == 0，也就是不期望不执行foo()函数；

同理，if (__builtin_expect (ptr != NULL, 1)) error ();

表示期望指针prt非空，也就是不期望看到error()函数的执行。

编译器做的优化工作

从GCC的说明中可知，__builtin_expect的主要作用就是：帮助编译器判断条件跳转的预期值，避免因执行jmp跳转指令造成时间浪费。那么它是怎么帮助编译器进行优化的呢？

编译器优化时，根据条件跳转的预期值，按正确地顺序生成汇编代码，把“很有可能发生”的条件分支放在顺序执行指令段，而不是jmp指令段（jmp指令会打乱CPU的指令执行顺序，大大影响CPU指令执行效率）。

下面举例说明。下面这个简单的C程序使用gcc -O2进行编译。

  1. #define likely(x)    __builtin_expect(!!(x), 1)
  2. #define unlikely(x)  __builtin_expect(!!(x), 0)
  3.  
  4. int main(char *argv[], int argc)
  5. {
  6.    int a;
  7.  
  8.    /* 获取输入参数值（编译器不能进行优化） */
  9.    a = atoi (argv[1]);
  10.  
  11.    if (unlikely (a == 2))
  12.       a++;
  13.    else
  14.       a--;
  15.  
  16.    printf ("%d\n", a);
  17.  
  18.    return 0;
  19. }

使用objdump -S反汇编，查看它的汇编代码。

  1. 080483b0 <main>:
  2.  //             开头
  3.  80483b0:       55                      push   %ebp
  4.  80483b1:       89 e5                   mov    %esp,%ebp
  5.  80483b3:       50                      push   %eax
  6.  80483b4:       50                      push   %eax
  7.  80483b5:       83 e4 f0                and    $0xfffffff0,%esp
  8.  //             调用atoi()
  9.  80483b8:       8b 45 08                mov    0x8(%ebp),%eax
  10.  80483bb:       83 ec 1c                sub    $0x1c,%esp
  11.  80483be:       8b 48 04                mov    0x4(%eax),%ecx
  12.  80483c1:       51                      push   %ecx
  13.  80483c2:       e8 1d ff ff ff          call   80482e4 <atoi@plt>
  14.  80483c7:       83 c4 10                add    $0x10,%esp
  15.  //             把输入值与2进行比较，即执行：“a == 2”
  16.  80483ca:       83 f8 02                cmp    $0x2,%eax
  17.  //             --------------------------------------------------------
  18.  //             如果'a' 等于 2 (程序里面认为不太可能), 则跳转,
  19.  //             否则继续执行, 从而不破坏CPU的指令执行顺序.
  20.  //             --------------------------------------------------------
  21.  80483cd:       74 12                   je     80483e1 <main+0x31>
  22.  80483cf:       48                      dec    %eax
  23.  //             调用printf
  24.  80483d0:       52                      push   %edx
  25.  80483d1:       52                      push   %edx
  26.  80483d2:       50                      push   %eax
  27.  80483d3:       68 c8 84 04 08          push   $0x80484c8
  28.  80483d8:       e8 f7 fe ff ff          call   80482d4 <printf@plt>
  29.  //             返回0并退出.
  30.  80483dd:       31 c0                   xor    %eax,%eax
  31.  80483df:       c9                      leave
  32.  80483e0:       c3                      ret

在上面程序中，用likely()代替其中的unlikely()，重新编译，再来看它的汇编代码：

  1. 080483b0 <main>:
  2.  //             开头
  3.  80483b0:       55                      push   %ebp
  4.  80483b1:       89 e5                   mov    %esp,%ebp
  5.  80483b3:       50                      push   %eax
  6.  80483b4:       50                      push   %eax
  7.  80483b5:       83 e4 f0                and    $0xfffffff0,%esp
  8.  //             调用atoi()
  9.  80483b8:       8b 45 08                mov    0x8(%ebp),%eax
  10.  80483bb:       83 ec 1c                sub    $0x1c,%esp
  11.  80483be:       8b 48 04                mov    0x4(%eax),%ecx
  12.  80483c1:       51                      push   %ecx
  13.  80483c2:       e8 1d ff ff ff          call   80482e4 <atoi@plt>
  14.  80483c7:       83 c4 10                add    $0x10,%esp
  15.  //             --------------------------------------------------
  16.  //             如果'a' 等于 2 (程序认为很有可能), 则不跳转，继续执行，
  17.  //             这样就不破坏CPU的指令执行顺序. 
  18.  //             只有当 a != 2 时才会发生跳转, 而这种情况，程序认为是不太可能的.
  19.  //             ---------------------------------------------------
  20.  80483ca:       83 f8 02                cmp    $0x2,%eax
  21.  80483cd:       75 13                   jne    80483e2 <main+0x32>
  22.  //             a++ 指令的优化
  23.  80483cf:       b0 03                   mov    $0x3,%al
  24.  //             调用printf()
  25.  80483d1:       52                      push   %edx
  26.  80483d2:       52                      push   %edx
  27.  80483d3:       50                      push   %eax
  28.  80483d4:       68 c8 84 04 08          push   $0x80484c8
  29.  80483d9:       e8 f6 fe ff ff          call   80482d4 <printf@plt>
  30.  //             返回0并退出.
  31.  80483de:       31 c0                   xor    %eax,%eax
  32.  80483e0:       c9                      leave
  33.  80483e1:       c3                      ret

如何使用？

在一个条件判断语句中，当这个条件被认为是非常非常有可能满足时，则使用likely()宏，否则，条件非常非常不可能或很难满足时，则使用unlikely()宏。

参考资料

本文英文原文：http://kernelnewbies.org/FAQ/LikelyUnlikely

更多GCC内置宏或函数，详见：http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/333826
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号