Question

I’ve been digging through some parts of the Linux kernel, and found calls like this:

if (unlikely(fd < 0)) {     /* Do something */ } 

or

if (likely(!err)) {     /* Do something */ } 

I’ve found the definition of them:

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

I know that they are for optimization, but how do they work? And how much performance/size decrease can be expected from using them? And is it worth the hassle (and losing the portability probably) at least in bottleneck code (in userspace, of course).

Answer 1

They are hint to the compiler to emit instructions that will cause branch prediction to favour the "likely" side of a jump instruction. This can be a big win, if the prediction is correct it means that the jump instruction is basically free and will take zero cycles. On the other hand if the prediction is wrong, then it means the processor pipeline needs to be flushed and it can cost several cycles. So long as the prediction is correct most of the time, this will tend to be good for performance.

Like all such performance optimisations you should only do it after extensive profiling to ensure the code really is in a bottleneck, and probably given the micro nature, that it is being run in a tight loop. Generally the Linux developers are pretty experienced so I would imagine they would have done that. They don’t really care too much about portability as they only target gcc, and they have a very close idea of the assembly they want it to generate.

---

Note that most ISAs don’t have a way for the machine code to actually hint the hardware branch predictor, other than static prediction (backward taken / forward not-taken) on some. And on modern implementations like x86 since 2013 or so, even that’s not a thing anymore:

• Why did Intel change the static branch prediction mechanism over these years?
• Is it possible to tell the branch predictor how likely it is to follow the branch? (on most ISA,s no)

The likely and unlikely macros or C++ [[likely]] / [[unlikely]] annotations can hint the compiler’s branch layout to favour I-cache locality for the fast path, and minimize taken branches on the fast path. Also to hint the decision to make branchy vs. branchless asm when that’s possible.