Home/ Questions/Q 426919
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-12T19:31:38+00:00

Sometimes a loop where the CPU spends most of the time has some branch

  • 0

Sometimes a loop where the CPU spends most of the time has some branch prediction miss (misprediction) very often (near .5 probability.) I’ve seen a few techniques on very isolated threads but never a list. The ones I know already fix situations where the condition can be turned to a bool and that 0/1 is used in some way to change. Are there other conditional branches that can be avoided?

e.g. (pseudocode)

loop () {
  if (in[i] < C )
    out[o++] = in[i++]
  ...
}

Can be rewritten, arguably losing some readability, with something like this:

loop() {
  out[o] = in[i]  // copy anyway, just don't increment
  inc = in[i] < C  // increment counters? (0 or 1)
  o += inc
  i += inc
}

Also I’ve seen techniques in the wild changing && to & in the conditional in certain contexts escaping my mind right now. I’m a rookie at this level of optimization but it sure feels like there’s got to be more.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    I believe the most common way to avoid branching is to leverage bit parallelism in reducing the total jumps present in your code. The longer the basic blocks, the less often the pipeline is flushed.

    As someone else has mentioned, if you want to do more than unrolling loops, and providing branch hints, you’re going to want to drop into assembly. Of course this should be done with utmost caution: your typical compiler can write better assembly in most cases than a human. Your best hope is to shave off rough edges, and make assumptions that the compiler cannot deduce.

    Here’s an example of the following C code:

    if (b > a) b = a;

    In assembly without any jumps, by using bit-manipulation (and extreme commenting):

    sub eax, ebx ; = a - b
sbb edx, edx ; = (b > a) ? 0xFFFFFFFF : 0
and edx, eax ; = (b > a) ? a - b : 0
add ebx, edx ; b = (b > a) ? b + (a - b) : b + 0

    Note that while conditional moves are immediately jumped on by assembly enthusiasts, that’s only because they’re easily understood and provide a higher level language concept in a convenient single instruction. They are not necessarily faster, not available on older processors, and by mapping your C code into corresponding conditional move instructions you’re just doing the work of the compiler.

    • 0