前言

　内核版本：linux 4.9.x。在linux内核中，经常可以看见if( likely(x))或if( unlikely(x))的语句，本文将基于likely和unlikely的定义和作用进行一些简单的描述。

1. __builtin_expect 说明
2. likely和unlikely的说明
- 2.1 likely和unlikely函数的定义
- 2.2 likely和unlikely的高频使用方式
3. 汇编层理解
4. 汇编test和je组合解释

1. __builtin_expect 说明

1.1 __builtin_expect函数的声明

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

long __builtin_expect(long exp, long c);

1.2 __builtin_expect函数引入的背景

　　由于大部分程序员在分支预测方面做得很糟糕，所以GCC 提供了这个内建函数来帮助程序员处理分支预测。它的作用是期望表达式exp的值等于c（如果exp == c条件成立的机会占绝大多数，那么性能将会得到提升，否则性能反而会下降），原因如下：
GCC在编译过程中，会将可能性更大的代码紧跟着前面的代码，从而减少指令跳转带来的性能上的下降, 达到优化程序的目的：
（1）__builtin_expect函数用来引导gcc进行条件分支预测。在一条指令执行时，由于流水线的作用，CPU可以同时完成下一条指令的取指，这样可以提高CPU的利用率。在执行条件分支指令时，CPU也会预取下一条执行，但是如果条件分支的结果为跳转到了其他指令，那CPU预取的下一条指令就没用了，这样就降低了流水线的效率。
（2）另外，跳转指令相对于顺序执行的指令会多消耗CPU时间，如果可以尽可能不执行跳转，也可以提高CPU性能。

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

　注意， __builtin_expect (lexp, c)的返回值仍是exp值本身，并不会改变exp的值。

1.3 RATIONALE(原理)

if else 句型编译后, 一个分支的汇编代码紧随前面的代码,而另一个分支的汇编代码需要使用JMP指令才能访问到。显然，通过JMP访问需要更多的时间, 在复杂的程序中,有很多的if else句型,又或者是一个有if else句型的库函数,每秒钟被调用几万次，通常程序员在分支预测方面做得很糟糕, 编译器又不能精准的预测每一个分支,这时JMP产生的时间浪费就会很大,函数__builtin_expert()就是用来解决这个问题的。

2. likely和unlikely的说明

2.1 likely和unlikely函数的定义

参考/include/linux/compiler.h */

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

上述源码中采用了内建函数__builtin_expect来进行定义，即 built in function。

2.2 likely和unlikely的高频使用方式

在内核中经常看到如下的定义：

if(likely(x)){
	......
}else{
	......
}

if(unlikely(x))
{
	......
}else{
	......
}

展开后就等价于

if(__builtin_expect(!!(x), 1)){//期望x为真，x是逻辑真（1）的可能性比较大
	......
}else{
	......
}

if(__builtin_expect(!!(x), 0))//期望x为假，x是逻辑假（0）的可能性比较大
{
	......
}else{
	......
}

首选先要明白的是：

if(likely(x))    //等价于   if(x)
if(unlikely(x))  //也等价于 if(x)

　　从表面上看。 likely和unlikely是一样的，但是实际上执行是不同的，加likely的意思是x的值为真的可能性更大一些，也就是执行if的机会大，而unlikely表示x的值为假的可能性大一些，也就是执行else机会大一些。
　　加上这种修饰，编译成二进制代码时likely使得if后面的执行语句紧跟着前面的程序，unlikely使得else后面的语句紧跟着前面的程序，这样就会被cache预读取，增加程序的执行速度。
　　
上述定义中为什么要使用 "!!" 符号呢？
　　计算机中bool逻辑只有0和1，非0即是1，当likely(x)中参数不是逻辑值时，就可以使用 "!!" 符号转化为逻辑值1或0 。
　　

3. 汇编层理解

3.1 likely的例子

3.1.1 likely例子的代码

#include <stdlib.h>
#include <stdio.h>
#define unlikely(x)  (__builtin_expect(!!(x), 0))
#define likely(x)    (__builtin_expect(!!(x), 1))

int likely_func(int x)
{
	if (likely(x))
	{
		x = 0x123;
	}
	else
	{
		x = 0x456;
	}
	
	return x;
}

int main(char *argv[], int argc)
{
	likely_func(1);
    return 0;
}

3.1.2 编译选项

gcc -fprofile-arcs -O2 -c test.c

-fprofile-arcs -ftest-coverage 选项的使用

3.1.3反汇编likely_func片段

0000000000000000 <likely_func>:
   0:   f3 0f 1e fa             endbr64
   4:   48 83 05 00 00 00 00    addq   $0x1,0x0(%rip)        # c <likely_func+0xc>
   b:   01
   c:   b8 23 01 00 00          mov    $0x123,%eax           // 优先执行语句为if分支
  11:   85 ff                   test   %edi,%edi             //测试传入参数是否为0    
  13:   74 0b                   je     20 <likely_func+0x20> //若参数为0，则跳转
  15:   c3                      retq
  16:   66 2e 0f 1f 84 00 00    nopw   %cs:0x0(%rax,%rax,1)
  1d:   00 00 00
  20:   48 83 05 00 00 00 00    addq   $0x1,0x0(%rip)        # 28 <likely_func+0x28>
  27:   01
  28:   b8 56 04 00 00          mov    $0x456,%eax
  2d:   c3                      retq

