Is there any portable way of doing branch prediction hints? Consider the following example:
if (unlikely_condition) { /* ..A.. */ } else { /* ..B.. */ } Is this any different than doing:
if (!unlikely_condition) { /* ..B.. */ } else { /* ..A.. */ } Or is the only way to use compiler specific hints? (e.g. __builtin_expect on GCC)
Will compilers treat the if conditions any differently based on the ordering of the conditions?
The canonical way to do static branch prediction is that if is predicted not-branched (i.e. every if clause is executed, not else), and loops and backward-gotos are taken. So, don't put the common case in else if you expect static prediction to be significant. Getting around an untaken loop isn't as easy; I've never tried but I suppose putting it an an else clause should work pretty portably.
Many compilers support some form of #pragma unroll, but it will still be necessary to guard it with some kind of #if to protect other compilers.
Branch prediction hints can theoretically express a complete description of how to transform a program's flow-control graph and arrange the basic blocks in executable memory… so there are a variety of things to express, and most won't be very portable.
As GNU recommends in the documentation for __builtin_expect, profile-guided optimization is superior to hints, and with less effort.
In most cases, the following code
if (a) { ... } else { ... } is actually
evaluate(A) if (!A) { jmp p1 } ... code A jmp p2 p1: ... code !A p2: Note that if A is true, "code A" is already in the pipeline. The processor will see the "jmp p2" command ahead, and will load p2 code to the pipeline.
If A is false, the "code !A" may not be in the pipleline, therefore it may be slower.
Conclusions:
:
evaluate(A) do more stuff if (A) ... 
C++20 offers likely and unlikely attributes
Allow the compiler to optimize for the case where paths of execution including that statement are more or less likely than any alternative path of execution that does not include such a statement
Optimization is inherently a compiler thing, so you have to use compiler functionality to help it. The language itself doesn't care about (or mandate) optimizations.
So the best you can do without compiler-specific extensions is organize your code in such a way where your compilers will "do the right thing" without help. But if you want to be sure, tap in to compiler extensions. (You might try abstracting them behind the preprocessor, so your code remains portable.)
inline, restrict, register). Some are more pointful than others on modern compilers. It doesn't matter whether a particular implementation actually does anything with them: if there's a reasonable chance of some doing something useful, then it would be a nice feature. I reckon static branch prediction in the main doesn't meet that criterion, so I don't think it's a bad call to leave it out. It is a judgement on the merits of the case, though, not quite "we don't care about optimisation, ever".restrict is probably worthwhile as a premature optimisation. It's not going to do any harm, it might do significant good by preventing horrible store/load dependencies, and where it applies it's presumably a documented requirement (as in memcpy) whether that's reflected in the source or not. The others (and in C++03), I agree with your resounding "meh" :-)restrict since it's not part of the current standard. :)What's wrong with checking for a specific compiler via #ifdef and hiding these things behind a custom macro? You can #define it to expand to the plain expression in cases you don't have a compiler that supports these optimization hints. I recently did something similar with explicit cache prefetches which GCC supports via an intrinsic function.
Just be consistant with what you do. I like to use
if (!(someExpression)) But the compiler should treat this equally.
if? Likeif([[unlikely]] unlikely_condition) { ... }? Currently the syntax does not allow it. It does however allowif([[unlikely]] bool b = ...) { }. Maybe one could abuse that :)if(likely(...))junk in completely non-performance-critical code, and IMO this is really bad. For one thing, it doesn't read naturally in English - it sounds like "if this condition is likely to be true" instead of "if this condition is true, which it likely is". And for another, it's just clutter. Unless you have lots of performance-critical conditionals that won't compile tocmovor similar already, just ignore branch prediction hinting.if(unlikely(...)). They prefer early exits that make code flow easier to follow. If they did not do this then the static branch prediction would always fail.