Linux Kernel中的LIKELY和UNLIKELY

最新推荐文章于 2019-10-27 23:54:59 发布

yuntongsf

最新推荐文章于 2019-10-27 23:54:59 发布

阅读量556

点赞数

摘自：http://www.crazyshell.org/blog/?p=511

Linux Kernel中的LIKELY和UNLIKELY

发布于 2012/08/22 由 crazybaby

190 人浏览暂无评论发表评论

常看到内核中的代码如下:

 
/* Note: the chip doesn't have auto-pad! */
 
        if  (likely(len < TX_BUF_SIZE)) {
 
                if  (len < ETH_ZLEN)
 
                    memset(tp->tx_buf[entry], 0, ETH_ZLEN);
 
                skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);
 
                dev_kfree_skb(skb);
 
        } else  {
 
                dev_kfree_skb(skb);
 
                dev->stats.tx_dropped++;
 
                return  NETDEV_TX_OK;
 
        }
 
/* We received data from the HW, so stop the watchdog */
 
        if  (unlikely
 
            (len + IL39_RX_FRAME_SIZE >
 
             PAGE_SIZE << il->hw_params.rx_page_order)) {
 
                D_DROP("Corruption detected!\n");
 
                return;
 
        }

如果你眼睛够细会看到likely 和 unlikely 这样的词. 在内核中它应该不是函数, 要是函数也应该是inline, 不过我觉得它更应该是一个宏
通过SI读源码, 可以看到它们被定义如下:

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

__builtin_expect作用是gcc内建的一条指令的优化,在一个条件经常出现, 或者该条件很少出现的时候, 编译后可以根据这条指令对条件分支选择优化

__builtin_expect((x),1)的意思是

 
if  (__builtin_expect(!!(x),1)) {
 
 
 
} else  {
 
 
 
}

表示这个if里面为真, 程序大多数直接执行if里面的程序

__builtin_expect((x),0) 则和上面相反直接执行else里面的程序.

来看段程序:

 
#define LIKELY(x)    __builtin_expect(!!(x), 1)
 
#define UNLIKELY(x)  __builtin_expect(!!(x), 0)
 
 
 
int  likely(int  x) {
 
 
 
        if  (LIKELY(x)) {
 
                x = 1;
 
        } else  {
 
                x = 2;
 
        }
 
        return  x;
 
}
 
 
 
int  unlikely(int  x) {
 
 
 
        if  (UNLIKELY(x)) {
 
                x = 1;
 
        } else  {
 
                x = 2;
 
        }
 
        return  x;
 
}
 
 
 
int  main() {
 
 
 
        likely(1);
 
        unlikely(2);
 
}

然后看它汇编代码, 使用gcc -O2 -fprofile-arcs 来进行编.

 
Disassembly of section .text:
 
 
 
0000000000000000 :
 
   0:   48 83 05 00 00 00 00    addq   $0x1,0x0(%rip)        # 8
 
   7:   01
 
   8:   85 ff                   test   %edi,%edi
 
   a:   74 06                   je     12
 
   c:   b8 01 00 00 00          mov    $0x1,%eax
 
  11:   c3                      retq
 
  12:   48 83 05 00 00 00 00    addq   $0x1,0x0(%rip)        # 1a
 
  19:   01
 
  1a:   b8 02 00 00 00          mov    $0x2,%eax
 
  1f:   c3                      retq
 
 
 
0000000000000020 :
 
  20:   48 83 05 00 00 00 00    addq   $0x1,0x0(%rip)        # 28
 
  27:   01
 
  28:   85 ff                   test   %edi,%edi
 
  2a:   75 0e                   jne    3a
 
  2c:   48 83 05 00 00 00 00    addq   $0x1,0x0(%rip)        # 34
 
  33:   01
 
  34:   b8 02 00 00 00          mov    $0x2,%eax
 
  39:   c3                      retq
 
  3a:   b8 01 00 00 00          mov    $0x1,%eax
 
  3f:   c3                      retq

可以看出相同的程序,不同的likely的情况下, 程序分别使用了je和jne进行了优化.
对于编译代码的时候使用-fprofile-arcs , 原因如下:

Built-in Function: long __builtin_expect (long exp, long c)
You may use __builtin_expect to provide the compiler with branch prediction information. In general, you should prefer to use actual profile feedback for this (-fprofile-arcs), as programmers are notoriously bad at predicting how their programs actually perform. However, there are applications in which this data is hard to collect.

The return value is the value of exp, which should be an integral expression. The semantics of the built-in are that it is expected that exp == c. For example:

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

would indicate that we do not expect to call foo, since we expect x to be zero. Since you are limited to integral expressions for exp, you should use constructions such as

if (__builtin_expect (ptr != NULL, 1))
foo (*ptr);

when testing pointer or floating-point values.

原创文章,转载请注明出处: http://www.crazyshell.org/blog/?p=511