test %edi %edi测试了传入的参数x是否为0。若结果为0，ZF=1语句je执行跳转。但是这里是likely,也就是x参数大部分是1的情况。所以这里避免了大部分的跳转。
过程使用 ret(从过程返回)，q是64位的意思。

3.2 unlikely的例子

3.2.1 unlikely例子的代码

#include <stdlib.h>
#include <stdio.h>
#define unlikely(x)  (__builtin_expect(!!(x), 0))
#define likely(x)    (__builtin_expect(!!(x), 1))

int unlikely_func(int x)
{
	if (unlikely(x))
	{
		x = 0x123;
	}
	else
	{
		x = 0x456;
	}
	
	return x;
}

int main(char *argv[], int argc)
{
	unlikely_func(1);
    return 0;
}

3.2.2 unlikely的编译选项

gcc -fprofile-arcs -O2 -c test.c

-fprofile-arcs -ftest-coverage 选项的使用

要声明一点的是：likely(x)用于x为真的可能性更大的场景，unlikey(x)用于x为假的可能性更大的场景，这两个宏的最终目的就是尽量减少跳转，因为只要跳转，pipeline就会flush，就会降低效率。想让上面的优化生效的话，需要指定一定的优化等级，因为默认是-O0，没有任何优化（一定要指定等级，您可以自己反汇编看一下编译选项加不加 -Ox的区别）。

3.2.3 反汇编unlikely_func片段

0000000000000000 <unlikely_func>:
   0:   f3 0f 1e fa             endbr64
   4:   85 ff                   test   %edi,%edi            //测试传入参数是否为0 
   6:   75 18                   jne    20 <unlikely_func+0x20>   //若参数不为0，则跳转
   8:   48 83 05 00 00 00 00    addq   $0x1,0x0(%rip)        # 10 <unlikely_func+0x10>
   f:   01
  10:   b8 56 04 00 00          mov    $0x456,%eax         // 优先执行语句为else分支
  15:   c3                      retq 
  16:   66 2e 0f 1f 84 00 00    nopw   %cs:0x0(%rax,%rax,1)
  1d:   00 00 00
  20:   48 83 05 00 00 00 00    addq   $0x1,0x0(%rip)        # 28 <unlikely_func+0x28>
  27:   01
  28:   b8 23 01 00 00          mov    $0x123,%eax
  2d:   c3                      retq

test %edi %edi测试了传入的参数x是否为0。若结果为0，ZF=1，语句jne不执行跳转。
- 过程使用 ret(从过程返回)，q是64位的意思。

3.3 if(likely(x)) 与 if(x) 在性能上的差异（针对博友的提问补充）

3.3.1 if(likely(x)) 例子的代码

#include <stdlib.h>
#include <stdio.h>
#define unlikely(x)  (__builtin_expect(!!(x), 0))
#define likely(x)    (__builtin_expect(!!(x), 1))

int likely_func(int x)
{
	if (likely(x))
	{
		x = 0x123;
	}
	else
	{
		x = 0x456;
	}
	
	return x;
}

int main(char *argv[], int argc)
{
	likely_func(1);
    return 0;
}

3.3.2 if(x) 例子的代码

#include <stdlib.h>
#include <stdio.h>
#define unlikely(x)  (__builtin_expect(!!(x), 0))
#define likely(x)    (__builtin_expect(!!(x), 1))

int likely_func(int x)
{
	if (x)
	{
		x = 0x123;
	}
	else
	{
		x = 0x456;
	}
	
	return x;
}

int main(char *argv[], int argc)
{
	likely_func(1);
    return 0;
}

3.3.3 编译选项

gcc -fprofile-arcs -O2 -c test.c

3.3.4 区别分析

在这里插入图片描述
可以清晰的看到：虽然if(x)与if (likely(x))功能相同，但是对于x为真的情况下， if(x)要返回，要经过跳转操作才能调用retq返回指令 。比if (likely(x))多了一次跳转指令。

4. 汇编test和je组合解释

test 指令用于两个操作数的按位AND运算，并根据结果设置标志寄存器，结果本身不会写回到目的操作数。

1. AND 运算结果为0时， ZF(zero flag)置位；
2. test可以影响CF，OF，PF，SF，ZF标志位；
3. 两个操作数相等，同时为0时，AND 结果为0， 此时ZF置位。

je 指令【Jump if Equals】在ZF被置位时跳转。je 是 jz 【Jump if Zero】的别名。

test 和 je 常用组合范例：

TEST EAX,EAX 
JE target_address

这段代码的含义是：
如果EAX==0,就跳转到”target_address”。